import java.io.*;
import algebra.*;

/**
 * Defines a triangle based mesh.
 * A mesh is constructed by interpretting the data given in an OFF file.
 * 
 * @author smondet gg cdehais
 */
public class Mesh {

    private Vector[] vertices;
    private int[] faces;
    private double[] colors;
    private Vector3[] normals;
    private double[] texCoords;

    private static String nextLine(BufferedReader in) throws Exception {
        String r = in.readLine();

        while (r.matches("\\s*#.*")) {
            r = in.readLine();
        }
        return r;
    }

    /**
     * Builds a Mesh object by reading in an OFF file.
     * Does not support non triangular meshes.
     * 
     * @filename path to OFF file.
     */
    public Mesh(String filename) throws Exception {
        BufferedReader in = new BufferedReader(new FileReader(filename));

        String r = nextLine(in);
        if (!r.equals("OFF")) {
            throw new IOException("Invalid OFF file !");
        }

        r = nextLine(in);

        String[] sar = r.split("\\s+");

        /* Parse object properties */
        int verts_nb = new Integer(sar[0]).intValue();
        int faces_nb = new Integer(sar[1]).intValue();
        int edges_nb = new Integer(sar[2]).intValue();

        /* Parse vertices and attributes */
        vertices = new Vector[verts_nb];
        faces = new int[3 * faces_nb];
        colors = new double[3 * verts_nb];
        for (int i = 0; i < verts_nb; i++) {

            r = nextLine(in);
            sar = r.split("\\s+");

            vertices[i] = new Vector("v" + i, 4);
            vertices[i].set(0, new Double(sar[0]).doubleValue());
            vertices[i].set(1, new Double(sar[1]).doubleValue());
            vertices[i].set(2, new Double(sar[2]).doubleValue());
            vertices[i].set(3, 1.0);
            colors[3 * i + 0] = new Double(sar[3]).doubleValue();
            colors[3 * i + 1] = new Double(sar[4]).doubleValue();
            colors[3 * i + 2] = new Double(sar[5]).doubleValue();
            /* optionnal texture coordinates */
            if (sar.length >= 8) {
                if (texCoords == null) {
                    texCoords = new double[2 * verts_nb];
                }
                texCoords[2 * i] = new Double(sar[6]).doubleValue();
                texCoords[2 * i + 1] = new Double(sar[7]).doubleValue();
            }
        }

        /* Parse faces */
        for (int i = 0; i < faces_nb; i++) {

            r = nextLine(in);
            sar = r.split("\\s+");

            int en = new Integer(sar[0]).intValue();
            if (en != 3) {
                throw new IOException("Non-triangular meshes not supported.");
            }
            faces[3 * i + 0] = new Integer(sar[1]).intValue();
            faces[3 * i + 1] = new Integer(sar[2]).intValue();
            faces[3 * i + 2] = new Integer(sar[3]).intValue();

        }
        in.close();
    }

    /**
     * Gets the number of vertices in the mesh
     */
    public int getNumVertices() {
        return vertices.length;
    }

    /**
     * Gets the number of faces in the mesh
     */
    public int getNumFaces() {
        return faces.length / 3;
    }

    /**
     * Constructs a normal for each vertex of the mesh
     */
    private Vector3[] computeNormals() {

        normals = new Vector3[vertices.length];

        // Compute per face normals and set the vertex normal to the average normals
        // across faces
        // to the vertex.
        try {
            for (int i = 0; i < 3 * getNumFaces(); i += 3) {

                Vector v0 = vertices[i + 0];
                Vector v1 = vertices[i + 1];
                Vector v2 = vertices[i + 2];

                Vector3 bidule_gauche = new Vector3(v1);
                bidule_gauche.subtract(v0);

                Vector3 bidule_droite = new Vector3(v2);
                bidule_droite.subtract(v0);

                Vector3 n = bidule_gauche.cross(bidule_droite);

                // ajoute la normale calculee a chq sommet de la face
                for (int j = 0; j < 3; j++) {
                    Vector nj = normals[faces[i + j]];

                    if (nj == null) {
                        normals[faces[i + j]] = new Vector3(n);
                        normals[faces[i + j]].setName("n" + faces[i + j]);
                    } else {
                        nj.add(n);
                    }
                }
            }
        } catch (InstantiationException e) {
            System.out.println("Should not reach 1");
        } catch (SizeMismatchException e) {
            System.out.println("Should not reach 2");
        }

        // final round of normalization
        for (int i = 0; i < normals.length; i++) {
            if (normals[i] == null) { /* deals with orphans vertices */
                normals[i] = new Vector3("n_orphan");
            } else {
                normals[i].normalize();
            }
        }

        return normals;
    }

    /**
     * Returns the vertices of the mesh
     */
    public Vector[] getVertices() {
        return vertices;
    }

    /**
     * Return the normals associated to the vertices.
     */
    public Vector3[] getNormals() {
        if (normals == null) {
            normals = computeNormals();
        }

        return normals;
    }

    /**
     * Returns the faces of the mesh. The returned array contains 3*n integers, with
     * n the number of faces.
     * Each integer is an index into the array of Vector.
     */
    public int[] getFaces() {
        return faces;
    }

    /**
     * Returns the colors of each vertex in the mesh.
     */
    public double[] getColors() {
        return colors;
    }

    /**
     * Returns the texture coordinates of each vertex in the mesh.
     */
    public double[] getTextureCoordinates() {
        return texCoords;
    }

}