#ifndef MESH_H
#define MESH_H


#include <vector>

#include "geometry.h"


class Mesh {
public:
    class Vertex {
    public:
        Vector3 pos;
        Vector3 normal;
        explicit inline Vertex(const Vector3 &pos = Vector3(), const Vector3 &normal = Vector3()):
            pos(pos), normal(normal) { }
    };
    
    class Triangle {
    public:
        int v[3];
        explicit inline Triangle(int v0 = 0, int v1 = 0, int v2 = 0)
            { v[0] = v0; v[1] = v1; v[2] = v2; }
    };

    typedef std::vector<Vertex> VertexList;
    typedef std::vector<Triangle> TriangleList;
    
    VertexList vertices;
    TriangleList triangles;
    
    mutable unsigned int vbuf, ibuf, elements;

    inline Mesh(): vbuf(), ibuf() { }
    inline ~Mesh() { dirty(); }
    
    void createbuf() const;
    void dirty() const;
    void clear();
    void draw() const;
};


class LinkedMesh {
public:
    class Vertex {
    public:
        Vector3 pos;
        Real value;
        explicit inline Vertex(const Vector3 &pos = Vector3(), Real value = Real()):
            pos(pos), value(value) { }
    };
    
    class Edge {
    public:
        int v[3];
        int e[2];
        explicit inline Edge(int v0 = 0, int v2 = 0)
            { v[0] = v0; v[1] = -1; v[2] = v2; e[0] = 0; e[1] = 0; }
    };

    class Triangle {
    public:
        int e[3];
        bool d[3];
        explicit inline Triangle(
            int e0 = 0, bool d0 = false,
            int e1 = 0, bool d1 = false,
            int e2 = 0, bool d2 = false )
        {
            e[0] = e0; e[1] = e1; e[2] = e2;
            d[0] = d0; d[1] = d1; d[2] = d2;
        }
    };
    
    class Level {
    public:
        Real k;
        int vertex0, vertex1;
        int edge0, edge1;
        int triangle0, triangle1;
        Level():
            k(1),
            vertex0(), vertex1(),
            edge0(), edge1(),
            triangle0(), triangle1() { }
    };
    
    typedef std::vector<Vertex> VertexList;
    typedef std::vector<Edge> EdgeList;
    typedef std::vector<Triangle> TriangleList;
    typedef std::vector<Level> LevelList;
    typedef Vector3 (*VertexFunc)(const Vertex&, Real, Real);
    

    VertexList vertices;
    EdgeList edges;
    TriangleList triangles;
    LevelList levels;

    
    static Vertex average(const Vertex &a, const Vertex &b);
    static Vector3 sphere_func(const Vertex &v, Real r, Real kr);
    static Vector3 z_func(const Vertex &v, Real r, Real kr);

    static Real random();
    
    void check() const;
    
    void clear();
    void next_level(Real k);
    void generate_level(Real k = sqrt2);
    void generate_levels(int count, Real k = sqrt2);
    void smooth();
    void smooth(int count);
    
    void triangle(Real k = 1);
    void tetrahedron(Real k = 1);
    void icosahedron(Real k = 1);
    
    void to_mesh(Mesh &mesh, VertexFunc func, Real r = 0, Real kr = 1, int level = -1) const;

    inline void to_sphere_mesh(Mesh &mesh, Real r = 1, Real kr = 0.5, int level = -1) const
        { to_mesh(mesh, &sphere_func, r, kr, level); }
    inline void to_z_mesh(Mesh &mesh, Real r = 0, Real kr = 1, int level = -1) const
        { to_mesh(mesh, &z_func, r, kr, level); }
};


#endif