#include <VrmlConverter_Drawer.hxx>
#include <VrmlConverter_ShadedShape.hxx>
#include <Vrml_Normal.hxx>
#include <TopoDS_Shape.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS.hxx>
#include <TopAbs.hxx>
#include <Poly_Connect.hxx>
#include <TColgp_Array1OfDir.hxx>
#include <TColgp_HArray1OfVec.hxx>
#include <Poly_Triangle.hxx>
#include <Poly_Triangulation.hxx>
#include <BRepTools.hxx>
#include <BRepMesh.hxx>
#include <BRep_Tool.hxx>
#include <gp_Pnt.hxx>
#include <gp_Vec.hxx>
#include <TopExp_Explorer.hxx>
#include <TopLoc_Location.hxx>
#include <TColgp_Array1OfPnt.hxx>
#include <Poly_Array1OfTriangle.hxx>
#include <Vrml_IndexedFaceSet.hxx>
#include <Vrml_Coordinate3.hxx>
#include <BRepBndLib.hxx>
#include <Bnd_Box.hxx>
#include <math.hxx>
#include <TColStd_HArray1OfInteger.hxx>
#include <Geom_Surface.hxx>
#include <CSLib_DerivativeStatus.hxx>
#include <CSLib_NormalStatus.hxx>
#include <CSLib.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
#include <Precision.hxx>
#include <Vrml_Material.hxx>
#include <VrmlConverter_ShadingAspect.hxx>
#include <Vrml_ShapeHints.hxx>
#include <Vrml_MaterialBindingAndNormalBinding.hxx>
#include <Vrml_NormalBinding.hxx>
#include <Vrml_Separator.hxx>
#include <Vrml_NormalBinding.hxx>


