#include <cassert></cassert>

#include <cstdlib></cstdlib>

#include <algorithm></algorithm>

#include <map></map>

#include <gl gl.h=""></gl>

#include <gl glext.h=""></gl>

#include "mesh.h"

void Mesh::createbuf() const {

    if (ibuf && vbuf && elements) return;

    dirty();

    if (vertices.empty() || triangles.empty()) return;

    glGenBuffers(1, &vbuf);

    glBindBuffer(GL_ARRAY_BUFFER, vbuf);

    glBufferData(GL_ARRAY_BUFFER, sizeof(Vertex)*vertices.size(), &vertices.front(), GL_STATIC_DRAW);

    glBindBuffer(GL_ARRAY_BUFFER, 0);

    glGenBuffers(1, &ibuf);

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibuf);

    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(Triangle)*triangles.size(), &triangles.front(), GL_STATIC_DRAW);

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

    elements = triangles.size()*3u;

}

void Mesh::dirty() const {

    if (ibuf) { glDeleteBuffers(1, &ibuf); ibuf = 0; }

    if (vbuf) { glDeleteBuffers(1, &vbuf); vbuf = 0; }

    elements = 0;

}

void Mesh::clear() {

    dirty();

    triangles.clear();

    vertices.clear();

}

void Mesh::draw() const {

    createbuf();

    if (!elements) return;

    glBindBuffer(GL_ARRAY_BUFFER, vbuf);

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibuf);

    glEnableClientState(GL_VERTEX_ARRAY);

    glEnableClientState(GL_NORMAL_ARRAY);

    glVertexPointer(3, GL_DOUBLE, sizeof(Vertex), 0);

    glNormalPointer(GL_DOUBLE, sizeof(Vertex), (void*)sizeof(Vector3));

    glDrawElements(GL_TRIANGLES, elements, GL_UNSIGNED_INT, 0);

    glDisableClientState(GL_VERTEX_ARRAY);

    glDisableClientState(GL_NORMAL_ARRAY);

    glBindBuffer(GL_ARRAY_BUFFER, 0);

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

    //glBegin(GL_TRIANGLES);

    //for(TriangleList::const_iterator i = triangles.begin(); i != triangles.end(); ++i) {

    //    for(int j = 0; j < 3; ++j) {

    //        glNormal3dv(vertices[ i->v[j] ].normal.c);

    //        glVertex3dv(vertices[ i->v[j] ].pos.c);

    //    }

    //}

    //glEnd();

}

LinkedMesh::Vertex LinkedMesh::average(const Vertex &a, const Vertex &b)

    { return Vertex((a.pos + b.pos)*0.5, (a.value + b.value)*0.5); }

Vector3 LinkedMesh::sphere_func(const Vertex &v, Real r, Real kr)

    { return v.pos.norm()*r*pow(1+kr, v.value); }

Vector3 LinkedMesh::z_func(const Vertex &v, Real r, Real kr)

    { return Vector3(v.pos.x, v.pos.y, v.pos.z + v.value*kr + r); }

Real LinkedMesh::random()

    { return real_random2(); }

void LinkedMesh::clear() {

    levels.clear();

    triangles.clear();

    edges.clear();

    vertices.clear();

}

void LinkedMesh::next_level(Real k) {

    Level level;

    if (!levels.empty()) {

        const Level &l = levels.back();

        level.k = l.k;

        level.vertex0 = l.vertex1;

        level.edge0 = l.edge1;

        level.triangle0 = l.triangle1;

    }

    level.k *= k;

    level.vertex1 = (int)vertices.size();

    level.edge1 = (int)edges.size();

    level.triangle1 = (int)triangles.size();

    assert(level.vertex0 <= level.vertex1);

    assert(level.edge0 <= level.edge1);

    assert(level.triangle0 <= level.triangle1);

    levels.push_back(level);

    check();

}

