#include <engine.h>
#include <SparrowInput/input.h>
#include <SparrowRenderer/scene.h>
#include <SparrowRenderer/mesh.h>
#include <SparrowRenderer/image.h>
#include <SparrowRenderer/deferredpipeline.h>
#include <SparrowRenderer/pbrmaterial.h>
#include <resourcemanager.h>
#include <SparrowRenderer/sparrowrenderer.h>
#include <SparrowRenderer/texture.h>
#include <SparrowRenderer/chunk.h>
#include "defaultkeysmap.h"

#include <scene/scenetree.h>
#include <scene/textnode.h>
#include <scene/playercharacternode.h>
#include <scene/scenenode.h>
#include <tools/graph.h>
#include <tools/pathfinder.h>
#include <tools/loader.h>

#include <tools/font.h>
#include <tools/utils.h>

#include <sparrowshell/sparrowshell.h>
#include <btBulletDynamicsCommon.h>

#include <glm/ext.hpp>

#include "scene/gui/buttonnode.h"
#include "scene/gui/buttonshape.h"

#include "scene/gui/backgroundnode.h"

//#include "potator.h"
#include "SparrowSerializer/serializationmanager.h"
#include "SparrowSerializer/serializable.h"
#include <cereal/archives/json.hpp>
#include <fstream>

#include "resourcemanager.h"

#include "scene/gui/callback.h"

class TestGen : public TerrainGenerator
{
    float map[64*64];
public:
    TestGen()
    {
        for(int i=0; i<64*64; ++i)
            map[i] = (rand()%64)/64.f;
    }

    float getHeight(float x, float z, float zoom)
    {
        x /= zoom;
        z /= zoom;
        int i1 = int(floor(x)+64)%64;
        int j1 = int(floor(z)+64)%64;
        int i2 = (i1+1)%64;
        int j2 = (j1+1)%64;
        float v1 = map[i1*64+j1];
        float v2 = map[i2*64+j1];
        float v3 = map[i1*64+j2];
        float v4 = map[i2*64+j2];
        float ph = x - floor(x);
        float pv = z - floor(z);
        ph = 0.5f-cos(3.1416*ph)/2;
        pv = 0.5f-cos(3.1416*pv)/2;
        float v5 = v1*(1-ph) + v2*ph;
        float v6 = v3*(1-ph) + v4*ph;
        return (v5*(1-pv) + v6*pv)*zoom;
    }

    virtual float func(float x, float y, float z)
    {
        float height = getHeight(x+6.7, z+15.7, 2.5f);
        height += getHeight(x+5.76, z+2.14, 5.4f);
        height += getHeight(x, z, 10.f);
        return y+8.f - height;
    }
};

void generateTerrain(SceneTree *scene)
{
    SceneNode* terrainContainer = new SceneNode("terrain container");
    TestGen gen;
    PBRMaterial *mat = new PBRMaterial();
    mat->albedo = glm::vec3(0.1f, 0.4f, 0.2f);
    mat->metallic = 0.2f;
    mat->roughness = 0.95f;

    for(int x=-3; x<3; ++x)
    for(int y=-2; y<2; ++y)
    for(int z=-3; z<3; ++z)
    {
        Chunk *chunk = new Chunk(&gen); // ! WARNING ! : chunk pointer is lost and never deleted
        glm::vec3 pos(x, y, z);
        chunk->generate(pos);
        if(chunk->mesh->m_positions3D.empty())
            delete chunk;
        else
        {
            chunk->mesh->setMaterial(mat);
            chunk->mesh->initGL();
            SceneNode *node = new SceneNode("terrain element");
            node->setMesh(chunk->mesh);
            node->getGeometryNode()->modelMatrix = glm::translate(glm::scale(glm::mat4(), glm::vec3(2.f)), pos*8.f);
            node->setTransform(node->getGeometryNode()->modelMatrix);
            btRigidBody* body = utils::buildStaticCollider(node->getGeometryNode());
            node->setRigidBody(body);
            scene->getPhysics()->addRigidBody(body);
            terrainContainer->addChild(node);
        }
    }
    scene->getRootObject()->addChild(terrainContainer);
}

