#include "level.hh"
#include "loader.hh"
#include <string>

Level::Level(std::string xmlFilePath, float farPlane) {
    // default value
    skydomeSize = 50.0f;
    physics = Physics();
    this->xmlFilePath = xmlFilePath;
    this->farPlane = farPlane;
}

Level::Level() {
}

Level::~Level() {
    if (luaState!=nullptr) {
        lua_close(luaState);
    }
    delete(waterPlane);
}

void Level::load() {
    //Intialize lua state
    // Check if there's an existing state and close it
    if(luaState != nullptr){
        lua_close(luaState);
        luaState = nullptr;
    }
    // Create a new lua state
    luaState = luaL_newstate();
    luaL_openlibs(luaState);
    //Expose the class Level and its functions to Lua
    luabridge::getGlobalNamespace(luaState)
        .beginClass<Level>("Level")
        .addFunction("getObjectCount", &Level::getPhysicsObjectsVectorSize)
        .addFunction("moveObject", &Level::moveObject)
        .addFunction("resetPlayer", &Level::resetPlayer)
        .addFunction("movePlayer", &Level::movePlayer)
        .addFunction("setSunDirection", &Level::setSunDirection)
        .addFunction("forceMove", &Level::forceMove)
        .addFunction("activateEndgame", &Level::activateEndgame)
        .addFunction("preloadLightPosition", &Level::preloadLightPosition)
        .addFunction("addLightByParameters", &Level::addLightByParameters)
        .addFunction("deleteFourLights", &Level::deleteFourLights)
        .endClass();
    //Push the level to Lua as a global variable
    luabridge::push(luaState, this);
    lua_setglobal(luaState, "level");
    
    this->camera = Camera(glm::vec2(-0.8f, 0.0f), 3.0f);
}

int Level::checkMaxSurroundingLights() {
    int maxSurroundingLights = 0;
    for(unsigned int i = 0; i<lights.size(); i++) {
        int thisSurroundingLights = 0;
        for(unsigned int j = 0; j<lights.size(); j++) {
            if (glm::distance(lights.at(i)->getPosition(), lights.at(j)->getPosition()) < skydomeSize) {
                thisSurroundingLights++;
            }
        }
        if (thisSurroundingLights > maxSurroundingLights) {
            maxSurroundingLights = thisSurroundingLights;
        }
    }
    return maxSurroundingLights;
}

void Level::render(ACGL::OpenGL::SharedShaderProgram shader, bool lightingPass, 
        glm::vec3 center, int chunkRenderDistance, glm::mat4* viewProjectionMatrix,
        std::vector<glm::mat4>* shadowVPs) {
    std::vector<Chunk*> nearChunks = getSurroundingChunks(center, chunkRenderDistance);
    for(unsigned int i = 0; i<nearChunks.size(); i++) {
        nearChunks.at(i)->render(shader, lightingPass, viewProjectionMatrix, shadowVPs);
    }
    for (unsigned int i = 0; i<crossChunkObjects.size(); i++) {
        crossChunkObjects.at(i)->render(shader, lightingPass, viewProjectionMatrix, shadowVPs);
    }
}

void Level::enqueueObjects(Graphics* graphics) {
    std::vector<Chunk*> nearChunks = getSurroundingChunks(cameraCenter->getPosition(), -1);
    for(unsigned int i = 0; i<nearChunks.size(); i++) {
        graphics->enqueueObjects(nearChunks.at(i)->getSortedObjects());
    }
    graphics->enqueueObjects(&sortedCrossChunkObjects);
}

