#include "simulator.h"

//initialisation Surface
Surface::Surface(Simulator* sim,VEC3 offset):
    mapOperator(surfaceMap)
{

    r=1.0f;
    g=0.627f;
    b=0.0f;
    sim_=sim;
    width=1.0;
    nbVertices=0;
    nbTriangles=0;
    distanceColorationMaxi=0.01f;
    distanceColorationMini=2.0f;

    surfaceMap.initImplicitProperties();
    positionSurface = surfaceMap.addAttribute<VEC3, VERTEX, SURFACE>("positionSurface");
    initOperators(LERP);
    initPlane();

    indexParticule = surfaceMap.addAttribute<int, VERTEX, SURFACE>("indexParticule");
    indexTriangle= surfaceMap.addAttribute<int, FACE, SURFACE>("indexTriangle");
    faceColor=surfaceMap.addAttribute<VEC3, FACE, SURFACE>("faceColor");

    index_surface=sim->surfaces.size();




    // initialisation des particules et des attributs de sommet
    TraversorV<SURFACE> tv(surfaceMap);
    for(Dart d = tv.begin() ; d != tv.end() ; d = tv.next())
    {
        positionSurface[d]+=offset;
        indexParticule[d]=nbVertices;
        parts_.push_back(new CGoGN::Algo::Volume::MovingObjects::ParticleCell3D<PFP>(sim_->envMap_.map, sim_->envMap_.getBelongingCell(positionSurface[d]), positionSurface[d] , sim_->envMap_.position));
        nbVertices ++;
    }
    // initialisation tableaux de vecteurs qui vont stocker les belonging cells
    TraversorE<SURFACE> tF2(surfaceMap);
    for(Dart d = tF2.begin() ; d != tF2.end() ; d = tF2.next())
    {
        nbTriangles ++;
    }



    // initialisation des segments et des attributs d'edge
    TraversorF<SURFACE> tE(surfaceMap);
    for(Dart d = tE.begin() ; d != tE.end() ; d = tE.next())
    {
        faceColor[d]=VEC3(r,g,b);
#ifdef DEBUG_affichage
        CGoGNout<<" init Segment :"<< nbTriangles ;
        CGoGNout<<" || nb_segments  :"<< triangles_.size() <<CGoGNendl;
#endif
        indexTriangle[d]=triangles_.size();

        VEC3 p1=positionSurface[d],p2=positionSurface[surfaceMap.phi1(d)],p3=positionSurface[surfaceMap.phi1(surfaceMap.phi1(d))];
        Triangle* o = new Triangle(p1,p2,p3,this,d,r,g,b,indexTriangle[d]);
        triangles_.push_back(o);

        sim_->envMap_.FirstRegistrationTriangle(o);

    }



    sim_->surfaces.push_back(this);

//    for(Dart d = tE.begin() ; d != tE.end() ; d = tE.next())
//    {
//        CGoGNout<<" color face :"<<d<<" || : "<<faceColor[d]<<CGoGNendl ;
//    }

//    for(Dart d = tv.begin() ; d != tv.end() ; d = tv.next())
//    {
//        CGoGNout<<" position dart :"<<d<<" || : "<<positionSurface[d]<<CGoGNendl ;
//    }
}

void Surface::initGL()
{
    //rendering
    m_render_map = new Algo::Render::GL2::MapRender();
    m_positionVBO = new Utils::VBO();
    m_colorVBO= new Utils::VBO();
    m_render = new Algo::Render::GL2::ColorPerFaceRender();
//

    m_shader= new Utils::ShaderColorPerVertex();
    m_shader->setAttributeColor(m_colorVBO);
    m_shader->setAttributePosition(m_positionVBO);
    m_simpleColorShader = new Utils::ShaderSimpleColor();
    m_simpleColorShader->setAttributePosition(m_positionVBO);
    m_simpleColorShader->setColor(Geom::Vec4f(0.,1.,0.,0.));

    m_render->updateVBO<PFPSurface,FACE>(*m_positionVBO,*m_colorVBO,surfaceMap,positionSurface,faceColor);

    m_render_map->initPrimitives<PFPSurface>(surfaceMap, Algo::Render::GL2::LINES) ;
//    m_render->initPrimitives<PFPSurface>(surfaceMap, Algo::Render::GL2::TRIANGLES) ;
}

