#include "game.h"

#include <GL/glut.h>
#include <stdlib.h>
#include <iostream.h>
#include <fstream.h>
#include <string.h>
#include <math.h>
#include <time.h>

#if HAVE_PIC_LIB
#include "pic.h"
#endif

#include "texturemap.h"
#include "playerlocation.h"



//create the classes that do the stuff
#include "world.h"
World world;

//when adding more cameras remember the windowreshape function too
#include "camera.h"
Camera camera;

#include "input.h"
Input input;

//! instance pointer for callbacks
Game* Game::s_pGame = NULL;

//! helper function to read strings from a stream
inline bool READ_STRING(istream &is, char* pString)
{
  is >> pString;
  return is.good();
}


const char* Game::SNAPSHOT_FILENAME = "snapshot.jpg";



//---------------------------------------------------------------------
//                            Intro
//
//  Method:  Constructor
//
//---------------------------------------------------------------------
Game::Game() 
{
  // initialize instance pointer for callbacks
  s_pGame = this;

  mainWindow = -1;
  iWindowWidth = 0;
  iWindowHeight = 0;
  gamemode=0;
  for (int x=0; x<MAX_LEVELS; x++) {
    levelfilenames[x]=new char[512];
  }
  for (int x=0; x<MAX_FRAMES; x++) 
    slideFilenames[x]=new char[512];
  
  numslideframes=0;
  slideendtime=0;

  worldtype=0;
  inputtype=0;
  cameratype=0;
  numlevels=0;
  currentlevel=0;

  numplayers=1;

  numupdates=0;

}

//---------------------------------------------------------------------
//                            Intro
//
//  Method:  Destructor
//
//---------------------------------------------------------------------
Game::~Game() 
{
  if (mainWindow > 0)
    glutDestroyWindow(mainWindow);
}
/*
bool Game::ReadLevel(const char *introfilename) {
  cerr << "Reading intro description file "<<introfilename<<endl;
  
  ifstream is(introfilename);
  if (!is.good()) { cerr<<"Intro::ReadIntro: Error opening file"<<endl; return false; }
  
  is>>numintroframes;

  for (int x=0; x<numintroframes; x++) {
    is>>introTimes[x];
    if (!READ_STRING(is, introFilenames[x])) {
      cerr << "ERROR" << endl;
      return false;
    }
  }

  is>>introendtime;

  return true;
  }*/

bool Game::ReadGameFile() {
  cerr << "Reading game description file "<<gamefile<<endl;
  
  ifstream is(gamefile);
  if (!is.good()) { cerr<<"ReadGameFile: Error opening file"<<endl; 

exit(0); 

return false; }

  loadingfile=new char[256];
  if (!READ_STRING(is, loadingfile)) {
    cerr << "ERROR gamefile read" << endl;
  }

  is>>numlevels;

  for (int x=0; x<numlevels; x++) {
    cerr<<"reading"<<endl;
    if (!READ_STRING(is, levelfilenames[x])) {
      cerr << "ERROR gamefile read" << endl;
      return false;
    }
  }



  return true;
  }

//---------------------------------------------------------------------
//                            Intro
//  Method:  Init
//
//! set up game and initialize data structures
//
//---------------------------------------------------------------------
bool Game::Init(int mainWindowval, unsigned short w, unsigned short h) 
{
  mainWindow=mainWindowval;
  iWindowWidth=w;
  iWindowHeight=h;

  ReadGameFile();

  return (true);
}




