#include "engine/camera.hpp"
#include "engine/largepos.hpp"
#include "engine/light.hpp"
#include "engine/object.hpp"
#include "engine/planet.hpp"
#include "engine/rendering.hpp"
#include "engine/shader.hpp"
#include "engine/simple-shapes.hpp"
#include "engine/texture.hpp"
#include "engine/multipass.hpp"
#include <SDL2/SDL_events.h>
#include <SDL2/SDL_keycode.h>
#include <SDL2/SDL_mouse.h>
#include <SDL2/SDL_timer.h>
#include <SDL2/SDL_video.h>
#include <SDL2/SDL_keyboard.h>
#include <cstddef>
#include <cstdlib>
#include <glm/detail/qualifier.hpp>
#include <glm/ext/matrix_transform.hpp>
#include <glm/ext/vector_float3.hpp>
#include <glm/fwd.hpp>
#include <glm/geometric.hpp>
#include <glm/gtx/quaternion.hpp>
#include <glm/trigonometric.hpp>
#include <iostream>
#include <iterator>
#include <string>

void cke(){
   GLenum err = glGetError();
          if (err != GL_NO_ERROR) {
    std::cout<<"\n" << err << "frm\n";
    exit(-1);
  }
}


void printerror(GLenum source, GLenum type, GLuint id,
   GLenum severity, GLsizei length, const GLchar* message, const void* userParam){
  std::cout<<message;
}

