#include <GL/glut.h>

#include <time.h>
#include <string>
#include <iostream>

#include "C_MatchBloxEngine.h"

#include "C_3DObject.h"
#include "C_Environment.h"
#include "C_Hand.h"
#include "C_Block.h"
#include "C_Box.h"
#include "C_Log.h"
#include "bitmap.h"

C_MatchBloxEngine::C_MatchBloxEngine(const char *f_strModelPath,
                                     const char *f_strLogFile)
{
  //create logger
  
  
  //Load models
  if (LoadModels(f_strModelPath))
  {
    //set state to initialised;
    m_State = ES_INITIALISED;
  }
  else
  {
    m_State = ES_ERROR;
  }

  //initialise a random seed
  srand ( time(NULL) );

  //init vars
  m_CurrentBox = BS_SMALL;

  //debug
  m_pBox[0]->SetPos(0.0, -5.0, -15.0);
  m_pBox[0]->SetRot(45.0, 0.0, 0.0);
  m_pBox[0]->RandomizeTiles();

  m_pBlock[0]->SetPos(-6.0, 1.0, -10.0);
  m_pBlock[0]->SetRot(90.0, 0.0, 0.0);
  m_pBlock[1]->SetPos(-2.0, 1.0, -10.0);
  m_pBlock[1]->SetRot(90.0, 0.0, 0.0);
  m_pBlock[2]->SetPos(2.0, 1.0, -10.0);
  m_pBlock[2]->SetRot(90.0, 0.0, 0.0);
  m_pBlock[3]->SetPos(6.0, 1.0, -10.0);
  m_pBlock[3]->SetRot(90.0, 0.0, 0.0);
}

C_MatchBloxEngine::~C_MatchBloxEngine()
{
  //destroy logger
  
  //delete models
  DeleteModels();
}

GameResult C_MatchBloxEngine::GameStep(void)
{
  //process message queue
  return GR_ERROR;
}

void C_MatchBloxEngine::Render_Basics(unsigned int f_uiElapsedTime)
{
  //render the environment
  m_pEnvMap->Render();

  m_pBox[(intptr_t)m_CurrentBox]->Render();
  for (int i=0; i<4; i++)
    m_pBlock[i]->Render(f_uiElapsedTime);
//  m_pHand->Render(f_uiElapsedTime);
}

void C_MatchBloxEngine::Render(unsigned int f_uiElapsedTime)
{
  switch (m_State)
  {
  case ES_INITIALISED:
    Render_Basics(f_uiElapsedTime);
  break;

  case ES_ERROR:
    //render a red cube
    glPushMatrix();
    glPushAttrib(GL_ENABLE_BIT);
    glDisable(GL_LIGHTING);
    glColor3d(1.0, 0.0, 0.0);
    glTranslated(0.0, 0.0, -5.0);
    glutSolidCube(5.0);
    glPopAttrib();
    glPopMatrix();
  break;

  case ES_GET_READY:
    Render_Basics(f_uiElapsedTime);
    //render some GET READY text
  break;

  case ES_PLAYING_GRAB_BLOCK:
    Render_Basics(f_uiElapsedTime);
  break;

  case ES_PLAYING_PUT_BLOCK:
    Render_Basics(f_uiElapsedTime);
  break;

  case ES_PAUSED:
    Render_Basics(f_uiElapsedTime);
    //render menu??
  break;

  case ES_FINISHED:
    //render results...
  break;
  }

  //glPushMatrix();

  //double l_dSeconds = (double)f_uiElapsedTime/1000.0;

  //glRotated(l_dSeconds * 5.0, 0.0, 1.0, 0.0);
  ////glRotated(l_dSeconds * 10, 0.0, 0.0, 1.0);

  //m_pEnvMap->Render();

  //glPopMatrix();

  //m_pBox[0]->Render();

  //for(int i=0; i<4; i++)
  //{
  //   glPushMatrix();
  //   m_pBlock[i]->Render(f_uiElapsedTime);
  //   glPopMatrix();
  //}

}

bool C_MatchBloxEngine::NewGame(int f_iUserID, int f_iGameId, BoxSize f_BS)
{
  if(m_State == ES_INITIALISED)
  {
    //log new game

    //prepare a fresh box
    m_CurrentBox = f_BS;
    m_pBox[(int)m_CurrentBox]->RandomizeTiles();

    //set state to GET READY
    m_State = ES_GET_READY; 
  
    //init object positions
    m_pBox[(int)m_CurrentBox]->SetPos(0.0, -6.0, -15.0);
    return true;
  }

  return false;
}

bool C_MatchBloxEngine::StartGame()
{
  return false;
}

bool C_MatchBloxEngine::Pause()
{
  //only pause when playing
  if (m_State == ES_PLAYING_GRAB_BLOCK ||
      m_State == ES_PLAYING_PUT_BLOCK)
  {
    //save current state
    m_SavedState = m_State;

    //probably do something with a time variable

    //set current state to paused
    m_State = ES_PAUSED;

    return true;    
  }

  return false;
}

bool C_MatchBloxEngine::Resume()
{
  if (m_State == ES_PAUSED)
  {
    //restore previous state
    m_State = m_SavedState;

    //restore timers
    //

    return true;
  }
  return false;
}

bool C_MatchBloxEngine::Abort()
{
  //abort when not in error or init state
  if (m_State != ES_ERROR && m_State != ES_INITIALISED)
  {
    //set state to initialised
    m_State = ES_INITIALISED;

    //..

    return true;
  }
  return false;
}