std::vector<Chunk*> Level::getSurroundingChunks(glm::vec3 center, int chunkRenderDistance) {
    int renderDistance = 0;
    if (chunkRenderDistance < 0) {
        if ((int)farPlane % chunkSize == 0) {
            renderDistance = (((int)skydomeSize)+chunkSize/2)/chunkSize;
        }
        else {
            renderDistance = ((((int)skydomeSize)+chunkSize/2)/chunkSize) + 1;
        }
    }
    else {
        renderDistance = chunkRenderDistance;
    }
    int xPosition = ((int)center.x + (terrain.getHeightmapWidth()/2))/chunkSize;
    int zPosition = ((int)center.z + (terrain.getHeightmapHeight()/2))/chunkSize;
    int xStart = xPosition - renderDistance;
    unsigned int xEnd = xPosition + renderDistance;
    int zStart = zPosition - renderDistance;
    unsigned int zEnd = zPosition + renderDistance;
    if (xStart < 0) {
        xStart = 0;
    }
    if (zStart < 0) {
        zStart = 0;
    }
    if (xEnd >= chunks.size()) {
        xEnd = chunks.size()-1;
    }
    if (zEnd >= chunks.at(0).size()) {
        zEnd = chunks.at(0).size()-1;
    }
    std::vector<Chunk*> vector = std::vector<Chunk*>((xEnd - xStart + 1)*(zEnd - zStart + 1));
    int counter = 0;
    for(unsigned int i = xStart; i<=xEnd; i++) {
        for(unsigned int j = zStart; j<=zEnd; j++) {
            vector.at(counter) = &chunks.at(i).at(j);
            counter++;
        }
    }
    return vector;
}

void Level::sortObjects(int textureCount) {
    for(unsigned int i = 0; i<chunks.size(); i++) {
        for(unsigned int j = 0; j<chunks.at(i).size(); j++) {
            chunks.at(i).at(j).sortObjects(textureCount);
        }
    }
    // init
    sortedCrossChunkObjects = std::vector<std::vector<Object*>>(textureCount);
    for(unsigned int i = 0; i<sortedCrossChunkObjects.size(); i++) {
       sortedCrossChunkObjects.at(i) = std::vector<Object*>(); 
    }
    for(unsigned int i = 0; i<crossChunkObjects.size(); i++) {
        sortedCrossChunkObjects.at(crossChunkObjects.at(i)->getMaterial()->getTextureUnit() - 2)
            .push_back(crossChunkObjects.at(i));
    }
}

void Level::update(float runTimeSinceLastUpdate, float runTime, glm::vec2 mouseDelta, 
        KeyboardState* keyboardState) {
    
    // Ignore first two mouse updates, because they are incorrect
    // DON'T try to move this functionallity elsewhere
    static int i = 0;
    if (i <20) {
        i++;
        mouseDelta.x=mouseDelta.y=0;
    }
    
    const int runs = 4;
    
    if(i>=20)
    {
        mouseDelta.x = -mouseDelta.x;
    }
        
    for(int j = runs; j > 0; j--)
    {
        physics.takeUpdateStep(runTimeSinceLastUpdate/runs);
        
        camera.updateRotation(mouseDelta/100.0f/(float)runs);
        physics.updateCameraPos(mouseDelta, 50/runs, camera.getDistance());
            
        camera.setPosition(physics.getCameraPosition());
        camera.setDirection(physics.getCameraToPlayer());
        
        if(keyboardState->wPressed){
            physics.rollForward(camera.getVector(),strength/runs);
        }
        if(keyboardState->aPressed) {
            physics.rollLeft(camera.getVector(),strength/runs);
        }
        if(keyboardState->sPressed) {
            physics.rollBack(camera.getVector(),strength/runs);
        }
        if(keyboardState->dPressed){
            physics.rollRight(camera.getVector(),strength/runs);
        }
     }
        
        if(keyboardState->f1Pressed) {
            physics.forcePlayer(glm::vec3(17.5, 21.0, 87.0));
        }
        if(keyboardState->f2Pressed) {
            physics.forcePlayer(glm::vec3(-78.5, 21.75, 4.5));
        }
        if(keyboardState->f3Pressed) {
            physics.forcePlayer(glm::vec3(-169.5, 21.5, 58.5));
        }
        if(keyboardState->f4Pressed) {
            physics.forcePlayer(glm::vec3(-180.5, 21.75, 58.5));
        }

        if(keyboardState->kPressed)
            camera.setIsPhysicsCamera(true);
        if(keyboardState->lPressed)
            camera.setIsPhysicsCamera(false);
        
        cameraCenter->setPosition(physics.getPos(0));
        cameraCenter->setRotation(physics.getRotation(0));
        
        for(unsigned i = 0; i < physicsObjects.size();i++)
        {
            physicsObjects[i]->setPosition(physics.getPos(i));
            physicsObjects[i]->setRotation(physics.getRotation(i));
        }
        
        skydome.setPosition(glm::vec3(cameraCenter->getPosition().x, 
            0.0f, cameraCenter->getPosition().z));

        if (runTime > 2.0f) {
            for(unsigned int i = 0; i<triggers.size(); i++) {
                triggers.at(i).triggerUpdate();
            }
        }
}