int main(int argc, char *argv[]) {
  auto t_start = std::chrono::high_resolution_clock::now();

  rendering renderer;

  renderer.SDLinit();
  SDL_Window *window =
      SDL_CreateWindow("aaa", 20, 20, 800, 600, SDL_WINDOW_OPENGL);
  renderer.GLinit(window);

  if(!renderer.Shaderinit()) return -1;

  renderer.farClipPlane=100;
  renderer.width=800;
  renderer.height=600;
  glEnable(GL_DEPTH_TEST);
  glEnable(GL_CULL_FACE);
  glEnable(GL_DEBUG_OUTPUT);
  glDebugMessageCallback((void (*)(unsigned int, unsigned int, unsigned int, unsigned int, int, const char *, const void *))printerror,NULL);

  vertex vertices[] = {
      vertex(-0.5f, 0.5f, -0.5f),
      vertex(0.5f, 0.5f, -0.5f),
      vertex(0.5f, -0.5f, -0.5f),
      vertex(-0.5f, -0.5f, -0.5f),

      vertex(-0.5f, 0.5f, -0.5f),
      vertex(0.5f, 0.5f, -0.5f),
      vertex(-0.5f, 0.5f, 0.5f),
      vertex(0.5f, 0.5f, 0.5f),

      vertex(-0.5f, -0.5f, -0.5f),
      vertex(0.5f, -0.5f, -0.5f),
      vertex(-0.5f, -0.5f, 0.5f),
      vertex(0.5f, -0.5f, 0.5f),

      vertex(-0.5f, 0.5f, 0.5f),
      vertex(0.5f, 0.5f, 0.5f),
      vertex(0.5f, -0.5f, 0.5f),
      vertex(-0.5f, -0.5f, 0.5f),
  };
  vertex color[] = {
      vertex(0.f, 0.5f, 0.f),
      vertex(1.f, 0.5f, 0.f),
      vertex(1.f, 0.5f, 0.f),
      vertex(1.f, 0.5f, 0.f),

      vertex(0.f, 0.5f, 0.5f),
      vertex(1.f, 0.5f, 0.5f),
      vertex(1.f, 0.5f, 0.5f),
      vertex(1.f, 0.5f, 0.5f),

      vertex(0.f, 1.f, 0.5f),
      vertex(1.f, 1.f, 0.5f),
      vertex(1.f, 1.f, 0.5f),
      vertex(1.f, 1.f, 0.5f),
      
      vertex(0.f, 0.5f, 0.f),
      vertex(1.f, 0.5f, 0.f),
      vertex(1.f, 0.5f, 0.f),
      vertex(1.f, 0.5f, 0.f),
      
  };

  GLuint elements[] = {
   0, 1, 2, 2, 3, 0,

   5,4,6, 6,7,5,
  8,9,10, 11,10,9,


   1,7,2, 2,7,11,
  0,3,10, 12,0,10,


    13,12,14,12,15,14
  };

  gameobject test(&renderer.shaders.at(1));
  renderer.objects.push_back(test);


  test.genVbo(vertices, sizeof(vertices) / sizeof(vertices[1]));
  test.setVertexAtribPointer("position", 0);

  //std::cout<<"faa "<< renderer.shaders.at(1).getInputId("position")<<"ffauf\n";



  test.genVboShadow();
  test.setVertexAtribPointerShadow("position", &renderer.shaders.at(3), 0);

  test.genEbo(elements, sizeof(elements) / sizeof(elements[1]));
  test.genEboShadow();

  test.setBuffer(color, sizeof(color) / sizeof(color[1]), test.COLOR_BUFFER);
  test.setVertexAtribPointer("color", 0);
  test.positionMatrix = glm::translate(test.positionMatrix, glm::vec3(0.f,-0.5f,-1.f));
  test.distmult=1.0;


  gameobject test2(&renderer.shaders.at(1));
  renderer.objects.push_back(test2);

  planet plt;
  plt.generateSphere();
  planetMesh pltm = plt.toPlanetMesh();

  glm::vec3 *pltvrts=plt.chunks[0].vtx->vertices;

  test2.genVbo(pltm.vertices, pltm.numverts);
  test2.setVertexAtribPointer("position", 0);

  test2.genEbo(pltm.indices, pltm.numindecies);

  test2.setBuffer(color, sizeof(color) / sizeof(color[1]), test2.COLOR_BUFFER);
  test2.setVertexAtribPointer("color", 0);
  test2.scaleMatrix=glm::scale(glm::mat4(1.0), glm::vec3(1.0));
  test2.positionMatrix = glm::translate(test2.positionMatrix, glm::vec3(0.f,-0.5f,-1.f));
  test2.rotationMatrix=glm::rotate(glm::mat4(1.0f), (float)glm::radians(180.0), glm::vec3(0.0,1.0,0.0));
  test2.distmult=1.0;

  test.rend_shader->use();

  camera mainCamera;
  mainCamera.proj= glm::perspective(glm::radians(45.0f), 800.0f / 600.0f, 0.1f, renderer.farClipPlane);
  mainCamera.view= glm::lookAt(glm::vec3(1.2f, 1.2f, 1.2f), glm::vec3(0.0f, 0.0f, 0.0f),
                  glm::vec3(0.0f, 0.0f, 1.0f));
  test.shdViewId=test.rend_shader->getUniformId("view");
  test.shdProjId=test.rend_shader->getUniformId("proj");
  test.shdTrnsId=test.rend_shader->getUniformId("trans");

  test2.shdViewId=test2.rend_shader->getUniformId("view");
  test2.shdProjId=test2.rend_shader->getUniformId("proj");
  test2.shdTrnsId=test2.rend_shader->getUniformId("trans");
  test2.spacePos.fx=100.0;
  test2.spaceAct=true;

  renderer.shaders.at(2).use();
  Gbuffer gbuf;

  gbuf.init(800, 600);

  gbuf.bind();



  renderer.mkDepthBuffer();
  


  mainCamera.pos=glm::vec3(1.2f,6.2f,1.2f);
  renderer.lights.push_back(light(glm::vec3(0.f,0.f,5.f)));



  // trans = glm::rotate(trans, glm::radians(10.0f), glm::vec3(0.0f,
  // 0.0f, 1.0f));


  /*texture tex;
  tex.loadFromPath("sample.png",
                   VELAGE_generateTextureSettings(GL_CLAMP_TO_EDGE, GL_LINEAR),
                   GL_TEXTURE0);
  tex.setTexUniformLocation("tex1", 0, test.rend_shader);*/

  // std::cout<<renderer.objects.at(0).get().element_number;

    if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
        std::cout << "Framebuffer not complete!" << std::endl;

  
  SDL_Event windowEvent;
  bool running = true;

  bool keys[500];

  for (int i=0; i<400; i++) {
    keys[i]=false;
  }

  float lastframe;
  float currentframe;
  float deltaTime;

  float camSpeed=10.f;

  float pitch=0.f;
  float yaw=-90.f;

  float lastx;
  float lasty;

  bool firstMouse=true;

  SDL_SetRelativeMouseMode(SDL_TRUE);

  renderer.mkShadowCubemap();

  while (running) {
    while (SDL_PollEvent(&windowEvent)) {
      switch (windowEvent.type) {
        case SDL_QUIT:
          running = false;
          break;
        case SDL_KEYDOWN:
          //std::cout<<windowEvent.key.keysym.sym<<"wwa \n";
          keys[windowEvent.key.keysym.sym&~(1<<30)]=true;
          break;
        case SDL_KEYUP:
          if (windowEvent.key.keysym.sym == SDLK_ESCAPE)
            running = false;
          //std::cout<<windowEvent.key.keysym.sym<<"aww \n";
          keys[windowEvent.key.keysym.sym&~(1<<30)]=false;
          break;
      }
    }

    if(keys[SDLK_w]){
      mainCamera.pos+=mainCamera.forward*camSpeed*deltaTime;
      mainCamera.spacePos+=mainCamera.forward*camSpeed*deltaTime;
    }
    if(keys[SDLK_s]){
      mainCamera.pos-=mainCamera.forward*camSpeed*deltaTime;
      mainCamera.spacePos-=mainCamera.forward*camSpeed*deltaTime;

    }
    if(keys[SDLK_a]){
      mainCamera.pos+=glm::normalize(glm::cross(mainCamera.forward, mainCamera.up))*camSpeed*deltaTime;
      mainCamera.spacePos+=glm::normalize(glm::cross(mainCamera.forward, mainCamera.up))*camSpeed*deltaTime;
    }
    if(keys[SDLK_d]){
      mainCamera.pos-=glm::normalize(glm::cross(mainCamera.forward, mainCamera.up))*camSpeed*deltaTime;
      mainCamera.spacePos-=glm::normalize(glm::cross(mainCamera.forward, mainCamera.up))*camSpeed*deltaTime;
    }
    if(keys[SDLK_q]){
      mainCamera.rotateY(-3);
    }
    if(keys[SDLK_e]){
      mainCamera.rotateY(3);
    }


    int mx;
    int my;
    SDL_GetRelativeMouseState(&mx, &my);

    pitch+=(mx)*0.3f;
    yaw+=(my)*0.3f;

    
    mainCamera.rotateZ(-(mx)*0.3f);
    mainCamera.rotateX((my)*0.3f);

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
    //glClear(GL_COLOR_BUFFER_BIT);
        
    

    auto t_now = std::chrono::high_resolution_clock::now();
    float time = std::chrono::duration_cast<std::chrono::duration<float>>(
                     t_now - t_start)
                     .count();
    currentframe=time;
    deltaTime=currentframe-lastframe;
    lastframe=currentframe;

    test2.updateMatrix(mainCamera);

    


    glm::mat4 trans = glm::mat4(1.0f);
    trans = glm::rotate(trans, time * glm::radians(180.0f),
                        glm::vec3(0.0f, 0.0f, 1.0f));
    test.rotationMatrix = trans;

    mainCamera.update();

    largePos a;
    largePos b;
    a.fx=20;
    b.fx=10;

    //std::cout<<(a-b).fx<<"ä\n";

    renderer.render(mainCamera, &renderer.shaders.at(3), &renderer.shaders.at(4), &gbuf);

    renderer.shaders.at(0).use();
    //test.render(mainCamera);
    SDL_GL_SwapWindow(window);

    SDL_Delay(16);
  }

  SDL_GL_DeleteContext(renderer.context);

  SDL_Quit();
  return 0;
}

    // renderer.shaders.at(3).use();

    // glUniform3f(renderer.shaders.at(3).getUniformId("lights[0].Position"), 0.f,0.f,5.f);
    // glUniform3f(renderer.shaders.at(3).getUniformId("lights[0].Color"), 1.f,1.f,1.f);

    // test.renderShadows(light(glm::vec3(0.,0.,5.)), renderer.SHADOW_WIDTH, renderer.SHADOW_HEIGHT, renderer.depthCubemap, &renderer.shaders.at(3), renderer.depthFBO, renderer.farClipPlane, true);
    // test2.renderShadows(light(glm::vec3(0.,0.,5.)), renderer.SHADOW_WIDTH, renderer.SHADOW_HEIGHT, renderer.depthCubemap, &renderer.shaders.at(3), renderer.depthFBO, renderer.farClipPlane);

    // cke();// return -1;

    // renderer.shaders.at(1).use();


    // glActiveTexture(GL_TEXTURE0);
    // glBindTexture(GL_TEXTURE_CUBE_MAP, renderer.depthCubemap);
    // glUniform1i(renderer.shaders.at(1).getUniformId("depthMap"), 0);

    // gbuf.bindW();
    // gbuf.clear();


    // glUniform3f(renderer.shaders.at(1).getUniformId("lights[0].Position"), 0.f,0.f,5.f);
    // glUniform3f(renderer.shaders.at(1).getUniformId("lights[0].Color"), 1.f,1.f,1.f);

    // glUniform1f(renderer.shaders.at(1).getUniformId("far_plane"), 100.f);


    // test.render(mainCamera);
    // test2.render(mainCamera);

    // renderer.shaders.at(2).use();

    // glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);

    // gbuf.bindR();
    // // tex 0 position
    // // tex 1 normals
    // // tex 2 diffuse (albedo)
    // // tex 3 texcoord
    // // tex 4 shadow

    // renderer.setupTextureDS(gbuf);

    // glUniform1i(renderer.shaders.at(2).getUniformId("gPosition"),0);
    // glUniform1i(renderer.shaders.at(2).getUniformId("gNormal"),1);
    // glUniform1i(renderer.shaders.at(2).getUniformId("gAlbedoSpec"),2);
    // glUniform1i(renderer.shaders.at(2).getUniformId("gShadow"),4);

    

    // glUniform3f(renderer.shaders.at(2).getUniformId("lights[0].Position"), 0.f,0.f,0.f);
    // glUniform3f(renderer.shaders.at(2).getUniformId("lights[0].Color"), 1.f,1.f,1.f);

    // if(firstMouse){
    //   firstMouse=false;
    //   //std::cout<<"löoel "<< renderer.shaders.at(3).geometryShader<<" \n";
    // }

    // renderer.renderlighting(renderer.shaders.at(2).getInputId("position"),renderer.shaders.at(2).getInputId("TexCoord"));

    
    // renderer.cpyDepthBuffer(gbuf.fbo);

    //enderer.shaders.at(0).use();

    // if(firstMouse){
    //   //firstMouse=false;
    //   // std::cout<<"\n"<<renderer.shaders.at(2).getInputId("position")<<" löl\n";
    //   GLint count;
    //   glGetProgramiv(renderer.shaders.at(3).shaderProgram, GL_ACTIVE_UNIFORMS, &count);

    //   // std::cout<<gbuf.textus[gbuf.GBUFER_TEXTURE_DIFFUSE]<< " fffa \n";
    //   // std::cout<<count<<" aaa\n";
    //   for (int i=0; i<count; i++) {
    //     GLsizei length, size;
    //     GLenum type;
    //     GLchar name[32];
    //     glGetActiveUniform(renderer.shaders.at(3).shaderProgram, (GLuint)i, 32, &length, &size, &type, name);
    //     std::cout<<name<<" "<< length<<" fff\n";
    //   }
    //}
    //glUniform1f(renderer.shaders.at(3).getUniformId("far_plane"), 100.f);
    
    //cke(); return -1;


    //std::cout<<"\n"<<renderer.shaders.at(3).getUniformId("far_plane");