void LinkedMesh::check() const {

    if (levels.empty()) {

        assert(vertices.empty());

        assert(edges.empty());

        assert(triangles.empty());

    }

    for(int li = 0; li < (int)levels.size(); ++li) {

        const bool last_level = (li == (int)levels.size() - 1);

        const Level &l = levels[li];

        const Level pl = li ? levels[li - 1] : Level();

        const Level nl = last_level ? Level() : levels[li + 1];

        assert(l.k >= 0);

        assert(l.k <= pl.k);

        assert(l.vertex0 == pl.vertex1);

        assert(l.edge0 == pl.edge1);

        assert(l.triangle0 == pl.triangle1);

        assert(l.vertex0 >= 0);

        assert(l.edge0 >= 0);

        assert(l.triangle0 >= 0);

        assert(l.vertex1 <= (int)vertices.size());

        assert(l.edge1 <= (int)edges.size());

        assert(l.triangle1 <= (int)triangles.size());

        assert(l.vertex0 <= l.vertex1);

        assert(l.edge0 <= l.edge1);

        assert(l.triangle0 <= l.triangle1);

        if (last_level) {

            assert(l.vertex1 == (int)vertices.size());

            assert(l.edge1 == (int)edges.size());

            assert(l.triangle1 == (int)triangles.size());

        }

        for(int i = l.edge0; i < l.edge1; ++i) {

            const Edge &e = edges[i];

            if (last_level) {

                assert(e.e[0] == 0);

                assert(e.e[1] == 0);

                assert(e.v[1] == -1);

            } else {

                assert(e.e[0] != e.e[1]);

                assert(e.e[0] >= nl.edge0 && e.e[0] < nl.edge1);

                assert(e.e[1] >= nl.edge0 && e.e[1] < nl.edge1);

                assert(e.v[1] >= nl.vertex0 && e.v[1] < nl.vertex1);

            }

            assert(e.v[0] != e.v[1]);

            assert(e.v[0] >= 0 && e.v[0] < l.vertex1);

            assert(e.v[2] >= 0 && e.v[2] < l.vertex1);

        }

        for(int i = l.triangle0; i < l.triangle1; ++i) {

            const Triangle &t = triangles[i];

            for(int j = 0; j < 3; ++j) {

                int jj = (j+1)%3;

                assert(t.e[j] >= l.edge0 && t.e[j] < l.edge1);

                assert(edges[ t.e[j] ].v[ t.d[j] ? 0 : 2 ] == edges[ t.e[jj] ].v[ t.d[jj] ? 2 : 0 ]);

            }

        }

    }

}

void LinkedMesh::generate_level(Real k) {

    const Level level = levels.empty() ? Level() : levels.back();

    const Real kk = level.k * k;

    for(int i = level.triangle0; i < level.triangle1; ++i) {

        Triangle t = triangles[i];

        Edge ee[3];

        for(int j = 0; j < 3; ++j) {

            Edge &e = edges[t.e[j]];

            if (e.v[1] < 0) {

                Vertex v = average( vertices[e.v[0]], vertices[e.v[2]] );

                v.value += random()*kk;

                e.v[1] = (int)vertices.size();

                vertices.push_back(v);

                e.e[0] = (int)edges.size();

                e.e[1] = e.e[0] + 1;

                ee[j] = e;

                edges.push_back(Edge(ee[j].v[0], ee[j].v[1]));

                edges.push_back(Edge(ee[j].v[1], ee[j].v[2]));

            } else {

                ee[j] = e;

            }

            if (t.d[j]) {

                std::swap(ee[j].e[0], ee[j].e[1]);

                std::swap(ee[j].v[0], ee[j].v[2]);

            }

        }

        int ei = (int)edges.size();

        edges.push_back(Edge(ee[0].v[1], ee[2].v[1]));

        edges.push_back(Edge(ee[1].v[1], ee[0].v[1]));

        edges.push_back(Edge(ee[2].v[1], ee[1].v[1]));

        triangles.push_back(Triangle( ee[0].e[0], t.d[0], ei + 0, false, ee[2].e[1], t.d[2] ));

        triangles.push_back(Triangle( ee[1].e[0], t.d[1], ei + 1, false, ee[0].e[1], t.d[0] ));

        triangles.push_back(Triangle( ee[2].e[0], t.d[2], ei + 2, false, ee[1].e[1], t.d[1] ));

        triangles.push_back(Triangle( ei + 0, true, ei + 1, true, ei + 2, true ));

    }

    next_level(k);

}

void LinkedMesh::generate_levels(int count, Real k) {

    for(int i = 0; i < count; ++i)

        generate_level(k);

}

void LinkedMesh::smooth() {

    typedef std::pair<real, real=""> Sum;</real,>

    typedef std::vector<sum> SumList;</sum>

    const Level &level = levels.back();

    SumList sum;

    sum.reserve(level.vertex1);

    for(int i = 0; i < level.vertex1; ++i)

        sum.push_back(Sum(1, vertices[i].value));

    for(int i = level.edge0; i < level.edge1; ++i) {

        const Edge &e = edges[i];

        Sum &s0 = sum[e.v[0]], &s1 = sum[e.v[2]];

        s0.first += 1;

        s1.first += 1;

        s0.second += vertices[e.v[2]].value;

        s1.second += vertices[e.v[1]].value;

    }

    for(int i = 0; i < level.vertex1; ++i) {

        const Sum &s = sum[i];

        vertices[i].value = s.second/s.first;

    }

}

void LinkedMesh::smooth(int count) {

    for(int i = 0; i < count; ++i)

        smooth();

}

