/*******************************************************************************
 * Copyright (c) 2007- VTT Technical Research Centre of Finland.
 * 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
 *******************************************************************************/
/* 
   This class is combination of jCAE's classes to generate meshes from shapes.
   Faces are lisetd as individual meshes.
   
   Marko Luukkainen
   
   jCAE stand for Java Computer Aided Engineering. Features are : Small CAD
   modeler, Finit element mesher, Plugin architecture.

    Copyright (C) 2003 Jerome Robert <jeromerobert@users.sourceforge.net>

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

package org.simantics.proconf.g3d.occ.geometry;
import org.jcae.opencascade.jni.BRepBndLib;
import org.jcae.opencascade.jni.BRepMesh_IncrementalMesh;
import org.jcae.opencascade.jni.BRepTools;
import org.jcae.opencascade.jni.BRep_Tool;
import org.jcae.opencascade.jni.Bnd_Box;
import org.jcae.opencascade.jni.GCPnts_UniformDeflection;
import org.jcae.opencascade.jni.GP_Trsf;
import org.jcae.opencascade.jni.GeomAPI_ProjectPointOnSurf;
import org.jcae.opencascade.jni.GeomAdaptor_Curve;
import org.jcae.opencascade.jni.GeomLProp_SLProps;
import org.jcae.opencascade.jni.Geom_Curve;
import org.jcae.opencascade.jni.Geom_Surface;
import org.jcae.opencascade.jni.Poly_Triangulation;
import org.jcae.opencascade.jni.TopAbs_Orientation;
import org.jcae.opencascade.jni.TopAbs_ShapeEnum;
import org.jcae.opencascade.jni.TopExp_Explorer;
import org.jcae.opencascade.jni.TopLoc_Location;
import org.jcae.opencascade.jni.TopoDS_Edge;
import org.jcae.opencascade.jni.TopoDS_Face;
import org.jcae.opencascade.jni.TopoDS_Shape;
import org.jcae.opencascade.jni.TopoDS_Vertex;


import java.util.ArrayList;
import java.util.HashSet;

import javax.vecmath.Matrix4d;
import javax.vecmath.Point3d;
import javax.vecmath.Vector3f;


public class ViewableShapeImpl 
{

    
    ArrayList<IndexedGeometry> faceMeshes =new ArrayList<IndexedGeometry>();
    ArrayList<float[]> edges=new ArrayList<float[]>();

	public ViewableShapeImpl(TopoDS_Shape g)
	{
        BRepTools.clean(g);
		buildFaces(g);
        buildEdges(g);
		
	}
    /*
    public ViewableShapeImpl(TopoDS_Shape g, boolean alternative)
    {
        
        if (alternative) 
            buildFaces(g);
        else {
            BRepTools.clean(g);
            buildFaces2(g);
        }
            
        buildEdges(g);
        
    }
	*/
	
	public IndexedGeometry getGeometry(int i)
	{     
		return faceMeshes.get(i);
	}
	
	public int numGeometries()
	{
        return faceMeshes.size();

	}	
    
    public int getNumEdges() {
        return edges.size();
    }
    
    public float[] getEdge(int i) {
        return edges.get(i);
    }
    
    /**
     * org.jcae.viewer3d.cad.occ.OCCEdgeDomain
     * @param shape
     * @param geom
     */
    private void buildFaces(TopoDS_Shape shape) {
        TopExp_Explorer explorer = new TopExp_Explorer();
        TopLoc_Location loc = new TopLoc_Location();
        
        int meshIter=4;
        double deflection = deflection(shape);
        for (explorer.init(shape, TopAbs_ShapeEnum.FACE); explorer.more(); explorer.next())
        {       
            //System.out.println("Triangulation");
            TopoDS_Shape s = explorer.current();
            if (!(s instanceof TopoDS_Face)) continue; // should not happen!
            TopoDS_Face face = (TopoDS_Face)s;
            Poly_Triangulation pt = BRep_Tool.triangulation(face,loc);
            
            //float error=0.01f;
            double error = deflection;
            int iter=0;
            // if shape was generated with program triangulation seems to be always null,
            // but model is loaded from file, it may already contain triangulation
            // So : in those cases can we delete existing triangulation and generate a new one ?
            //if (pt == null) {
                //System.out.println("Initial triangulation of face "+face+" not found. Using Incremental mesh");
            //} else {
            	//System.out.println("Initial triangulation of face "+face+" found.");
            //}
            while((pt==null)&(iter<meshIter)){
                //System.out.println("Triangulation failed for face "+face+". Trying other mesh parameters.");
                
                // using relatif in incremental mesh would cause visible seams between faces
            	BRepMesh_IncrementalMesh m = new BRepMesh_IncrementalMesh(face,error, false);
                //new BRepMesh_IncrementalMesh(face,error, false,12.0);
                pt = BRep_Tool.triangulation(face,loc);             
                error/=10;
                iter++;
                m.delete();
                
            }
                          
            
            if (pt==null)
            {
                System.out.println("Triangulation failed for face "+face+". Mesh not generated.");
                continue;
 
            }
            
            GP_Trsf trsf = loc.transformation();
            double[] mat = new double[16];
            trsf.getValues(mat);
            Matrix4d m = new Matrix4d(mat);
            
            double[] dnodes = pt.nodes();
            final int[] itriangles = pt.triangles();   
            boolean useNormals = false;
            boolean useTCoord = false;
            
            float[] tnodes = null;
            float[] normals = null;
            
            if (useTCoord)
            	tnodes = new float[dnodes.length / 3 * 2];
            if (useNormals)
            	normals= new float[dnodes.length];
            GeomLProp_SLProps prop = new GeomLProp_SLProps(2,0.001);
            Geom_Surface surf = BRep_Tool.surface(face);
            prop.setSurface(surf);
            if (useTCoord || useNormals) {
            	for (int i = 0; i < dnodes.length; i += 3) {
					double UV[] = new double[2];
					double point[] = new double[] { dnodes[i], dnodes[i + 1],
							dnodes[i + 2] };
					GeomAPI_ProjectPointOnSurf pof = new GeomAPI_ProjectPointOnSurf(
							point, surf);
					pof.lowerDistanceParameters(UV);
					// boolean b = GeomLib_Tool.parameters(surf, point, 0.01,
					// UV);
					prop.setParameters(UV[0], UV[1]);
					if (useNormals) {
						double normal[] = prop.normal();
						normals[i] = (float) normal[0];
						normals[i + 1] = (float) normal[1];
						normals[i + 2] = (float) normal[2];
					}
					if (useTCoord) {
						int index = i / 3 * 2;
						tnodes[index] = (float) UV[0];
						tnodes[index + 1] = (float) UV[1];
					}
					// System.out.println(dnodes[i]+ " " +dnodes[i+1]+ " "
					// +dnodes[i+2]+ " " + " UV:" + UV[0] + ","+UV[1]+ " " + b);
					// System.out.println(dnodes[i]+ " " +dnodes[i+1]+ " "
					// +dnodes[i+2]+ " " + normals[i] + " " + normals[i+1] + " "
					// + normals[i+2] + " UV:" + UV[0] + ","+UV[1]);
				}
            }
            prop.delete();
            
            if(face.orientation()==TopAbs_Orientation.REVERSED)
            {
                flipFace(itriangles);
            }
            
            final float[] fnodes=createFloatVertices(dnodes, m);
            IndexedGeometry geom = new IndexedGeometry();
            geom.setCoordinates(fnodes);
            geom.setIndices(itriangles);
            geom.setNormals(calcNormals(fnodes,itriangles));
            if (useNormals)
            	geom.setNormals(normals);
            if (useTCoord)
            	geom.setTCoordinates(tnodes);
            faceMeshes.add(geom);
            //System.out.println("Triangulation done");
        }
    }
    
    /**
     * org.jcae.viewer3d.cad.occ.OCCEdgeDomain
     * @param shape
     * @param geom
     */
    /*
    private void buildFaces2(TopoDS_Shape shape) {

            TopExp_Explorer explorer = new TopExp_Explorer();
            TopLoc_Location loc = new TopLoc_Location();
            
            int meshIter=10;
                    
            for (explorer.init(shape, TopAbs_ShapeEnum.FACE); explorer.more(); explorer.next())
            {                       
                TopoDS_Shape s = explorer.current();
                if (!(s instanceof TopoDS_Face)) continue; // should not happen!
                TopoDS_Face face = (TopoDS_Face)s;
               
                double error=0.01;
                BRepMesh_Discret mesh = new BRepMesh_Discret(0.01,face,0.1,true,true);
                Poly_Triangulation pt = BRep_Tool.triangulation(face,loc);
                //float error=0.001f*getMaxBound(s)*4;
                
                if (pt == null) {
                    System.out.println("Triangulation failed for face "+face+". Using Incremental mesh");
                }
                
                int iter=0;
                while((pt==null)&(iter<meshIter)){
                	BRepMesh_IncrementalMesh m = new BRepMesh_IncrementalMesh(face,error, false);
                    //new BRepMesh_IncrementalMesh(face,error, true);
                    pt = BRep_Tool.triangulation(face,loc);             
                    error/=100;
                    iter++;
                    System.out.println("Triangulation failed for face "+face+". Trying other mesh parameters.");
                    m.delete();
                }
                mesh.delete();
                if (pt==null)
                {
                    System.out.println("Triangulation failed for face "+face+". Mesh not generated.");
                    continue;
                }
                GP_Trsf trsf = loc.transformation();
                double[] mat = new double[16];
                trsf.getValues(mat);
                Matrix4d m = new Matrix4d(mat);
                
                double[] dnodes = pt.nodes();
                final int[] itriangles = pt.triangles();                        

                if(face.orientation()==TopAbs_Orientation.REVERSED)
                {
                    flipFace(itriangles);
                }
                
                final float[] fnodes=createFloatVertices(dnodes, m);
                IndexedGeometry geom = new IndexedGeometry();
                geom.setCoordinates(fnodes);
                geom.setIndices(itriangles);
                geom.setNormals(calcNormals(fnodes,itriangles));
                faceMeshes.add(geom);
            }
    }
    */
    
    private float[] createFloatVertices(double dnodes[], Matrix4d m) {
        float[] fnodes=new float[dnodes.length];
        Point3d p = new Point3d();
        
        for(int i=0; i<dnodes.length;)
        {
            p.x = dnodes[i];
            p.y = dnodes[i+1];
            p.z = dnodes[i+2];
            m.transform(p);
            fnodes[i++]=(float) p.x;
            fnodes[i++]=(float) p.y;
            fnodes[i++]=(float) p.z;  
        }
        return fnodes;
    }
    private double deflection(TopoDS_Shape s) {
    	Bnd_Box box = new Bnd_Box(); 
        BRepBndLib.add(s,box);
        
        double[] bbox = box.get();
        double boundingBoxDeflection=0.01*
            Math.max(Math.max(bbox[3]-bbox[0], bbox[4]-bbox[1]), bbox[5]-bbox[2]);
        box.delete();
        return boundingBoxDeflection;
    }
    
    private double edgeDeflection(TopoDS_Shape s) {
    	return 0.5 * deflection(s);
    }
    
    /**
     * org.jcae.viewer3d.cad.occ.OCCEdgeDomain
     * @param shape
     * @param geom
     */
    private void buildEdges(TopoDS_Shape shape) {
        
        
        TopExp_Explorer explorer = new TopExp_Explorer();
        HashSet<TopoDS_Edge> alreadyDone=new HashSet<TopoDS_Edge>();
        double boundingBoxDeflection = edgeDeflection(shape);

        for (explorer.init(shape, TopAbs_ShapeEnum.EDGE); explorer.more(); explorer.next())
        {
            TopoDS_Shape s = explorer.current();            
            if (!(s instanceof TopoDS_Edge)) continue; // should not happen!
            TopoDS_Edge e = (TopoDS_Edge)s;
            
            if(!alreadyDone.add(e))
                continue;
                        
            double[] range = BRep_Tool.range(e);
            Geom_Curve gc = BRep_Tool.curve(e, range);
            float[] array;
            if(gc!=null)
            {
                GeomAdaptor_Curve adaptator = new GeomAdaptor_Curve(gc);
                GCPnts_UniformDeflection deflector = new GCPnts_UniformDeflection();

                deflector.initialize(adaptator, boundingBoxDeflection, range[0], range[1]);
                int npts = deflector.nbPoints();
                
                // Allocate one additional point at each end  = parametric value 0, 1
                int size = 0;
                if (npts > 2)
                    size = (npts-2)*2;
                size+=2;
                size*=3;
                array = new float[size];          
                int j=0;
                double[] values = adaptator.value(range[0]);
                array[j++] = (float) values[0];
                array[j++] = (float) values[1];
                array[j++] = (float) values[2];
                // All intermediary points
                for (int i=1; i<npts-1; ++i) {
                    values = adaptator.value(deflector.parameter(i+1));
                    array[j++] = (float) values[0];
                    array[j++] = (float) values[1];
                    array[j++] = (float) values[2];
                    array[j++] = (float) values[0];
                    array[j++] = (float) values[1];
                    array[j++] = (float) values[2];
                }
                // Add last point
                values = adaptator.value(range[1]);
                array[j++] = (float) values[0];
                array[j++] = (float) values[1];
                array[j++] = (float) values[2];
                edges.add(array);
                adaptator.delete();
                deflector.delete();
            }
            else
            {
                if (!BRep_Tool.degenerated(e))
                {
                    // So, there is no curve, and the edge is not degenerated?
                    // => draw lines between the vertices and ignore curvature  
                    // best approximation we can do
                    ArrayList<double[]> aa = new ArrayList<double[]>(); // store points here
                    for (TopExp_Explorer explorer2 = new TopExp_Explorer(s, TopAbs_ShapeEnum.VERTEX);
                        explorer2.more(); explorer2.next())
                    {
                        TopoDS_Shape sv = explorer2.current();
                        if (!(sv instanceof TopoDS_Vertex)) continue; // should not happen!
                        TopoDS_Vertex v = (TopoDS_Vertex)sv;
                        aa.add(BRep_Tool.pnt(v));
                    }
                    int size = 0;
                    if (aa.size() > 2)
                        size = (aa.size()-2)*2;
                    size+=2;
                    double[] f=(double[])aa.get(0);
                    array = new float[size*3];
                    array[0]=(float) f[0];
                    array[1]=(float) f[1];
                    array[2]=(float) f[2];
                    for(int i=1, j=3; i<aa.size()-1; i++)
                    {
                        f=aa.get(i);
                        array[j++]=(float) f[0];
                        array[j++]=(float) f[1];
                        array[j++]=(float) f[2];
                        array[j++]=(float) f[0];
                        array[j++]=(float) f[1];
                        array[j++]=(float) f[2];
                    }
                    f=aa.get(aa.size()-1);
                    array[array.length-3]=(float) f[0];
                    array[array.length-2]=(float) f[1];
                    array[array.length-1]=(float) f[2];
                    edges.add(array);
                }
            }
        }       
    }
    
    private float[] calcNormals(float[] fnodes, int[] trias) {
        float nnodes[] = new float[fnodes.length];
        for (int i = 0; i < nnodes.length; i++) nnodes[i] = 0.f;
        Vector3f v1 = new Vector3f();
        Vector3f v2 = new Vector3f();
        Vector3f v3 = new Vector3f();
        Vector3f t1 = new Vector3f();
        Vector3f t2 = new Vector3f();
        Vector3f n = new Vector3f();
        for (int i = 0; i < trias.length; i+=3) {
            v1.x = fnodes[trias[i]*3];
            v1.y = fnodes[trias[i]*3+1];
            v1.z = fnodes[trias[i]*3+2];
            v2.x = fnodes[trias[i+1]*3];
            v2.y = fnodes[trias[i+1]*3+1];
            v2.z = fnodes[trias[i+1]*3+2];
            v3.x = fnodes[trias[i+2]*3];
            v3.y = fnodes[trias[i+2]*3+1];
            v3.z = fnodes[trias[i+2]*3+2];
            t1.sub(v3, v1);
            t2.sub(v2, v1);
            n.cross(t2, t1);
            //n.normalize();
            nnodes[trias[i]*3] += n.x;
            nnodes[trias[i]*3+1] += n.y;
            nnodes[trias[i]*3+2] += n.z;
            nnodes[trias[i+1]*3] += n.x;
            nnodes[trias[i+1]*3+1] += n.y;
            nnodes[trias[i+1]*3+2] += n.z;
            nnodes[trias[i+2]*3] += n.x;
            nnodes[trias[i+2]*3+1] += n.y;
            nnodes[trias[i+2]*3+2] += n.z;
        }
        for (int i = 0; i < nnodes.length; i+=3) {
            n.x = nnodes[i];
            n.y = nnodes[i+1];
            n.z = nnodes[i+2];
            n.normalize();
            nnodes[i] = n.x;
            nnodes[i+1] = n.y;
            nnodes[i+2] = n.z;
        }
        return nnodes;
    }
    
    private void flipFace(int[] trias) {
        int newTrias[] = new int[trias.length];
        System.arraycopy(trias, 0, newTrias, 0, trias.length);
        for (int i = 0; i < trias.length; i++) {
            trias[i] = newTrias[trias.length - i - 1];
        }
    }	
	
}