/*! --------------------------------------------------------------------

  \file   game.cpp

  \brief  Encapsulate a game

  \author James Kuffner
  \date   2002-09-17

// ------------------------------------------------------------------*/


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

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

#include "intro.h"
#include "texturemap.h"


//! default window title
const char* Intro::WINDOW_TITLE = "Chobits";

//! instance pointer for callbacks
Intro* Intro::s_pIntro = NULL;

//! snapshot default filename
const char* Intro::SNAPSHOT_FILENAME = "snapshot.jpg";

const char* Intro::INTROFILE = "data/intro/intro.txt";


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

/*
#define menux -0.57
#define menuy 0.099
#define menuxsize 0.5
#define menuysize 0.15
#define menuincrement 0.16

#define menux 50
#define menuy 150
#define menuxsize 40
#define menuysize 100
#define menuincrement 50*/

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

  mainWindow = -1;
  iWindowWidth = 0;
  iWindowHeight = 0;
  starttime=time(0);//glutGet wasnt working. if it was it would be =0;
  timeElapsed = 0;
  skipintro=false;
  introstate=1;
  menuitem=0;
  menureturned=false;

}

//---------------------------------------------------------------------
//                            Intro
//
//  Method:  Destructor
//
//---------------------------------------------------------------------
Intro::~Intro() 
{
  if (mainWindow > 0)
    glutDestroyWindow(mainWindow);
}

bool Intro::ReadIntro(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>>startmenuimage;
  
  is>>numintroframes;

  //menu stuff
  is>>menux;
  is>>menuy;
  is>>menuxsize;
  is>>menuysize;
  is>>menuincrement;

  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;
}

//---------------------------------------------------------------------
//                            Intro
//  Method:  Init
//
//! set up game and initialize data structures
//
//---------------------------------------------------------------------
bool Intro::Init(Game *gameptr)
{
  // parse level description file
  for (int x=0; x<MAX_FRAMES; x++) 
    introFilenames[x]=new char[512];

  startmenuimage=new char[256];

  if (!ReadIntro(INTROFILE)) {
    cerr << "Intro::Init() - ERROR loading intro description." << endl;
    return false;
  }
  
  // initalize game window
  bool bError = false;
  if (!InitWindow()) {
    cerr << "Intro: ERROR initializing window" << endl;
    bError = true;
  }
  
  s_pGame=gameptr;//tells us where to go after we finish. The class this points to will take control of execution



  LoadNewFrame(introFilenames[0]);
  /*
    char imagepath[1024];
    sprintf(imagepath, "./intro1.tif");
    TextureMap &tex = IntroTexture;

    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 bError=true;
  */



  return (!bError);
}


//---------------------------------------------------------------------
//                            Intro
//  Method:  Run
//
//! game main processing loop
//
//---------------------------------------------------------------------
void Intro::Run()
{
  glutMainLoop();
}






//---------------------------------------------------------------------
//                            Intro
//  Method:  _InitWindow
//
//! initialize main window
//
//---------------------------------------------------------------------
bool Intro::InitWindow()
{
  // set main window
  glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
  glutInitWindowSize(DEFAULT_WINDOW_WIDTH,DEFAULT_WINDOW_HEIGHT);
  mainWindow   = glutCreateWindow(WINDOW_TITLE);
  glClearColor(0, 0, 1, 0);

  glViewport(0,0,DEFAULT_WINDOW_WIDTH,DEFAULT_WINDOW_HEIGHT);
  gluPerspective(65,1,0.1,100);//fov, aspect,near,farclip

  // set up the primary callbacks
  glutReshapeFunc(ReshapeCB);
  glutDisplayFunc(DisplayCB);
  glutIdleFunc(IdleCB);

  // keyboard input callbacks
  glutKeyboardFunc(KeyDownCB);
  glutKeyboardUpFunc(KeyUpCB);
  glutSpecialFunc(SKeyDownCB);
  glutSpecialUpFunc(SKeyUpCB);
  glutIgnoreKeyRepeat(GL_TRUE);

  return true;
}




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

