#include "sons_of_sol/SonsOfSolApplication.hpp"

#include "glox/GloxLightSource.hpp"
#include "glox/GloxRotation.hpp"
#include "glox/GloxScopedRotation.hpp"

#include <iostream>

using namespace slox;
using namespace glox;
using namespace std;

bool SonsOfSolApplication::initialize(int argc, char** argv) {
  (void)argc;
  (void)argv;
  /* Use our texture factory to load textures */
  m_object_loader.setTextureFactory(&m_texture_factory);
  m_is_paused = false;

  setupControls();

  SDL_Init(SDL_INIT_VIDEO);
  SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
  const SDL_VideoInfo* info =
      SDL_GetVideoInfo();  //<-- calls SDL_GetVideoInfo();
  m_screen_width = info->current_w;
  m_screen_height = info->current_h;
  m_screen =
      SDL_SetVideoMode(600, 600, 0, SDL_OPENGL | SDL_RESIZABLE | SDL_DOUBLEBUF);

  m_perspective.setPosition(GloxPoint<>(0, 0, 10));
  m_perspective.setZFar(FAR_DISTANCE_END);
  m_perspective.setZNear(FAR_DISTANCE_START);
  m_ship.setPerspective(m_perspective);
  m_ship.setPosition(GloxPointf(0, 10, -3));

  if (argv[1] == NULL || strcmp(argv[1], "nograb")) {
    SDL_ShowCursor(0);
    SDL_WM_GrabInput(SDL_GRAB_ON);
  }

  if (glewInit() != GLEW_OK) {
    cerr << "Unable to initialize GLEW" << endl;
    exit(122);
  }

  /* Add some listeners */
  this->addQuitListener(this);
  this->addKeyListener(this);

  this->addResizeListener(this);

  m_event_multiplexer.addControlMotionListener(&m_ship);

  if (!m_screen) {
    /* If the screen could not be initialized, print
         * a useful video message */
    this->setError("Cannot set SDL video mode\n");
    return false;
  }

  SDL_WM_SetCaption("Sons Of Sol", "");
  reshape(m_screen->w, m_screen->h);

  /* Load the textures into memory */
  if (!loadTextures())
    return false;

  GloxTextureRepeat texrep(&m_sky_tex, 1.8, 1.8);
  m_sky = new GloxTexturedCube(FAR_DISTANCE_END - 100, GloxColor(255, 255, 255),
                               texrep, texrep, texrep, texrep, texrep, texrep);

  texrep = GloxTextureRepeat(&m_crate_tex, 1, 1);
  m_crate = new GloxTexturedCube(5.0f, GloxColor(255, 255, 255), texrep, texrep,
                                 texrep, texrep, texrep, texrep);

  m_object_loader.addToPath("objects");
  m_object_loader.addToPath("objects/material");
  m_earth = new GloxTexturedSphere(FAR_DISTANCE_END / 4.0, 5.0f, m_earth_tex);
  m_moon = new GloxTexturedSphere(FAR_DISTANCE_END / 24.0, 5.0f, m_moon_tex);
  m_probe = m_object_loader.loadObjectFromFile("probe.obj");

  m_script_ttl = 130;
  if (!m_probe) {
    cerr << "Unable to load probe: " << m_object_loader.getReason() << endl;
    exit(123);
  }

  m_frigate_industrial =
      m_object_loader.loadObjectFromFile("frigate_industrial.obj");
  if (!m_frigate_industrial) {
    cerr << "Unable to load frigate_industrial\n"
         << m_object_loader.getReason() << endl;
    exit(123);
  }

  m_other_ship = m_object_loader.loadObjectFromFile("ship.obj");
  SloxModelObject* ship_med =
      m_object_loader.loadObjectFromFile("ship_med.obj");
  SloxModelObject* ship_low =
      m_object_loader.loadObjectFromFile("ship_low.obj");
  if (!(m_other_ship && ship_med && ship_low)) {
    cerr << "Unable to load other ship\n"
         << m_object_loader.getReason() << endl;
    exit(123);
  }

  m_test_cube = m_object_loader.loadObjectFromFile("cube.obj");
  if (!m_test_cube) {
    cerr << "Unable to load test cube\n" << m_object_loader.getReason() << endl;
    exit(123);
  }

  m_deathstar = m_object_loader.loadObjectFromFile("deathstar.obj");
  if (!m_deathstar) {
    cerr << "Unable to load deathstar\n" << m_object_loader.getReason() << endl;
    exit(123);
  }

  m_acceleration_cannon =
      m_object_loader.loadObjectFromFile("acceleration_cannon.obj");
  if (!m_acceleration_cannon) {
    cerr << "Unable to load acceleration cannon\n"
         << m_object_loader.getReason() << endl;
    exit(123);
  }

  AIShip::setModel(m_other_ship, ship_med, ship_low);

  float xstart = 0.5 * (-FAR_DISTANCE_END / 5.0f);
  float xend = 0.5 * (-xstart);
  float ystart = 0.3 * (FAR_DISTANCE_END / 3.0f - FAR_DISTANCE_END / 2);
  float yend = 0.3 * (ystart + 2 * (FAR_DISTANCE_END / 5.0f));
  /* Add the points for the sun */
  m_star.add(GloxPointNormalTexture(
      GloxPoint<>(xstart, ystart, -(FAR_DISTANCE_END) / 3),
      GloxNormal<>(0, 0, 0), GloxPoint<>(0, 0)));
  m_star.add(
      GloxPointNormalTexture(GloxPoint<>(xend, ystart, -(FAR_DISTANCE_END) / 3),
                             GloxNormal<>(0, 0, 0), GloxPoint<>(1, 0)));
  m_star.add(
      GloxPointNormalTexture(GloxPoint<>(xend, yend, -(FAR_DISTANCE_END) / 3),
                             GloxNormal<>(0, 0, 0), GloxPoint<>(1, 1)));
  m_star.add(
      GloxPointNormalTexture(GloxPoint<>(xstart, yend, -(FAR_DISTANCE_END) / 3),
                             GloxNormal<>(0, 0, 0), GloxPoint<>(0, 1)));

  /* Move the light souce to the sun */
  GloxLightSource* source = m_light_manager.getLightSource(0);
  source->setPosition(GloxPointf(0, 200, -695));

  m_quit = false;

  /* Starting ships */
  for (int i = 0; i < 5; ++i) {
    AIShip::Updater* updater =
        new EllipseUpdater(GloxPointf(0, -10, 0), GloxPointf(0, 10, 10),
                           GloxPointf(10, i * 5, 0), 0.01);
    m_updaters.push_back(updater);
    AIShip tmp(updater);
    tmp.setTimeOffset(1000 * i);
    m_aiships.push_back(tmp);
  }

  /* Frigate ships */
  for (int j = 0; j < 360; j += 72) {
    for (int i = 0; i < 10; ++i) {
      float pos = 10000 + 100 * i;
      GloxPointf center(pos, pos, pos);
      float cos = GloxCos(j);
      float sin = GloxSin(j);
      AIShip::Updater* updater =
          new EllipseUpdater(center, GloxPointf(60 * cos, -100 * sin, 2),
                             GloxPointf(50 * cos, 10 * sin, 50) * 2, 0.002);
      m_updaters.push_back(updater);
      AIShip tmp(updater);
      tmp.setTimeOffset(100000 * i);
      m_aiships.push_back(tmp);
    }
  }

  /* Deathstar ships */
  for (int j = 0; j < 360; j += 72) {
    for (int i = 0; i < 10; ++i) {
      float pos = 100 * i;
      GloxPointf center(5000 + pos, -1000 + pos, -20000 + pos);
      float cos = GloxCos(j);
      float sin = GloxSin(j);
      AIShip::Updater* updater =
          new EllipseUpdater(center, GloxPointf(60 * cos, -70 * sin, 2),
                             GloxPointf(50 * cos, 10 * sin, 40) * 2, 0.002);
      m_updaters.push_back(updater);
      AIShip tmp(updater);
      tmp.setTimeOffset(10000 * i);
      m_aiships.push_back(tmp);
    }
  }

  m_earth_prog = new GloxProgram();

  printf("Using GLSL version %s\n", glGetString(GL_SHADING_LANGUAGE_VERSION));

  const char* earth_frag_shader = "shaders/earth.fp";
  float version = atof((const char*)glGetString(GL_SHADING_LANGUAGE_VERSION));
  if (version < 1.29) {
    fprintf(
        stderr,
        "Using version %02f, unfortunately, I must use the fallback shader\n",
        version);
    earth_frag_shader = "shaders/earth_fallback.fp";
  }

  if (m_earth_prog->attachShaderFromFile("shaders/earth.vp",
                                         GL_VERTEX_SHADER) ||
      m_earth_prog->attachShaderFromFile(earth_frag_shader,
                                         GL_FRAGMENT_SHADER) ||
      m_earth_prog->link()) {
    cerr << "Warning Unable to load shaders: " << GloxShader::getMessage()
         << endl;
  }
  m_earth_shader_light_pos = m_earth_prog->getUniformLocation("lightPos");
  m_earth_shader_camera_pos = m_earth_prog->getUniformLocation("cameraPos");
  m_earth_shader_time = m_earth_prog->getUniformLocation("time");

  // cout << "Earth light  " << m_earth_shader_light_pos  << endl;
  // cout << "Earth camera " << m_earth_shader_camera_pos << endl;

  m_moon_prog = new GloxProgram();
  if (m_moon_prog->attachShaderFromFile("shaders/moon.vp", GL_VERTEX_SHADER) ||
      m_moon_prog->attachShaderFromFile("shaders/moon.fp",
                                        GL_FRAGMENT_SHADER) ||
      m_moon_prog->link()) {
    cerr << "Warning Unable to load shaders: " << GloxShader::getMessage()
         << endl;
  }
  m_moon_shader_light_pos = m_moon_prog->getUniformLocation("lightPos");
  m_moon_shader_camera_pos = m_moon_prog->getUniformLocation("cameraPos");

  // start the starting light
  GloxLightSource* start = m_light_manager.getLightSource(0);
  start->setLightModelAttribute(GL_LIGHT_MODEL_AMBIENT, GloxColor(50, 50, 50));
  start->setAmbient(GloxColor(30, 30, 30));
  start->setDiffuse(GloxColor(255, 0, 0));
  start->setPosition(GloxPoint<>(0, 0, 0));

  start->setEnabled(false);

  glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, 0.5);

  return true;
}