void LinkedMesh::to_mesh(Mesh &mesh, VertexFunc func, Real r, Real kr, int level) const {

    if (levels.empty()) return;

    if (level < 0 || level >= (int)levels.size()) level = levels.size() - 1;

    const Level &l = levels[level];

    int v0 = (int)mesh.vertices.size();

    int v1 = v0 + l.vertex1;

    mesh.vertices.reserve(v1);

    for(int i = 0; i < l.vertex1; ++i)

        mesh.vertices.push_back(Mesh::Vertex( func(vertices[i], r, kr) ));

    mesh.triangles.reserve(mesh.triangles.size() + (l.triangle1 - l.triangle0));

    for(int i = l.triangle0; i < l.triangle1; ++i) {

        const Triangle &t = triangles[i];

        Mesh::Triangle tt;

        for(int j = 0; j < 3; ++j)

            tt.v[j] = v0 + edges[t.e[j]].v[ t.d[j] ? 2 : 0 ];

        Vector3 normal = (mesh.vertices[tt.v[1]].pos - mesh.vertices[tt.v[0]].pos).cross(

                          mesh.vertices[tt.v[2]].pos - mesh.vertices[tt.v[0]].pos ).norm();

        for(int j = 0; j < 3; ++j)

            mesh.vertices[tt.v[j]].normal += normal;

        mesh.triangles.push_back(tt);

    }

    for(int i = v0; i < v1; ++i)

        mesh.vertices[i].normal = mesh.vertices[i].normal.norm();

    mesh.dirty();

}

void LinkedMesh::triangle(Real k) {

    clear();

    for(int i = 0; i < 3; ++i) {

        Real a = 2*pi/3*i;

        vertices.push_back(Vertex( Vector3(cos(a), sin(a), 0), random()*k ));

        edges.push_back(Edge(i, (i+1)%3));

    }

    triangles.push_back(Triangle(0, false, 1, false, 2, false));

    next_level(k);

}

void LinkedMesh::tetrahedron(Real k) {

    clear();

    const Real r = 2*sqrt2/3;

    const Real z = -1/Real(3);

    vertices.push_back(Vertex( Vector3(0, 0, 1), random()*k ));

    for(int i = 0; i < 3; ++i) {

        Real a = 2*pi/3*i;

        vertices.push_back(Vertex( Vector3(cos(a)*r, sin(a)*r, z), random()*k ));

        edges.push_back(Edge(0, i+1));

        edges.push_back(Edge(i+1, (i+1)%3 + 1));

        triangles.push_back(Triangle(i*2, false, i*2+1, false, (i+1)%3*2, true));

    }

    triangles.push_back(Triangle(5, true, 3, true, 1, true));

    next_level(k);

}

void LinkedMesh::icosahedron(Real k) {

    clear();

    const Real kk = 4*sin(pi/5)*sin(pi/5) - 1;

    const Real r = 2*sqrt(kk)/(kk + 1);

    const Real z = 1 - r*sqrt(kk);

    // vertices

    vertices.push_back(Vertex( Vector3(0, 0,  1), random()*k ));

    for(int i = 0; i < 5; ++i) {

        Real a = 2*pi/5*i;

        vertices.push_back(Vertex( Vector3(cos(a)*r, sin(a)*r,  z), random()*k ));

    }

    for(int i = 0; i < 5; ++i) {

        Real a = 2*pi/5*i + pi/5;

        vertices.push_back(Vertex( Vector3(cos(a)*r, sin(a)*r, -z), random()*k ));

    }

    vertices.push_back(Vertex( Vector3(0, 0, -1), random()*k ));

    // edges

    for(int i = 0; i < 5; ++i) edges.push_back(Edge(0, i+1));

    for(int i = 0; i < 5; ++i) edges.push_back(Edge(i+1, (i+1)%5 + 1));

    for(int i = 0; i < 5; ++i) edges.push_back(Edge(i+1, i+6));

    for(int i = 0; i < 5; ++i) edges.push_back(Edge(i+6, (i+1)%5 + 1));

    for(int i = 0; i < 5; ++i) edges.push_back(Edge(i+6, (i+1)%5 + 6));

    for(int i = 0; i < 5; ++i) edges.push_back(Edge(11, i+6));

    // triangles

    for(int i = 0; i < 5; ++i) {

        int ii = (i+1)%5;

        triangles.push_back(Triangle(i, false, i+5, false, ii, true));

        triangles.push_back(Triangle(i+10, false, i+15, false, i+5, true));

        triangles.push_back(Triangle(i+20, false, ii+10, true, i+15, true));

        triangles.push_back(Triangle(i+25, true, ii+25, false, i+20, true));

    }

    next_level(k);

}