//Start Game-causes a new level to be loaded
void Game::StartGame(int gamemodeparam, int whichlevel) {
  gamemode=gamemodeparam;
  currentlevel=whichlevel;


  if (currentlevel>=numlevels) {//if we beat the game
    //doending();
    cerr<<"Do the ending here!*****************"<<endl;
    cerr<<"StartGame called with end of game currentlevel"<<endl;
    exit(0);
  }



  //this transfers control to Game. it should only really be necessary when Intro calls StartGame
  glutIdleFunc(IdleCB);

  glutDisplayFunc(DisplayCB);

  glutKeyboardFunc(KeyDownCB);
  glutKeyboardUpFunc(KeyUpCB);
  glutSpecialFunc(SKeyDownCB);
  glutSpecialUpFunc(SKeyUpCB);


  LoadLoading(loadingfile);
  RenderLoading();//draw the loading screen


  //***********also read in the level file here
  //read in slide show data, and other stuff
  ifstream is(levelfilenames[currentlevel]);
  if (!is.good()) { cerr<<"Game::StartGame: Error opening file"<<endl; return; }


  int temp;//placeholder for file reading
  char *courseFile = new char[512];
  char *skyboxPath = new char[256];
  char *inputFile = new char[256];
  char *npcFile = new char[256];
  char *eventFile = new char[256];
  char *minimapfile = new char[256];
  char *minimapmaskfile = new char[256];
  char *chatback = new char[256];
  char *chatborder = new char[256];
  int wgoaltype; float wgoalx; float wgoaly; float wgoaldistance;

  is>>inputFile;
  is>>skyboxPath;
  is>>courseFile;
  is>>npcFile;
  is>>eventFile;
  is>>minimapfile;
  is>>minimapmaskfile;
  is>>chatback;
  is>>chatborder;
  is>>worldtype;  cout<<"t1:"<<temp<<endl;
  is>>inputtype;  cout<<"t2:"<<temp<<endl;
  is>>cameratype; cout<<"t2:"<<temp<<endl;
  is>>wgoaltype>>wgoalx>>wgoaly>>wgoaldistance;
  is>>numslideframes;
  for (int r=0; r<numslideframes; r++) {
    is>>slideTimes[r];
    is>>slideFilenames[r];
  }
  is>>slideendtime;

  cout<<"initing the world"<<endl;

  world.Init(gamemode, skyboxPath, courseFile, npcFile, eventFile);
  world.SetGoal(wgoaltype,wgoalx,wgoaly,wgoaldistance);

  cout<<"initing chats from files: "<<chatback<<", and "<<chatborder<<endl;
  if (!world.chats.Init(chatback, chatborder)) {
    cerr<<"from Game, World:: ERROR initializing conversation"<<endl;
  }

  cout<<"numslideframes "<<numslideframes<<" slideendtime "<<slideendtime<<endl;


  //****************read in these filenames from the level file
  if (!theminimap.Init(minimapfile,minimapmaskfile)) {
    cerr<<"Game:: ERROR initializing minimap"<<endl;
  }

  //***********now use the level file data to read in all the other data and set everything up.


  //do the slide show here by loading new textures and rendering
  slidestarttime=time(0);
  int x=0;
  int loaded=0;
  while ((x<numslideframes)&&(time(0)-slidestarttime<slideendtime)) {
    if (loaded==0) {
      cout<<"load a slide"<<endl;
      LoadLoading(slideFilenames[x]);
      RenderLoading();
      loaded=1;
    }
    if (x==numslideframes-1) {
      if (time(0)-slidestarttime>=slideendtime) x++;
    }
    else if (time(0)-slidestarttime>=slideTimes[x+1]) {
      x++;
      loaded=0;
    }
    //cerr<<"whiled with x="<<x<<" and time "<<time(0)-slidestarttime<<" end "<<slideendtime<<endl;
  }

  cerr<<"going to init the level"<<endl;
  //**********initialize the levels



  input.Init(inputFile);
  input.s_pWorld=&world;

  camera.Init(iWindowWidth,iWindowHeight);

  if (gamemodeparam==1) numplayers=2;//else default 1
}




//---------------------------------------------------------------------
//                            Intro
//  Method:  _Render
//
//! render world contents to window
//
//---------------------------------------------------------------------

void Game::Render()
{


  if (firstupdate+numupdates*updatelag<glutGet(GLUT_ELAPSED_TIME)) {
    //cerr<<"frame drop"<<endl;
    return;
    //there haven't been enough updates, so drop a frame
  }
  /*uncomment this to cause frame drops
  for (int x=0; x<500000; x++) {
    for (int y=0; y<1000; y++) {}
}
  */

  float mapp1x,mapp1y,mapp2x,mapp2y;
  int coursesize=world.GetCourseSize();

  glClearColor(0,0,0,1);
  glDepthMask(GL_TRUE);
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

  PlayerState playerloc;
  for(int player = 0; player<numplayers; player++){
    //viewport stuff
    if (numplayers==1) {
      glViewport(0,0,iWindowWidth,iWindowHeight);
      camera.SetAspectRatio((float)iWindowWidth/(float)iWindowHeight);

    } else if (numplayers==2) {
      if (player==0)
        glViewport(0,iWindowHeight/2,iWindowWidth,iWindowHeight/2);
      else 
        glViewport(0,0,iWindowWidth,iWindowHeight/2);
      camera.SetAspectRatio((float)iWindowWidth*2/(float)iWindowHeight);

    } else {
      //split it up formulaicly. have an arbitrary number of players. muahaha
      int splits=2;
      while (splits*splits<numplayers) splits++;
      //now we have a square of ports
      int row=player/splits;
      int col=(player+(splits-1))%splits;
      glViewport((iWindowWidth/splits)*col,(iWindowHeight/splits)*row,
                 (iWindowWidth/splits),(iWindowHeight/splits));
      camera.SetAspectRatio((float)iWindowWidth/(float)iWindowHeight);
    }
    
    //set map locations for the minimap
    glPushMatrix();
    playerloc=world.GetPlayer(player);   
    if (player==0) {
      mapp1x=playerloc.loc.x;
      mapp1y=playerloc.loc.y;
    } else if (player==1) {
      mapp2x=playerloc.loc.x;
      mapp2y=playerloc.loc.y;
    }

    //draw the stuff
    if (world.eventer.incutscene(player)==false) {
      camera.SetView(playerloc, &(world.cameras[player]));
      world.Render(numplayers, player);
      world.chats.DrawConversation(player,numplayers,iWindowWidth,iWindowHeight);
      world.eventer.drawmessages(player,numplayers,iWindowWidth,iWindowHeight);
    } else {
      world.eventer.continuecut(player, iWindowWidth, iWindowHeight);
    }
    glPopMatrix();
  }//end for player

  camera.SetAspectRatio((float)iWindowWidth/(float)iWindowHeight);
  //gluPerspective(60,1,0.1,1000);
  if ((world.eventer.incutscene(0)==false)&&(world.eventer.incutscene(1)==false)) {
  theminimap.DrawMap(iWindowWidth,iWindowHeight,
                     mapp1x/coursesize,mapp1y/coursesize,
                     mapp2x/coursesize,mapp2y/coursesize, numplayers);
  }

  glutSwapBuffers();
  glFlush();

  lastframe=glutGet(GLUT_ELAPSED_TIME);
}