void Surface::draw()
{

    m_positionVBO->updateData(positionSurface) ;
        glLineWidth(1.0f);
    m_render_map->draw(m_simpleColorShader,Algo::Render::GL2::LINES);
//    m_colorVBO->updateData(faceColor);
//    colorRender->updateVBO<PFPSurface,FACE>(m_positionVBO,m_colorVBO,surfaceMap,positionSurface,colorRender);

    m_render->updateVBO<PFPSurface,FACE>(*m_positionVBO,*m_colorVBO,surfaceMap,positionSurface,faceColor);


    m_simpleColorShader->setColor(Geom::Vec4f(0.0,0.0,0.0,0.));

    m_render->draw(m_shader);



}

void Surface::initPlane()
{
    CGoGNout<<" initialisation d'un plan"<< CGoGNendl ;



    Algo::Surface::Tilings::Triangular::Grid<PFPSurface> prim(surfaceMap, 1,1) ;

    prim.embedIntoGrid(positionSurface,1.0f,1.0f, 0.0f) ;


    TraversorV<SURFACE> tv(surfaceMap);
    for(Dart d = tv.begin() ; d != tv.end() ; d = tv.next())
    {
        positionSurface[d]*=4;

    }




    TraversorF<SURFACE> tF(surfaceMap);
    for(Dart d = tF.begin() ; d != tF.end() ; d = tF.next())
    {
        REAL dist = faceMaxdistance(d);
        if(dist < sim_->envMap_.maxCellRay)
        {
            sim_->envMap_.maxCellRay=dist;
        }
    }


//    bool test = false;
//    while (!test)
//    {
//       test = subdiveMap();
////        CGoGNout<<"subdiv effectuée ? " <<!test<<CGoGNendl;
//    }

}

bool Surface::subdiveMap()
{
    bool res = true;
    std::vector<Dart> toCheck;
    TraversorF<SURFACE> tF(surfaceMap);
    surfaceMap.setCurrentLevel(surfaceMap.getMaxLevel()) ;
    for(Dart d = tF.begin() ; d != tF.end() ; d = tF.next())
    {

        toCheck.push_back(d);
    }

    for(Dart d : toCheck)
    {
        REAL dist = faceMaxdistance(d);
        if(dist > sim_->envMap_.maxCellRay)
        {
//            CGoGNout<<"ok pour subdiv face :"<<d<<CGoGNendl;
            mapOperator.subdivideFace(d,true,true) ;

            res=false;
        }
        surfaceMap.setCurrentLevel(surfaceMap.getMaxLevel()) ;

    }



    return res;
}


REAL Surface::faceMaxdistance(Face face)
{
    Dart d = face;

    VEC3 center = Algo::Surface::Geometry::faceCentroid<PFPSurface,VertexAttribute<VEC3,SURFACE>>(surfaceMap,face,positionSurface);

    REAL res = (positionSurface[d]-center).norm2();
    for ( Vertex vert : verticesIncidentToFace2(surfaceMap,face))
    {
        REAL size=(positionSurface[vert]-center).norm2();
        if(size>res)
        {
            res=size;
        }
    }
    return res;
}