void Intro::Render()
{
  //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, IntroTexture.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();



  if ((skipintro)&&(!menureturned)) {
    //draw the selector over the menu
    //menuitem says which of the 4 menu items is selected now. 0 is single player
    
    glDisable(GL_TEXTURE_2D);
    glDepthMask(GL_FALSE);
    glDisable(GL_DEPTH_TEST);
    glDisable(GL_LIGHTING);
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
    glColor4ub(0x3C,0x90,0xEF,128);
    //glColor4f(0.2,0.2,.9,0.3);
    glBegin(GL_QUADS);
    glVertex2f(menux*((float)iWindowWidth/640.0),(menuy-menuitem*menuincrement)*((float)iWindowHeight/480.0));
    glVertex2f((menux+menuxsize)*((float)iWindowWidth/640.0),(menuy-menuitem*menuincrement)*((float)iWindowHeight/480.0));
    glVertex2f((menux+menuxsize)*((float)iWindowWidth/640.0),(menuy+menuysize-menuitem*menuincrement)*((float)iWindowHeight/480.0));
    glVertex2f(menux*((float)iWindowWidth/640.0),(menuy+menuysize-menuitem*menuincrement)*((float)iWindowHeight/480.0));
    glEnd();

  }




  glPopMatrix();


  glutSwapBuffers();
  glFlush();

  return;

  /*
  //regular


  glPushMatrix();
  glClearColor(0,0,0,1);
  glEnable(GL_TEXTURE_2D);
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();
  gluPerspective(65,1,0.1,100);//fov, aspect,near,farclip
  //gluPerspective(65,iWindowWidth/iWindowHeight,0.1,100);//fov, aspect,near,farclip
  //why does it break if the perspective call isnt made in here?
  glMatrixMode(GL_MODELVIEW);
  gluLookAt(0,0,1, 0,0,-1, 0,1,0);

  //glDisable(GL_DITHER);

  // geometric style
  //glTranslatef(-1,-1,0);
  glTranslatef(0,-0.255,0.83);
  glBindTexture(GL_TEXTURE_2D, IntroTexture.GetName());
  glColor4f(1,1,1,1);

  //glScalef(1,640/480,1);
  //glScalef(480.0/640.0,1,1);//was this
  glScalef((float)iWindowHeight/(float)iWindowWidth,1,1);
  glBegin(GL_QUADS);
  glTexCoord2i(0,1);
  glVertex3f(-1,1,-1);
  glTexCoord2i(1,1);
  glVertex3f(1,1,-1);
  glTexCoord2i(1,0);
  glVertex3f(1,-1,-1);
  glTexCoord2i(0,0);
  glVertex3f(-1,-1,-1);
  glEnd();

  if ((skipintro)&&(!menureturned)) {
    //draw the selector over the menu
    //menuitem says which of the 4 menu items is selected now. 0 is single player

    glBindTexture(GL_TEXTURE_2D,0);
    glDisable(GL_TEXTURE_2D);
    glDepthMask(GL_FALSE);
    glDisable(GL_DEPTH_TEST);
    glDisable(GL_LIGHTING);
    //glEnable(GL_DITHER);
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
    //glColor4ub(0x3C,0x90,0xEF,128);
    glColor4f(0.2,0.2,.9,0.3);
    glBegin(GL_QUADS);
    glVertex3f(menux,menuy-menuitem*menuincrement,-0.9);
    glVertex3f(menux+menuxsize,menuy-menuitem*menuincrement,-0.9);
    glVertex3f(menux+menuxsize,menuy+menuysize-menuitem*menuincrement,-0.9);
    glVertex3f(menux,menuy+menuysize-menuitem*menuincrement,-0.9);
    glEnd();

  }

  glPopMatrix();

  glutSwapBuffers();
  glFlush();

  */
}


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

void Intro::LoadNewFrame(char *imagepath) {
  //char imagepath[1024];
  //sprintf(imagepath, imagepath);
    TextureMap &tex = IntroTexture;

    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 image at introstate "<<introstate<<endl;
}