bool C_MatchBloxEngine::LoadModels(const char* f_strModelDir)
{
  MatProps_t   l_Mat;
  std::string l_BaseName = f_strModelDir;

  //create the environment mapped cube
  m_pEnvMap = new C_Environment("envmaps/terrain_", 50.0);

  //load the bitmaps for the textures
  LoadTexture((l_BaseName + "/wood1.bmp").c_str(), m_uiWood1Tex);
  LoadTexture((l_BaseName + "/wood2.bmp").c_str(), m_uiWood2Tex);
  LoadTexture((l_BaseName + "/wood3.bmp").c_str(), m_uiWood3Tex);

  //load the block models
  //red squares
  l_Mat.setAmb(1.0, 0.0, 0.0, 1.0);
  l_Mat.setDif(1.0, 0.0, 0.0, 1.0);
  m_pBlock[BT_SQUARE] = new C_Block((l_BaseName + "/square.obj").c_str(),
                                    m_uiWood1Tex, l_Mat);
  if (!m_pBlock[BT_SQUARE]->Initialized()) return false;

  //yellow cricles
  l_Mat.setAmb(0.0, 1.0, 1.0, 1.0);
  l_Mat.setDif(0.0, 1.0, 1.0, 1.0);
  m_pBlock[BT_CIRCLE] = new C_Block((l_BaseName + "/circle.obj").c_str(),
                                    m_uiWood1Tex, l_Mat);
  if (!m_pBlock[BT_CIRCLE]->Initialized()) return false;

  //green triangles
  l_Mat.setAmb(0.0, 1.0, 0.0, 1.0);
  l_Mat.setDif(0.0, 1.0, 0.0, 1.0);
  m_pBlock[BT_TRIANGLE] = new C_Block((l_BaseName + "/triangle.obj").c_str(),
                                    m_uiWood1Tex, l_Mat);
  if (!m_pBlock[BT_TRIANGLE]->Initialized()) return false;

  //blue crosses
  l_Mat.setAmb(0.0, 0.0, 1.0, 1.0);
  l_Mat.setDif(0.0, 0.0, 1.0, 1.0);
  m_pBlock[BT_CROSS] = new C_Block((l_BaseName + "/cross.obj").c_str(),
                                    m_uiWood1Tex, l_Mat);
  if (!m_pBlock[BT_CROSS]->Initialized()) return false;

  
  //load the hand???
  
  
  //Load the box tiles
  l_Mat.setAmb(1.0, 1.0, 1.0, 1.0);
  l_Mat.setDif(1.0, 1.0, 1.0, 1.0);
  
  m_pTiles[BT_SQUARE]   = new C_3DObject((l_BaseName + "/tile_square.obj").c_str(),
                                         m_uiWood3Tex, l_Mat);
  if (!m_pTiles[BT_SQUARE]->Initialized()) return false;

  m_pTiles[BT_CIRCLE]   = new C_3DObject((l_BaseName + "/tile_circle.obj").c_str(),
                                         m_uiWood3Tex, l_Mat);
  if (!m_pTiles[BT_CIRCLE]->Initialized()) return false;

  m_pTiles[BT_TRIANGLE] = new C_3DObject((l_BaseName + "/tile_triangle.obj").c_str(),
                                         m_uiWood3Tex, l_Mat);
  if (!m_pTiles[BT_TRIANGLE]->Initialized()) return false;

  m_pTiles[BT_CROSS]   = new C_3DObject((l_BaseName + "/tile_cross.obj").c_str(),
                                         m_uiWood3Tex, l_Mat);
  if (!m_pTiles[BT_CROSS]->Initialized()) return false;

  m_pTiles[4]          = new C_3DObject((l_BaseName + "/tile_no_hole.obj").c_str(),
                                         m_uiWood3Tex, l_Mat);
  if (!m_pTiles[4]->Initialized()) return false;

  
  //Load the box models
  m_pBox[0] = new C_Box((l_BaseName + "/box_small.obj").c_str(),
                        m_uiWood2Tex, l_Mat, 2, 2, m_pTiles);
  if (!m_pBox[0]->Initialized()) return false;

  m_pBox[1] = new C_Box((l_BaseName + "/box_med.obj").c_str(),
                        m_uiWood2Tex, l_Mat, 4, 2, m_pTiles);
  if (!m_pBox[1]->Initialized()) return false;

  m_pBox[2] = new C_Box((l_BaseName + "/box_large.obj").c_str(),
                        m_uiWood2Tex, l_Mat, 4, 4, m_pTiles);
  if (!m_pBox[2]->Initialized()) return false;

  
  return true;
}

void C_MatchBloxEngine::DeleteModels()
{
  //delete objects
  delete m_pEnvMap;
  delete m_pBlock[0];
  delete m_pBlock[1];
  delete m_pBlock[2];
  delete m_pBlock[3];
  //delete m_pHand; 
  delete m_pBox[0];
  delete m_pBox[1];
  delete m_pBox[2];
  delete m_pTiles[0];
  delete m_pTiles[1];
  delete m_pTiles[2];
  delete m_pTiles[3];
  delete m_pTiles[4];

  //delete textures
  glDeleteTextures(1, &m_uiWood1Tex);
  glDeleteTextures(1, &m_uiWood2Tex);
  glDeleteTextures(1, &m_uiWood3Tex);
}

void C_MatchBloxEngine::LoadTexture(const char* f_BmpName, GLuint &f_uiTexHandle)
{
  BitmapStruct l_Bmp;

  l_Bmp = BitmapLoad((char*)f_BmpName);
  f_uiTexHandle = (GLuint)l_Bmp.m_iImageId;
  
  glBindTexture(GL_TEXTURE_2D, f_uiTexHandle);

  //set the texture paramaters
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
}