void Game::RenderLoading() {
  //ortho technique
  glDisable(GL_DEPTH_TEST);
  glPushMatrix();
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();
  glOrtho(0,iWindowWidth,0,iWindowHeight,0,100);

  glEnable(GL_TEXTURE_2D);
  glBindTexture(GL_TEXTURE_2D, LoadingTexture.GetName());
  glColor4f(1,1,1,1);

  
  glBegin(GL_QUADS);
  glTexCoord2i(0,1);
  glVertex2f(0,iWindowHeight);
  glTexCoord2i(1,1);
  glVertex2f(iWindowWidth,iWindowHeight);
  glTexCoord2i(1,0);
  glVertex2f(iWindowWidth,-1*(iWindowHeight*(640.0/480.0)-iWindowHeight));
  glTexCoord2i(0,0);
  glVertex2f(0,-1*(iWindowHeight*(640.0/480.0)-iWindowHeight));
  glEnd();
  glPopMatrix();

  glutSwapBuffers();
  glFlush();

  
}


//---------------------------------------------------------------------
//                            Intro
//  Method:  _UpdateState
//
//! update game state for single game loop iteration
//
//---------------------------------------------------------------------

void Game::LoadLoading(char *imagepath) {
  //char imagepath[1024];
  //sprintf(imagepath, "./loading.tif");
    TextureMap &tex = LoadingTexture;

    if (tex.LoadTIFF(imagepath)) {
      // set up params and bind name
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
      tex.InitTextureParams(false);
    } else cerr<<"Error loading the loading screen"<<endl;
}



void Game::UpdateState()
{

  if (numupdates==0)  {
    firstupdate=glutGet(GLUT_ELAPSED_TIME);
    world.eventer.manualmessage(0,4000,"O.K.! Let's Go!");
    world.eventer.manualmessage(1,4000,"O.K.! Let's Go!");
  }
/*
  if (numupdates%30==5) {//DEBUG PRINTOUT
    cout<<"player 1 hp/glow: "<<world.players[0].hp<<","<<world.players[0].glowing<<endl;
    cout<<"player 2 hp/glow: "<<world.players[1].hp<<","<<world.players[1].glowing<<endl;
  }
*/

  //cout<<"update state: numupdates "<<numupdates<<" first at "<<firstupdate<<", game time "<<firstupdate+numupdates*updatelag<<" real time "<<glutGet(GLUT_ELAPSED_TIME)<<endl;
  if (firstupdate+numupdates*updatelag<=glutGet(GLUT_ELAPSED_TIME)) {
    //we need to do another update
    numupdates++;

  //running in game now
  //switch on leveltype, call update functions for specific types
  //actually, StartGame should set the idle to the real one before we get here
  input.Repeats();

  world.UpdateState();

  if (world.Finished(numplayers)) {
    StartGame(gamemode,currentlevel+1);
  }

  lastupdate=glutGet(GLUT_ELAPSED_TIME);
  }
  else {
    //cout<<"else"<<endl;cout<<"update state: numupdates "<<numupdates<<" first at "<<firstupdate<<", game time "<<firstupdate+numupdates*updatelag<<" real time "<<glutGet(GLUT_ELAPSED_TIME)<<endl;
  }
    glutPostRedisplay();

}