void generateSponza(SceneTree *scene, btDiscreteDynamicsWorld *world)
{
    Loader::setTexDirectory("data/sponza/");
    SceneNode* sponzaContainer = Loader::loadMesh("sponza.obj");
    Loader::setTexDirectory("data/");
    if(sponzaContainer != nullptr && sponzaContainer->getChildren().size() > 0)
    {
        const std::vector<SceneNode*> children = sponzaContainer->getChildren();
        for(SceneNode* node : children)
        {
            if(node->getMesh()->getName().find("fabric") != std::string::npos)
            {
                // moyen crade de se débarasser des rideaux
                sponzaContainer->removeChild(node);
                node->destroyWhenOrphan();
            }
            else
            {
                // scale sponza before generating the static collider
                glm::mat4 scaleMatrix = glm::scale(glm::mat4(), glm::vec3(0.01f));
                node->getGeometryNode()->modelMatrix = scaleMatrix;
                node->setTransform(scaleMatrix);
                btRigidBody* body = utils::buildStaticCollider(node->getGeometryNode());
                node->setRigidBody(body);
                world->addRigidBody(body);
            }
        }
        scene->getRootObject()->addChild(sponzaContainer);
    }
    else
    {
        fprintf(stderr, "failed to load sponza");
        if(sponzaContainer)
            delete sponzaContainer;
    }
}

struct Config
{
    std::string mode; // fullscreen / windowed / borderless
    std::string scene; // terrain / sponza / none
    bool vsync;
    int width;
    int height;

    Config()
    {
        mode = "windowed";
        scene = "sandbox";
        vsync = false;
        width = 800;
        height = 600;
    }

    void save()
    {
//        std::fstream configFile;
//        configFile.open("config.ini", std::ios_base::out);
        std::ofstream configFile("config.ini");
        cereal::JSONOutputArchive output(configFile);

        output(cereal::make_nvp("mode", mode),
               cereal::make_nvp("scene", scene),
               cereal::make_nvp("vsync", vsync),
               cereal::make_nvp("width", width),
               cereal::make_nvp("height", height));
    }

    void load()
    {
        std::fstream configFile;
        configFile.open("config.ini", std::ios_base::in);
        if(configFile.is_open())
        {
            try
            {
                cereal::JSONInputArchive input(configFile);
                input(cereal::make_nvp("mode", mode),
                      cereal::make_nvp("scene", scene),
                      cereal::make_nvp("vsync", vsync),
                      cereal::make_nvp("width", width),
                      cereal::make_nvp("height", height));
            }
            catch(cereal::Exception e)
            {
                std::cerr << "Config file contains errors : " << e.what() << std::endl;
            }
            configFile.close();
        }
        save();
    }
};

class Demo {
    std::string m_demo_scene;
    Engine* m_engine;
    Config* m_config;
    PlayerCharacterNode* m_player;
public:
    Demo(Engine* engine,Config* config):m_demo_scene("demo"),m_engine(engine),m_config(config){
        m_engine->createScene(m_demo_scene);
    }

    void initScene(){
        //player
        m_player = new PlayerCharacterNode(false);
        m_player->setInputs(DefaultKeysMap::MOVE_FORWARD, DefaultKeysMap::MOVE_BACKWARD, DefaultKeysMap::STRAFE_LEFT, DefaultKeysMap::STRAFE_RIGHT, DefaultKeysMap::JUMP, DefaultKeysMap::RUN, DefaultKeysMap::TOGGLE_NOCLIP);
        SceneTree* scene = RESOURCE_GET(SceneTree, m_demo_scene);
        scene->getRootObject()->addChild(m_player);
        scene->setMainCamera(m_player->getCamera());

        //potator
        //Potator *potator = new Potator(m_player, DefaultKeysMap::MAIN_ACTION, DefaultKeysMap::SECONDARY_ACTION, DefaultKeysMap::TERTIARY_ACTION);
        //scene->getRootObject()->addChild(potator);

        //lighting
        Texture* skyboxTexture = RESOURCE_GET(Texture, "radiance");
        Texture* ambientTexture = RESOURCE_GET(Texture, "irradiance");
        SceneNode *ambientLight = new SceneNode();
        ambientLight->setLight(new AmbientLight(ambientTexture, skyboxTexture));

        DeferredPipeline* pipeline = dynamic_cast<DeferredPipeline*>(scene->getPipeline());
        pipeline->setSkybox(RESOURCE_GET(Texture, "skybox"));

        DirectionnalLight* sun = new DirectionnalLight(glm::vec3(5, 8, -2), glm::vec3(4.f));
        SceneNode *sunLight = new SceneNode();
        sunLight->setLight(sun);

        scene->getRootObject()->addChild(ambientLight);

        scene->initPhysics();

        if(m_config->scene == "sponza")
        {
            sun->initShadowMap(4096);
            generateSponza(scene, m_engine->getScene()->getPhysics());
            SceneNode* light_1 = new SceneNode();
            light_1->setLight(new PointLight(glm::vec3(-3.5, 2, 1.8), 15, glm::vec3(0.35f)));
            scene->getRootObject()->addChild(light_1);
            SceneNode* light_2 = new SceneNode();
            light_2->setLight(new PointLight(glm::vec3(-5, 6, 2), 15, glm::vec3(0.35f)));
            scene->getRootObject()->addChild(light_2);
            m_player->setPosition(0.f, 2.f, 0.f);
            sun->setShadowView(glm::vec3(30, 30, 50));
        }
        else if(m_config->scene == "terrain")
        {
            sun->initShadowMap(4096);
            generateTerrain(scene);
            m_player->setPosition(0.f, 15.f, 0.f);
            sun->setShadowView(glm::vec3(130, 130, 70));
        }
        else if(m_config->scene == "sandbox")
        {
            // load terrain

            Loader::setTexDirectory("data/");
            SceneNode* terrain = utils::createTerrain("HeightMap.png", "ColorMap.png", 100);
            terrain->translate(glm::vec3(353.96, -71.51, -60.79));
            //sandbox->scale(glm::vec3(0.5));
            terrain->getGeometryNode()->modelMatrix = terrain->getTransform();
            btRigidBody* terrainBody = utils::buildStaticCollider(terrain->getGeometryNode());
            terrain->setRigidBody(terrainBody);
            scene->getPhysics()->addRigidBody(terrainBody);
            scene->getRootObject()->addChild(terrain);

            // load sandbox

            SceneNode* sandbox = Loader::loadMesh("sandbox.obj");
            sandbox->setID("sandbox");
            btRigidBody* sandboxBody = utils::buildStaticCollider(sandbox->getGeometryNode());
            sandbox->setRigidBody(sandboxBody);
            scene->getPhysics()->addRigidBody(sandboxBody);
            scene->getRootObject()->addChild(sandbox);

            // adding tree
            SceneNode* tree = Loader::loadMesh("Tree01.obj");
            for(int i=0; i<8; ++i)
            {
                std::string id = "tree#"+ std::to_string(i);
                tree->setID(id);
                tree->moveTo(glm::vec3(-(10 + rand()%20), 0, rand()%40 - 5));
                sandbox->addChild(tree->clone());
            }
            delete tree;

            // init player and shadows

            sun->initShadowMap(4096);
            m_player->setPosition(0.f, 1.4f, 0.f);
            sun->setShadowView(glm::vec3(80));
        }

        scene->getRootObject()->addChild(sunLight);
    }