glm::vec3 Level::getAmbientLight() {
    return ambientLight;
}

std::vector<shared_ptr<Light>>* Level::getLights() {
    return &lights;
}

Camera* Level::getCamera() {
    return &camera;
}

Object* Level::getCameraCenter() {
    return cameraCenter;
}

Light* Level::getDirectionalLight() {
    return &directionalLight;
}

glm::vec4 Level::getFogColourDay() {
    return fogColourDay;
}

glm::vec4 Level::getFogColourRise() {
    return fogColourRise;
}

glm::vec4 Level::getFogColourNight() {
    return fogColourNight;
}

glm::vec3 Level::getCameraPosition() {
   return cameraCenter->getPosition() + camera.getVector();
}

void Level::setSkydomeSize(float size) {
    skydomeSize = size;
}

float Level::getSkydomeSize() {
    return this->skydomeSize;
}

std::vector<Object*>* Level::getAllObjects() {
    return &allObjects;
}

std::vector<Object*>* Level::getPhysicsObjects() {
    return &physicsObjects;
}

void Level::moveObject(int objectIndex, float strength, float xPos, float yPos, float zPos){
    glm::vec3 position = glm::vec3(xPos, yPos, zPos);
    physics.removePositionConstraint(objectIndex);
    physics.addPositionConstraint(objectIndex, strength, position);
}

void Level::resetPlayer(){
    Loader loader = Loader();
    glm::vec3 newPosition = loader.reloadPlayerPosition(xmlFilePath, this);
    physics.forcePlayer(newPosition);
}

void Level::movePlayer(float xPosition, float yPosition, float zPosition){
    glm::vec3 newPosition = glm::vec3(xPosition, yPosition, zPosition);
    physics.forcePlayer(newPosition);
}

void Level::setPlayerIndex(int index){
    playerIndex = index;
}

void Level::setStrength(float strength) {
    this->strength = strength;
}

void Level::setSkydomeObject(Skydome object){
    this->skydome = object;
}

void Level::addObject(Object* object, bool crossesChunks) {
    allObjects.push_back(object);
    if (crossesChunks) {
        crossChunkObjects.push_back(object);
    }
    else {
        int xPosition = ((int)object->getPosition().x + (terrain.getHeightmapWidth()/2))/chunkSize;
        int zPosition = ((int)object->getPosition().z + (terrain.getHeightmapHeight()/2))/chunkSize;
        chunks.at(xPosition).at(zPosition).addObject(object);
    }
}

void Level::addToSpecificChunk(Object* object, int xPosition, int zPosition) {
    chunks.at(xPosition).at(zPosition).addObject(object);
}

void Level::addPhysicsObject(Object* object) {
    physicsObjects.push_back(object);
}

void Level::setAmbientLight(glm::vec3 colour) {
    this->ambientLight = colour;
}

void Level::setFogColourDay(glm::vec4 colour) {
    this->fogColourDay = colour;
}

void Level::setFogColourRise(glm::vec4 colour) {
    this->fogColourRise = colour;
}

void Level::setFogColourNight(glm::vec4 colour) {
    this->fogColourNight = colour;
}

void Level::setDirectionalLight(Light light) {
    this->directionalLight = light;
}

void Level::setSunDirection(float x, float y, float z){
    glm::vec3 lightPosition = glm::vec3(x,y,z);
    glm::vec3 lightColour = this->directionalLight.getColour();
    float lightIntensity = this->directionalLight.getIntensity();
    this->directionalLight = Light(lightPosition, lightColour, lightIntensity);
}

Physics* Level::getPhysics() {
    return &physics;
}

unsigned int Level::getPhysicsObjectsVectorSize() {
    return physicsObjects.size();
}

