/*******************************************************************************
 * Copyright (c) 2012, 2013 Association for Decentralized Information Management in
 * Industry THTH ry.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     VTT Technical Research Centre of Finland - initial API and implementation
 *******************************************************************************/
package org.simantics.g3d.shape;

import java.util.ArrayList;
import java.util.List;

import javax.vecmath.Quat4d;
import javax.vecmath.Tuple3d;
import javax.vecmath.Vector3d;

import org.simantics.g3d.math.MathTools;

public class Mesh {
	private List<Tuple3d> vertices;
	private List<Tuple3d> normals;
	private List<Color4d> colors;
	private List<Integer> indices;
	
	
	public Mesh(List<Tuple3d> vertices, List<Tuple3d> normals,
			List<Color4d> colors, List<Integer> indices) {
		this.vertices = vertices;
		this.normals = normals;
		this.colors = colors;
		this.indices = indices;
	}
	
	public Mesh(List<Tuple3d> vertices, List<Tuple3d> normals, List<Integer> indices) {
		this.vertices = vertices;
		this.normals = normals;
		this.indices = indices;
	}
	
	public static Mesh create(List<Vector3d> vertices, List<Vector3d> normals, List<Integer> indices) {
		
		List<Tuple3d> v = new ArrayList<Tuple3d>();
		List<Tuple3d> n = new ArrayList<Tuple3d>();
		v.addAll(vertices);
		n.addAll(normals);
		return new Mesh(v, n, indices);
	}
	
	public Mesh(List<Tuple3d> vertices, List<Integer> indices) {
		this.vertices = vertices;
		this.indices = indices;
	}
	
	public static Mesh create(List<Vector3d> vertices, List<Integer> indices) {
		List<Tuple3d> v = new ArrayList<Tuple3d>();
		v.addAll(vertices);
		return new Mesh(v, indices);
	}

	public List<Tuple3d> getVertices() {
		return vertices;
	}
	
	public List<Tuple3d> getNormals() {
		return normals;
	}
	
	public List<Integer> getIndices() {
		return indices;
	}
	
	public List<Color4d> getColors() {
		return colors;
	}
	
	public void createNormals() {
		normals = new ArrayList<Tuple3d>(vertices.size());
		for (int i = 0; i < vertices.size(); i++) {
			normals.add(new Vector3d());
		}
        Vector3d v1 = new Vector3d();
        Vector3d v2 = new Vector3d();
        Vector3d v3 = new Vector3d();
        Vector3d t1 = new Vector3d();
        Vector3d t2 = new Vector3d();
        Vector3d n = new Vector3d();
        for (int i = 0; i < indices.size(); i+=3) {
            v1.set(vertices.get(i));
            v2.set(vertices.get(i+1));
            v3.set(vertices.get(i+2));
            t1.sub(v3,v1);
            t2.sub(v2,v1);
            n.cross(t2, t1);
            normals.get(i).add(n);
            normals.get(i+1).add(n);
            normals.get(i+2).add(n);
        }
        for (int i = 0; i < normals.size(); i++) {
        	((Vector3d)normals.get(i)).normalize();
        }
    }
	
	public void translate(Vector3d v) {
		for (int i = 0; i < vertices.size(); i++) {
			vertices.get(i).add(v);
		}
	}
	
	public void rotate(Quat4d q) {
		Vector3d t = new Vector3d();
		for (int i = 0; i < vertices.size(); i++) {
			MathTools.rotate(q, vertices.get(i), t);
			vertices.get(i).set(t);
		}
		
		if (normals != null) {
			for (int i = 0; i < normals.size(); i++) {
				MathTools.rotate(q, normals.get(i), t);
				t.normalize();
				normals.get(i).set(t);
			}	
		}
	}
	
	public void setColor(Color4d color) {
		colors = new ArrayList<Color4d>(vertices.size());
		for (int i = 0; i < vertices.size(); i++) {
			colors.add(color);
		}
	}
	
	public void add(Mesh mesh) {
		int vindex = vertices.size();
		int triIndex = indices.size();
		vertices.addAll(mesh.getVertices());
		indices.addAll(mesh.indices);
		for (int i = triIndex; i < indices.size(); i++) {
			indices.set(i, indices.get(i)+vindex);
		}
		if (normals != null) {
			boolean hasNormals = true;
			if (mesh.getNormals() == null) {
				mesh.createNormals();
				hasNormals = false;
			}
			normals.addAll(mesh.getNormals());
			if (!hasNormals)
				mesh.normals = null;
		}
		if (colors != null) {
			if (mesh.getColors() != null) {
				colors.addAll(mesh.getColors());
			} else {
				for (int i = 0; i < mesh.getVertices().size(); i++) {
					colors.add(new Color4d(1,1,1,0));
				}
			}
		}
	}
}