    std::string getScene(){return m_demo_scene;}
    PlayerCharacterNode* getPlayer(){return m_player;}
};

class ButtonDemoCallBack : public CallBack
{
    Engine* m_engine;
    Demo* m_demo;
public:
    ButtonDemoCallBack(Engine* engine, Demo* demo):m_engine(engine),m_demo(demo){}

    void exec(){
        m_demo->initScene();
        m_engine->setScene(m_demo->getScene());
        m_engine->getInput()->setCurrentContext("default");
        m_engine->getScene()->getPhysics()->addRigidBody(m_demo->getPlayer()->getRigidbody());
        m_engine->toggleMouseVisibility();
    }
};

class Menu {
    int m_left_click_action;
    ButtonNode* m_button_demo;
    std::string m_menu_scene;
public:
    Menu(Engine* engine,Config* config):m_menu_scene("menu"){
        engine->createScene(m_menu_scene);
        SceneTree* scene = RESOURCE_GET(SceneTree,m_menu_scene);
        m_button_demo = new ButtonNode(new RectangleButtonShape(glm::vec2(300,100)));
        m_button_demo->setID("startbutton");
        m_button_demo->getLabel()->setText("Start DEMO");
        m_button_demo->getLabel()->setColor(glm::vec3(1.,1.,1.));
        m_button_demo->getBackGround()->setColor(glm::vec3(0.88,0.05,0.05));
        scene->getRootObject()->addChild(m_button_demo);
        sf::Vector2u size = engine->getWindow()->getSize();
        glm::vec2 pos = glm::vec2(size.x,size.y)/glm::vec2(2,2) - m_button_demo->getDimension()/glm::vec2(2,2);
        m_button_demo->setPosition(pos);
        m_button_demo->setVisible(true);
        scene->initPhysics();
    }

    void setLeftClickAction(int action){
        m_left_click_action = action;
        m_button_demo->setAction(m_left_click_action);
    }

    void setButtonCallBack(ButtonDemoCallBack* button_callback){
        m_button_demo->setCallBack(button_callback);
    }

    std::string getScene(){return m_menu_scene;}
};