//=========================================================================
// function: Add
// purpose
//=========================================================================
void VrmlConverter_ShadedShape::Add( Standard_OStream& anOStream, 
                                     const TopoDS_Shape& aShape,
                                     const Handle(VrmlConverter_Drawer)& aDrawer )
  {

  // here the triangulation is computed on the whole shape
  //  if it does not yet exist


    Standard_Real theRequestedDeflection;
    if(aDrawer->TypeOfDeflection() == Aspect_TOD_RELATIVE)   // TOD_RELATIVE, TOD_ABSOLUTE
      {
	Bnd_Box box;
	BRepBndLib::AddClose(aShape, box);

	Standard_Real  Xmin, Xmax, Ymin, Ymax, Zmin, Zmax, diagonal;
	box.Get( Xmin, Ymin, Zmin, Xmax, Ymax, Zmax );
	if (!(box.IsOpenXmin() || box.IsOpenXmax() ||
	      box.IsOpenYmin() || box.IsOpenYmax() ||
	      box.IsOpenZmin() || box.IsOpenZmax()))
	    {

	    diagonal = Sqrt ((Xmax - Xmin)*( Xmax - Xmin) + ( Ymax - Ymin)*( Ymax - Ymin) + ( Zmax - Zmin)*( Zmax - Zmin));
	    diagonal = Max(diagonal, Precision::Confusion());
	    theRequestedDeflection = aDrawer->DeviationCoefficient() * diagonal;      
	  }
	else
	  {
	    diagonal =1000000.;
	    theRequestedDeflection = aDrawer->DeviationCoefficient() * diagonal;  
	  }
//	cout << "diagonal = "<< diagonal << endl;
//	cout << "theRequestedDeflection = "<< theRequestedDeflection << endl;

      }
    else 
      {
	theRequestedDeflection = aDrawer->MaximalChordialDeviation(); 
      }

    if (!BRepTools::Triangulation(aShape,theRequestedDeflection)) 
      BRepMesh::Mesh(aShape,theRequestedDeflection); // computes and save the triangulation in the face.
  
  
  Handle(Poly_Triangulation) T;
  TopLoc_Location theLocation;
  Standard_Integer i, j, k, decal, nnv, EI;
  
  Standard_Integer t[3], n[3];
  gp_Pnt p;
  TopExp_Explorer ex;

  // counting phasis. This phasis will count the valid triangle
  // and the vertices to allocate the correct size for the arrays: 
  
  Standard_Integer nbTriangles = 0, nbVertices = 0;
  
  Standard_Integer nt, nnn, n1, n2, n3;
    
  // iterating on each face of the shape:
  for (ex.Init(aShape, TopAbs_FACE); ex.More(); ex.Next()) {  
    // getting the face:
    const TopoDS_Face& F = TopoDS::Face(ex.Current());
    // getting the triangulation of the face. The triangulation may not exist:
    T = BRep_Tool::Triangulation(F, theLocation);
      // number of triangles:
    if (T.IsNull()) continue; //smh 
      nnn = T->NbTriangles();            
    
    const TColgp_Array1OfPnt& Nodes = T->Nodes(); 
    // getting a triangle. It is  a triplet of indices in the node table:	
    const Poly_Array1OfTriangle& triangles = T->Triangles(); 
    
    // Taking the nodes of the triangle, taking into account the orientation
    // of the triangle.
    for (nt = 1; nt <= nnn; nt++) {
      if (F.Orientation() == TopAbs_REVERSED) 
	triangles(nt).Get(n1,n3,n2);
      else 
	triangles(nt).Get(n1,n2,n3);
      
      const gp_Pnt& P1 = Nodes(n1);
      const gp_Pnt& P2 = Nodes(n2);
      const gp_Pnt& P3 = Nodes(n3);
      // controlling whether the triangle correct from a 3d point of 
      // view: (the triangle may exist in the UV space but the
      // in the 3d space a dimension is null for example)
      gp_Vec V1(P1,P2);
      if (V1.SquareMagnitude() > 1.e-10) {
	gp_Vec V2(P2,P3);
	if (V2.SquareMagnitude() > 1.e-10) {
	  gp_Vec V3(P3,P1);
	  if (V3.SquareMagnitude() > 1.e-10) {
	    V1.Normalize();
	    V2.Normalize();
	    V1.Cross(V2);
	    if (V1.SquareMagnitude() > 1.e-10) {
	      nbTriangles++;
	      }
	  }
	}
      }
    }
    nbVertices += T->NbNodes();
  }      

//     cout << "nbTriangles = "<< nbTriangles << endl;
//     cout  << "nbVertices = "<< nbVertices << endl << endl;  

//----------------------------
  // now we are going to iterate again to build graphic data from the triangle.   
  if (nbVertices > 2 && nbTriangles > 0) {
    // allocating the graphic arrays.

     Handle(VrmlConverter_ShadingAspect) SA = new VrmlConverter_ShadingAspect;
     SA = aDrawer->ShadingAspect();

     Handle(TColgp_HArray1OfVec) HAV1 = new TColgp_HArray1OfVec(1, nbVertices);
     Handle(TColgp_HArray1OfVec) HAV2 = new TColgp_HArray1OfVec(1, nbVertices);
     
     gp_Vec V, VV;

     Handle(TColStd_HArray1OfInteger) HAI1 = new TColStd_HArray1OfInteger(1,4*nbTriangles);
     Handle(TColStd_HArray1OfInteger) HAI3 = new TColStd_HArray1OfInteger(1,(nbVertices/3*4+nbVertices%3));
     Handle(TColStd_HArray1OfInteger) HAI2 = new TColStd_HArray1OfInteger(1,1);
     Handle(TColStd_HArray1OfInteger) HAI4 = new TColStd_HArray1OfInteger(1,1);

	HAI2->SetValue (1,-1);
	HAI4->SetValue (1,-1);

// !! Specialize HAI2 -  materialIndex  HAI4 - textureCoordinateIndex

    EI = 1;
    nnv = 1;

    for (ex.Init(aShape, TopAbs_FACE); ex.More(); ex.Next()) {
      const TopoDS_Face& F = TopoDS::Face(ex.Current());
      T = BRep_Tool::Triangulation(F, theLocation);
      if (!T.IsNull()) {
	Poly_Connect pc(T);
	
	// 1 -  Building HAV1 -  array of all XYZ of nodes for Vrml_Coordinate3 from the triangles
	//            and HAV2 - array of all normals of nodes for Vrml_Normal
	
	const TColgp_Array1OfPnt& Nodes = T->Nodes();
	TColgp_Array1OfDir NORMAL(Nodes.Lower(), Nodes.Upper());

	  decal = nnv-1;
	
	for (j= Nodes.Lower(); j<= Nodes.Upper(); j++) {
	  p = Nodes(j).Transformed(theLocation.Transformation());

          V.SetX(p.X()); V.SetY(p.Y()); V.SetZ(p.Z());
          HAV1->SetValue(nnv,V);

	  if(SA->HasNormals())
	    {
		// to compute the normal.
	      ComputeNormal(F, pc, NORMAL);

	      VV.SetX(NORMAL(j).X());  VV.SetY(NORMAL(j).Y());  VV.SetZ(NORMAL(j).Z());
	      HAV2->SetValue(nnv,VV);
	    }
          nnv++;
	}
	
	// 2 -   Building HAI1 - array of indexes of all triangles and
	//        HAI3 - array of indexes of all normales  for Vrml_IndexedFaceSet
        nbTriangles = T->NbTriangles();
	const Poly_Array1OfTriangle& triangles = T->Triangles();	
        for (i = 1; i <= nbTriangles; i++) {
          pc.Triangles(i,t[0],t[1],t[2]);
          if (F.Orientation() == TopAbs_REVERSED) 
            triangles(i).Get(n[0],n[2],n[1]);
          else 
            triangles(i).Get(n[0],n[1],n[2]);
          const gp_Pnt& P1 = Nodes(n[0]);
          const gp_Pnt& P2 = Nodes(n[1]);
          const gp_Pnt& P3 = Nodes(n[2]);
          gp_Vec V1(P1,P2);
          if (V1.SquareMagnitude() > 1.e-10) {
            gp_Vec V2(P2,P3);
            if (V2.SquareMagnitude() > 1.e-10) {
              gp_Vec V3(P3,P1);
              if (V3.SquareMagnitude() > 1.e-10) {
        	V1.Normalize();
        	V2.Normalize();
        	V1.Cross(V2);
        	if (V1.SquareMagnitude() > 1.e-10) {
		  for (j = 0; j < 3; j++) {
		   
		    HAI1->SetValue(EI, n[j]+decal-1);	// array of indexes of all triangles
		    EI++;
		  }

		  HAI1->SetValue(EI, -1);		    
		  EI++;		  
		}
	      }
	    }
	  }
	}
      }
    }
  

     if(SA->HasNormals())
       {
	 j=1;
	 for (i=HAI3->Lower(); i <= HAI3->Upper(); i++)
	   {
	     k = i % 4;
	     if (k == 0)
	       {
		 HAI3->SetValue(i, -1);
		 j++;
	       }
	     else
	       {
		 HAI3->SetValue(i, i-j);   
	       }
	   }
       }

//-----------------------------
/*
  cout  << " ******************** " << endl;  
     cout  << " Array HAV1 - Coordinare3 " << endl;  

     for ( i=HAV1->Lower(); i <= HAV1->Upper(); i++ )
       {
	 cout << HAV1->Value(i).X() << " " << HAV1->Value(i).Y()<< " " << HAV1->Value(i).Z() << endl; 
       }

     if(SA->HasNormals())
       {

	 cout  << " ******************** " << endl;         
	 cout  << " Array HAV2 - Normals " << endl;  

	 for ( i=HAV2->Lower(); i <= HAV2->Upper(); i++ )
	   {
	     cout << HAV2->Value(i).X() << " " << HAV2->Value(i).Y()<< " " << HAV2->Value(i).Z() << endl; 
	   }

	 cout  << " ******************** " << endl;  
	 cout  << " Array HAI3 - normalIndex " << endl;  

	 for ( i=HAI3->Lower(); i <= HAI3->Upper(); i++ )
	   {
	     cout << HAI3->Value(i) << endl;
	   }

       }

     cout  << " ******************** " << endl;         
     cout  << " Array HAI1 - coordIndex " << endl;  
       
     for ( i=HAI1->Lower(); i <= HAI1->Upper(); i++ )
       {
	 cout << HAI1->Value(i) << endl;
       }
   
     cout  << " ******************** " << endl;       
*/
//----------------------------

// creation of Vrml objects

     Vrml_ShapeHints  SH; 
     SH = SA->ShapeHints();

     if(SA->HasNormals())
       {
// Separator 1 {
     Vrml_Separator SE1;
     SE1.Print(anOStream);
// Material
  if (SA->HasMaterial()){

     Handle(Vrml_Material) M;
     M = SA->FrontMaterial();

     M->Print(anOStream);
   }

// Coordinate3
     Handle(Vrml_Coordinate3)  C3 = new Vrml_Coordinate3(HAV1);
     C3->Print(anOStream);
// ShapeHints
     SH.Print(anOStream);
// NormalBinding
     Vrml_MaterialBindingAndNormalBinding MBNB1 = Vrml_PER_VERTEX_INDEXED;
     Vrml_NormalBinding   NB(MBNB1);
     NB.Print(anOStream);
// Separator 2 {
     Vrml_Separator SE2;
     SE2.Print(anOStream);
// Normal
     Vrml_Normal  N(HAV2);
     N.Print(anOStream);
// IndexedFaceSet
     Vrml_IndexedFaceSet  IFS;
     IFS.SetCoordIndex(HAI1);
     IFS.SetNormalIndex(HAI3);
     IFS.Print(anOStream);
// Separator 2 }     
     SE2.Print(anOStream);
// Separator 1 }
     SE1.Print(anOStream);
        }
     else 
       { 
// Separator 1 {
     Vrml_Separator SE1;
     SE1.Print(anOStream);
// Material
  if (SA->HasMaterial()){

     Handle(Vrml_Material) M;
     M = SA->FrontMaterial();

     M->Print(anOStream);
   }
// Coordinate3
     Handle(Vrml_Coordinate3)  C3 = new Vrml_Coordinate3(HAV1);
     C3->Print(anOStream);
// ShapeHints
     SH.Print(anOStream);
// IndexedFaceSet
     Vrml_IndexedFaceSet  IFS;
     IFS.SetCoordIndex(HAI1);
     IFS.Print(anOStream);
// Separator 1 }
     SE1.Print(anOStream);
       }
  }
}