void Intro::UpdateState()
{
  // time elapsed since last call
  //int msec = glutGet(GLUT_ELAPSED_TIME);
  //timeElapsed = (msec * 0.001);
  //totaltime+=timeElapsed;
  totaltime=time(0)-starttime;//glutGet wasnt working
  //cout<<"totaltime to "<<totaltime<<endl;

  if ((totaltime<introendtime) && !skipintro) {
    if (totaltime>=introTimes[introstate]) {
      cout<<"next state"<<endl;
      LoadNewFrame(introFilenames[introstate]);
      introstate++;
    }

  } else {
    //if ((totaltime>30)||(skipintro)) {//intro is over
    //first do the startup screen-load that image, switch to startup screen input and rendering (add it to existing functions, enabled with an if skipintro)
    skipintro=true;
    if (introstate>=0) {
      LoadNewFrame(startmenuimage);
      introstate=-1;//if -1, we're at the startup menu
    }

    if (menureturned) {
      if (menuitem==3) exit(0);
      if (menuitem==2) {
        //do the options screen here
        menureturned=false;
      } else {
    //after the startup screen returns a mode:
    //(it has single and multi that return a mode, an options that run the options pause screen and then return to the startup screen, and exit that exit(0)

    //change the callbacks to the main game stuff
    //s_pGame->DisplayCB() is the new function, for example
    //keep redisplay until after level loading-just draw a loading screen for now
    //change input, reshape after determining level info
    //change idle to the class gameloop initializer
  // set up the primary callbacks
      //glutReshapeFunc(s_pGame->ReshapeCB);//change this along with display
      //LoadNewFrame("./loading.tif");//now Game will do this
      //glutDisplayFunc(s_pGame->DisplayCB);//disabled-switch it from Game->idleCB

        
        s_pGame->Init(mainWindow,iWindowWidth,iWindowHeight);//Init is called by Intro since intro knows how the window was set up. Intro is declared as a friend, so after the StartGame call only Game has access to the window data
      glutReshapeFunc(s_pGame->ReshapeCB);//change this along with display
        s_pGame->StartGame(menuitem,0);

        //glutIdleFunc(s_pGame->IdleCB);//this transfers control to Game
        //glutDisplayFunc(s_pGame->DisplayCB);
      //pass the parameters
      //s_pGame->gamemode=menuitem;

      // keyboard input callbacks
      /*
        glutKeyboardFunc(KeyDownCB);
        glutKeyboardUpFunc(KeyUpCB);
        glutSpecialFunc(SKeyDownCB);
        glutSpecialUpFunc(SKeyUpCB);
        glutIgnoreKeyRepeat(GL_TRUE);
      */
      }
    }
  }

  glutPostRedisplay();

}






//---------------------------------------------------------------------
//                            Intro
//  Method:  _ReshapeWindow
//
//! reshape the main window
//
//---------------------------------------------------------------------
void Intro::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;

  gluPerspective(65,1,0.1,100);//fov, aspect,near,farclip
 
  /*
  // 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 Intro::ProcessKeyDown(unsigned char key, int w, int h)
{
  switch (key) {
  case 27:
  case 'q':
    exit(0);
    break;

  case GLUT_KEY_UP:
  case 'w':
    if (skipintro) if (menuitem>0) menuitem--;
    break;
  case GLUT_KEY_DOWN:
  case 's':
    if (skipintro) if (menuitem<3) menuitem++;
    break;

  case ' ':
    cerr << "Saving screen snapshot to: " << SNAPSHOT_FILENAME << endl;
    CaptureImage(SNAPSHOT_FILENAME);
    break;

  case 13://return
    if (skipintro) {menureturned=true;
    cerr<<"Menu Selection Made"<<endl; }
    else skipintro=true;
    break;


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


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

  default:
    cerr << "Key UP: " << key <<"="<<(int)key<< endl;
  }
}


//---------------------------------------------------------------------
//                            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 Intro::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
}