void Surface::initOperators(SubdivisionType st)
{
    switch (st)
    {
       case LERP :
            //lerp subdiv
            mapOperator.setEdgeVertexFunctor(new Algo::MR::Primal::Masks::LerpEdgeVertexFunctor<PFPSurface>(surfaceMap,positionSurface));
            mapOperator.setVertexVertexFunctor(new Algo::MR::Primal::Masks::LerpVertexVertexFunctor<PFPSurface>(surfaceMap,positionSurface));
            mapOperator.setFaceVertexFunctor(new Algo::MR::Primal::Masks::LerpFaceVertexFunctor<PFPSurface>(surfaceMap,positionSurface));
            break;
       case LOOP :
            //loop subdiv
            mapOperator.setEdgeVertexFunctor(new Algo::MR::Primal::Masks::LoopEdgeVertexFunctor<PFPSurface>(surfaceMap,positionSurface));
            mapOperator.setVertexVertexFunctor(new Algo::MR::Primal::Masks::LoopVertexVertexFunctor<PFPSurface>(surfaceMap,positionSurface));
            break;
       case CATC :
            //catmull subdiv
            mapOperator.setEdgeVertexFunctor(new Algo::MR::Primal::Masks::CCEdgeVertexFunctor<PFPSurface>(surfaceMap,positionSurface));
            mapOperator.setVertexVertexFunctor(new Algo::MR::Primal::Masks::CCVertexVertexFunctor<PFPSurface>(surfaceMap,positionSurface));
            mapOperator.setFaceVertexFunctor(new Algo::MR::Primal::Masks::CCFaceVertexFunctor<PFPSurface>(surfaceMap,positionSurface));
            break;
       case SQRT3:
            //sqrt subdiv
            mapOperator.setVertexVertexFunctor(new Algo::MR::Primal::Masks::Sqrt3VertexVertexFunctor<PFPSurface>(surfaceMap,positionSurface));
            mapOperator.setFaceVertexFunctor(new Algo::MR::Primal::Masks::Sqrt3FaceVertexFunctor<PFPSurface>(surfaceMap,positionSurface));
        break;
       default : CGoGNerr<<" subdivtype inconnu "<<__FILE__<<__LINE__<<CGoGNendl;


    }
}

void Surface::changeColor(Triangle *t , float distance)
{
    if(distance >=0)
    {
        if(distance<distanceColorationMini)
        {
            if(distance<distanceColorationMaxi)
            {
                t->r=1.0f;
                t->g=0.0f;
                t->b=0.0f;
            }
            else
            {
                float factor = (distanceColorationMini-distance)/(distanceColorationMini-distanceColorationMaxi);
                t->r= r+(1.0f- r)*factor;
                t->g= g- g*factor;
                t->b= b- b*factor;
            }

        }
    }
    else
    {
        t->r= r;
        t->g= g;
        t->b= b;
    }

    faceColor[t->cell]=VEC3(t->r,t->g,t->b);
}



void  Surface::addGeneralCell ( Dart d)
{
    bool added = false;
    for(std::pair<Dart,int>& pere : general_belonging)
    {
//        if(sim_->envMap_.map.sameVolume(pere.first,d))
        if(pere.first==d)
        {
            pere.second ++;
            added= true;
            break;
        }

    }
    if (!added)
    {
        general_belonging.push_back(std::make_pair(d,1));
    }
}
/*removeGeneralCell
 * removes cell d to general belonging decreases the number of instance of the cell, if the number is 0 the celle is removed *forever*
 */
bool  Surface::removeGeneralCell (Dart d)
{
    for(std::pair<Dart,int>& pere : general_belonging)
    {
//        if(sim_->envMap_.map.sameVolume(pere.first,d))
        if(pere.first==d)
        {
            pere.second--;
            if(pere.second==0)
            {
                pere=general_belonging.back() ;
                general_belonging.pop_back() ;
            }
            return true;
        }


    };
    return false;
}

void  Surface::addGeneralNeighbor ( Dart d)
{
    bool added = false;
    for(std::pair<Dart,int>& pere : general_neighbors)
    {
//        if(sim_->envMap_.map.sameVolume(pere.first,d))
        if(pere.first==d)
        {
            pere.second ++;
            added= true;
            break;
        }

    }
    if (!added)
    {
        general_neighbors.push_back(std::make_pair(d,1));
    }
}
/*removeGeneralCell
 * removes cell d to general belonging decreases the number of instance of the cell, if the number is 0 the celle is removed *forever*
 */
bool  Surface::removeGeneralNeighbor (Dart d)
{
    for(std::pair<Dart,int>& pere : general_neighbors)
    {
//        if(sim_->envMap_.map.sameVolume(pere.first,d))
        if(pere.first==d)
        {
            pere.second--;
            if(pere.second==0)
            {
                pere=general_neighbors.back() ;
                general_neighbors.pop_back() ;
            }
            return true;
        }


    };
    return false;
}


VEC3 Surface::getPosition(int index)
{
    return parts_[index]->getPosition();
}