//---------------------------------------------------------------------
//                            Intro
//  Method:  _ReshapeWindow
//
//! reshape the main window
//
//---------------------------------------------------------------------
void Game::ReshapeWindow(int w, int h)
{
  
  if (w <= MIN_WINDOW_SIZE || h <= MIN_WINDOW_SIZE) {
    cerr << "Intro::Reshape - bad window size: " << w << ", " << h << endl;
    return;
  }

  // reset window size
  glutSetWindow(mainWindow);
  glViewport(0,0,w,h);
  iWindowWidth = w;
  iWindowHeight = h;
  //    camera.WindowWidth=w;
  //camera.WindowHeight=h;

  gluPerspective(65,1,0.1,100);//fov, aspect,near,farclip-1 for loading screens, regular rendering will update perspective
 
  /*
  // aspect ratio for each horizontal split-screen window
  //_iHalfHeight = h/2;
  float aspect = ((GLfloat)w / (GLfloat)_iHalfHeight);
  _cameraTop.SetAspectRatio(aspect);
  _cameraBot.SetAspectRatio(aspect);
  */
}


//---------------------------------------------------------------------
//                            Intro
//  Method:  _ProcessKeyDown
//
//! process keyboard down events
//
//---------------------------------------------------------------------
void Game::ProcessKeyDown(unsigned char key, int w, int h)
{

  //catch screenshots and quits here, pass everything else to the appropriate input class.
  switch (key) {
  case 27:  //esc
    exit(0);
    break;
    //case 13://return
  case ' ':
    cerr << "Saving screen snapshot to: " << SNAPSHOT_FILENAME << endl;
    CaptureImage(SNAPSHOT_FILENAME);
    break;

  default:
    // store which key is pressed
    //cerr << "Key DOWN: " << key <<"="<<(int)key<< endl;
    //_bKeyPressed[(int)key] = true;

    input.KeyDown(key,w,h);


  }
}


//---------------------------------------------------------------------
//                            Intro
//  Method:  _ProcessKeyUp
//
//! process keyboard up events
//
//---------------------------------------------------------------------
void Game::ProcessKeyUp(unsigned char key, int w, int h)
{
  switch (key) {

  default:
    //cerr << "Key UP: " << key <<"="<<(int)key<< endl;
    input.KeyUp(key,w,h);
  }
}

void Game::ProcessSKeyDown(int key, int w, int h) {
 switch (key) {
 case 104: //PageUp
    numplayers++;
    world.course.SetStartLocation(&(world.players[numplayers-1]),numplayers-1, true);
    cout<<"Now there are "<<numplayers<<endl;
    break;
 case 105: //PageDown
    if (numplayers>1)
      numplayers--;
    if ((world.players[numplayers].loc.x>0)&&(world.players[numplayers].loc.x<world.course.coursewidth))
      if ((world.players[numplayers].loc.y>0)&&(world.players[numplayers].loc.y<world.course.courseheight))
        world.course.RemoveDynamicObject((int)world.players[numplayers].loc.x,(int)world.players[numplayers].loc.y);
    cout<<"Now there are only "<<numplayers<<endl;
    break;
  default:
    cerr << "SKey Down: " << key <<"="<<key<< endl;

    input.SKeyDown(key,w,h);
  }
}

void Game::ProcessSKeyUp(int key, int w, int h) {
 switch (key) {

  default:
    cerr << "SKey UP: " << key <<"="<<key<< endl;

    input.SKeyUp(key,w,h);
  }
}
//---------------------------------------------------------------------
//                            Intro
//  Method:  _CaptureImage
//
// !takes a snapshot of the current window and saves it into
// filename in jpg format. returns true if saved successfully,
// false otherwise.
//
// NOTE: when saving image files, try to use a local path,
//   such as /usr/tmp instead of your andrew space, for better speed.
//---------------------------------------------------------------------
bool Game::CaptureImage(const char *filename)
{
#if HAVE_PIC_LIB
  if (filename == NULL) {
    cerr << "Intro::_CaptureImage : Tried to save into NULL filename\n";
    return false;
  }

  // allocate a buffer
  Pic *in = pic_alloc(iWindowWidth, iWindowHeight, 3, NULL);

  // read the framebuffer data
  for (int i = iWindowHeight; i >= 0; i--) {
    glReadPixels(0, iWindowHeight-1-i, iWindowWidth,
        1, GL_RGB, GL_UNSIGNED_BYTE, &in->pix[i*in->nx*in->bpp]);
  }

  // write the result
  bool bResult = jpeg_write((char *)filename, in);
  pic_free(in);

  if (!bResult)
    cerr << "Intro::_CaptureImage : Error writing image " << filename << endl;

  return bResult;

#else
  cerr << "Intro::_CaptureImage() needs 'libpicio'" << endl;
  return false;

#endif // HAVE_PIC_LIB
}