void Level::setCameraCenter(Object* object) {
    this->cameraCenter = object;
}

void Level::addLight(Light light) {
    shared_ptr<Light> add_light = shared_ptr<Light>(new Light(light));
    this->lights.push_back(add_light);
}

void Level::preloadLightPosition(float xPos, float yPos, float zPos){
    nextLightPosition = glm::vec3(xPos, yPos, zPos);
}

void Level::addLightByParameters(float redColour, float greenColour, float blueColour,  float intensity, float flameYOffset, float flameHeight, float flameWidth){
    glm::vec3 colour = glm::vec3(redColour, greenColour, blueColour);
    this->addLight(Light(nextLightPosition, colour, intensity, flameYOffset, flameHeight, flameWidth));
}

void Level::deleteFourLights(){
    int indice = lights.size()-4;
    lights.erase(lights.begin() + indice);
    lights.erase(lights.begin() + indice);
    lights.erase(lights.begin() + indice);
    lights.erase(lights.begin() + indice);
}

void Level::addTrigger(Trigger trigger) {
    this->triggers.push_back(trigger);
}

lua_State* Level::getLuaState() {
    return luaState;
}

Terrain* Level::getTerrain() {
    return &terrain;
}

Skydome* Level::getSkydome() {
    return &skydome;
}

void Level::forceMove(float x, float y, float z, unsigned indice){
    glm::vec3 position = glm::vec3(x,y,z);
    physics.forceMove(position, indice);
}

void Level::activateEndgame(){
    physics.activateEndgame();
}

void Level::setWaterPlane(Object* water) {
    this->waterPlane = water;
}

void Level::setTerrain(Terrain terrain) {
    this->terrain = terrain;
}

void Level::printPosition() {
    printf("Player position: %2.2f, %2.2f, %2.2f\n", cameraCenter->getPosition().x,
            cameraCenter->getPosition().y, cameraCenter->getPosition().z);
}

void Level::generateChunks(int chunkSize) {
    this->chunkSize = chunkSize;
    int numberChunksX = 0;
    if (terrain.getHeightmapWidth() % chunkSize == 0) {
        numberChunksX = terrain.getHeightmapWidth()/chunkSize;
    }
    else {
        numberChunksX = (terrain.getHeightmapWidth()/chunkSize) + 1;
    }
    int numberChunksZ = 0;
    if (terrain.getHeightmapHeight() % chunkSize == 0) {
        numberChunksZ = terrain.getHeightmapHeight()/chunkSize;
    }
    else {
        numberChunksZ = (terrain.getHeightmapHeight()/chunkSize) + 1;
    }
    chunks = std::vector<std::vector<Chunk>> (numberChunksX);
    for(int i = 0; i<numberChunksX; i++) {
        std::vector<Chunk> zChunks = std::vector<Chunk>(numberChunksZ);
        for(int j = 0; j<numberChunksZ; j++) {
            zChunks.at(j) = Chunk();
        }
        chunks.at(i) = zChunks;
    }
}

std::vector<std::vector<Chunk>>* Level::getChunks() {
    return &chunks;
}

Object* Level::getWaterPlane() {
    return waterPlane;
}

bool Level::compareLightDistances(shared_ptr<Light> a, shared_ptr<Light> b) {
    if (glm::distance(cameraCenter->getPosition(), a->getPosition()) <
            glm::distance(cameraCenter->getPosition(), b->getPosition())) {
        return true;
    }
    else {
        return false;
    }
}

std::vector<shared_ptr<Light>>* Level::getClosestLights(unsigned int maximumAmount) {
    closestLights = std::vector<shared_ptr<Light>>(lights);
    std::sort(closestLights.begin(),
        closestLights.end(),
        [this](shared_ptr<Light> a, shared_ptr<Light> b) {return compareLightDistances(a, b); });
    if (lights.size() > maximumAmount) {
        closestLights = std::vector<shared_ptr<Light>>(&closestLights[0],
                &closestLights[maximumAmount]);
    }
    // sort pointers for faster comparisons
    std::sort(closestLights.begin(), closestLights.end());
    return &closestLights;
}