int main(){
    Config* config = new Config();
    config->load();
    Engine engine;

    Loader::setObjDirectory("data/");
    Loader::setMtlDirectory("data/");
    Loader::setTexDirectory("data/");

    // this creates the opengl context
    // the opengl context must exist before any opengl class is used (texture, pipeline, etc..)
    engine.createWindow("Sparrow Engine Demo", config->width, config->height, config->mode);
    engine.getWindow()->setVerticalSyncEnabled(config->vsync);

    // opengl context is created, we can initialize the global textures used by the rendering pipeline
    Image* img = Loader::loadImage("ibl_brdf_lut.png", 24, true);
    AmbientLight::setBrdfLut(new Texture(img));
    delete img;
    Image * imgs[6];
    imgs[0] = Loader::loadImage("skybox/posx.jpg", 24, false); // right
    imgs[1] = Loader::loadImage("skybox/negx.jpg", 24, false); // left
    imgs[2] = Loader::loadImage("skybox/posy.jpg", 24, false); // top
    imgs[3] = Loader::loadImage("skybox/negy.jpg", 24, false); // bottom
    imgs[4] = Loader::loadImage("skybox/posz.jpg", 24, false); // front
    imgs[5] = Loader::loadImage("skybox/negz.jpg", 24, false); // back
    RESOURCE_ADD(new Texture(imgs), Texture, "skybox");
    for(int i=0; i<6; ++i)
        delete imgs[i];

    imgs[0] = Loader::loadImage("skybox/irradiance/output_iem_posx.tga", 24, false); // right
    imgs[1] = Loader::loadImage("skybox/irradiance/output_iem_negx.tga", 24, false); // left
    imgs[2] = Loader::loadImage("skybox/irradiance/output_iem_posy.tga", 24, false); // top
    imgs[3] = Loader::loadImage("skybox/irradiance/output_iem_negy.tga", 24, false); // bottom
    imgs[4] = Loader::loadImage("skybox/irradiance/output_iem_posz.tga", 24, false); // front
    imgs[5] = Loader::loadImage("skybox/irradiance/output_iem_negz.tga", 24, false); // back
    RESOURCE_ADD(new Texture(imgs, false), Texture, "irradiance");
    for(int i=0; i<6; ++i)
        delete imgs[i];

    imgs[0] = Loader::loadImage("skybox/radiance/output_pmrem_posx_0_256x256.tga", 24, false); // right
    imgs[1] = Loader::loadImage("skybox/radiance/output_pmrem_negx_0_256x256.tga", 24, false); // left
    imgs[2] = Loader::loadImage("skybox/radiance/output_pmrem_posy_0_256x256.tga", 24, false); // top
    imgs[3] = Loader::loadImage("skybox/radiance/output_pmrem_negy_0_256x256.tga", 24, false); // bottom
    imgs[4] = Loader::loadImage("skybox/radiance/output_pmrem_posz_0_256x256.tga", 24, false); // front
    imgs[5] = Loader::loadImage("skybox/radiance/output_pmrem_negz_0_256x256.tga", 24, false); // back
    RESOURCE_ADD(new Texture(imgs), Texture, "radiance");
    for(int i=0; i<6; ++i)
        delete imgs[i];

//    engine.toggleMouseVisibility();

    // setting up SparrowEngine
//    engine.initPhysics();
 //   SceneTree *scene = engine.createScene();
  //  engine.setScene(scene);

    // setting up SparrowInput
    Input* input = engine.getInput();
    input->setKeysMap(DefaultKeysMap());
    input->addContext(Context("default", DefaultKeysMap::getDefaultContext()));
    input->updateKeyBindings();
    engine.setTogglePhysicsDebugAction(DefaultKeysMap::TOGGLE_PHYSICS_DEBUG);
    engine.setToggleShellAction(DefaultKeysMap::TOGGLE_CONSOLE);
    engine.setExitGameAction(DefaultKeysMap::EXIT_GAME);
    engine.setShowMouseAction(DefaultKeysMap::TOGGLE_MOUSE_CURSOR);

    // setting up SparrowShell
    SparrowShell* shell = engine.getShell();
    shell->setInputs(DefaultKeysMap::MOVE_CURSOR_LEFT,DefaultKeysMap::MOVE_CURSOR_RIGHT,DefaultKeysMap::HISTORY_UP,DefaultKeysMap::HISTORY_DOWN);
    input->addContext(Context("shell",DefaultKeysMap::getShellContext()));
    input->updateKeyBindings();

    // setup editor
    input->addContext(Context("editor",DefaultKeysMap::getObjectEditorContext()));

    // setup menu
    Menu* menu = new Menu(&engine,config);
    Demo* demo = new Demo(&engine,config);
    menu->setLeftClickAction(DefaultKeysMap::LEFT_CLICK);
    input->addContext(Context("menu",DefaultKeysMap::getMenuContext()));
    input->setCurrentContext("menu");
    input->updateKeyBindings();

    menu->setButtonCallBack(new ButtonDemoCallBack(&engine,demo));

    engine.setScene(menu->getScene());
    engine.getInput()->setMouseGrabbed(false);

    engine.start();
}