//--------- Notes -------------

// the necessary of calculation of Normals and Textures must be define in Drawer
// likes tolerance

//---------- End on notes ------------



//----------------------------
// Computing the normal
//-----------------------------

void VrmlConverter_ShadedShape::ComputeNormal(const TopoDS_Face& aFace, 
					      Poly_Connect& pc, 
					      TColgp_Array1OfDir& Nor)
{
  const Handle(Poly_Triangulation)& T = pc.Triangulation();
  BRepAdaptor_Surface S;
  Standard_Boolean hasUV = T->HasUVNodes();
  Standard_Integer i;
  TopLoc_Location l;
  Handle(Geom_Surface) GS = BRep_Tool::Surface(aFace, l);

  if (hasUV && !GS.IsNull()) {
    Standard_Boolean OK = Standard_True;
    gp_Vec D1U,D1V;
    gp_Vec D2U,D2V,D2UV;
    gp_Pnt P;
    Standard_Real U, V;
    CSLib_DerivativeStatus Status;
    CSLib_NormalStatus NStat;
    S.Initialize(aFace);
    const TColgp_Array1OfPnt2d& UVNodes = T->UVNodes();
    for (i = UVNodes.Lower(); i <= UVNodes.Upper(); i++) {
      U = UVNodes(i).X();
      V = UVNodes(i).Y();
      S.D1(U,V,P,D1U,D1V);
      CSLib::Normal(D1U,D1V,Precision::Angular(),Status,Nor(i));
      if (Status != CSLib_Done) {
	S.D2(U,V,P,D1U,D1V,D2U,D2V,D2UV);
	CSLib::Normal(D1U,D1V,D2U,D2V,D2UV,Precision::Angular(),OK,NStat,Nor(i));
      }
      if (aFace.Orientation() == TopAbs_REVERSED) (Nor(i)).Reverse();
    }
  }
  else {
    const TColgp_Array1OfPnt& Nodes = T->Nodes();
    Standard_Integer n[3];
    const Poly_Array1OfTriangle& triangles = T->Triangles();

    for (i = Nodes.Lower(); i <= Nodes.Upper(); i++) {
      gp_XYZ eqPlan(0, 0, 0);
      for (pc.Initialize(i);  pc.More(); pc.Next()) {
	triangles(pc.Value()).Get(n[0], n[1], n[2]);
	gp_XYZ v1(Nodes(n[1]).Coord()-Nodes(n[0]).Coord());
	gp_XYZ v2(Nodes(n[2]).Coord()-Nodes(n[1]).Coord());
	eqPlan += (v1^v2).Normalized();
      }
      Nor(i) = gp_Dir(eqPlan);
      if (aFace.Orientation() == TopAbs_REVERSED) (Nor(i)).Reverse();
    }
  }
}