/* input.c
 *
 * Receives input from the user.
 *
 * (c) 2006, Joseph Curtis
 */

#include "input.h"
#include "display.h"
#include "world.h"
#include "player.h"
#include "main.h"

#ifndef x86
#include <pspdebug.h>
#include <psputils.h>
//#define printf pspDebugScreenPrintf
#else
#include <time.h>
#endif

extern struct display *default_display;
extern struct world *default_world;

int input_loop() {
  int i;
#ifndef x86
  struct timeval tp;
  int start_time;
#endif

  printf("input_loop: ");

#ifndef x86
  SceCtrlData pad;

  /*
  update(default_display, default_world);
  sceKernelLibcGettimeofday(&tp, 0);
  start_time = tp.tv_usec;
  */

  while (1) {

    sceKernelLibcGettimeofday(&tp, 0);
    //    printf("Time is: %d (%d)\n", tp.tv_usec, start_time);
    /*
    if(tp.tv_usec - start_time > 1000) {
      update(default_display, default_world);
      start_time = tp.tv_usec;
    }
    */
    sceCtrlReadBufferPositive(&pad, 1);
    if (pad.Buttons & PSP_CTRL_LEFT) {
      ctrl_left();
      update(default_display, default_world);
    } else if (pad.Buttons & PSP_CTRL_RIGHT) {
      ctrl_right();
      update(default_display, default_world);
    } else if (pad.Buttons & PSP_CTRL_UP) {
      ctrl_up();
      update(default_display, default_world);
    } else if (pad.Buttons & PSP_CTRL_DOWN) {
      ctrl_down();
      update(default_display, default_world);
    } else if (pad.Buttons & PSP_CTRL_LTRIGGER) {
      ctrl_ltrigger();
      update(default_display, default_world);
    } else if (pad.Buttons & PSP_CTRL_RTRIGGER) {
      ctrl_rtrigger();
      update(default_display, default_world);
    } else if (pad.Buttons & PSP_CTRL_CROSS) {
      ctrl_cross();
      update(default_display, default_world);
    } else if (pad.Buttons & PSP_CTRL_CIRCLE) {
      ctrl_circle();
      update(default_display, default_world);
    } else if (pad.Buttons & PSP_CTRL_TRIANGLE) {
      ctrl_triangle();
      update(default_display, default_world);
    } else if (pad.Buttons & PSP_CTRL_SQUARE) {
      ctrl_square();
      update(default_display, default_world);
    } else if (pad.Buttons & PSP_CTRL_START) {
      ctrl_start();
      update(default_display, default_world);
    } else if (pad.Buttons & PSP_CTRL_SELECT) {
      ctrl_select();
      update(default_display, default_world);
    } else if ((pad.Lx < 96 || pad.Lx > 160) || (pad.Ly < 96 || pad.Ly > 160)) {
      /* Analogue stick, converted to signed char */
      ctrl_analogue((pad.Lx - 128), (pad.Ly - 128));
      update(default_display, default_world);
    }

    if (pad.Buttons)
      for (i=0;i<15;i++)
	sceDisplayWaitVblankStart();

  }
#endif

  update(default_display, default_world);

}

#ifdef x86
int sdl_input_loop() {
  SDL_Event event;
  char quit = 0;
  int x=-1, y=-1; /* prev mouse position */

  //  update(default_display, default_world);

  while(!quit) {
    if(SDL_PollEvent(&event)) {
      if(event.type == SDL_KEYDOWN) {
	switch(event.key.keysym.sym) {
	case PSP_CTRL_LEFT:
	  ctrl_left();
	  update(default_display, default_world);
	  break;
	case PSP_CTRL_RIGHT:
	  ctrl_right();
	  update(default_display, default_world);
	  break;
	case PSP_CTRL_UP:
	  ctrl_up();
	  update(default_display, default_world);
	  break;
	case PSP_CTRL_DOWN:
	  ctrl_down();
	  update(default_display, default_world);
	  break;
	case PSP_CTRL_LTRIGGER:
	  ctrl_ltrigger();
	  update(default_display, default_world);
	  break;
	case PSP_CTRL_RTRIGGER:
	  ctrl_rtrigger();
	  update(default_display, default_world);
	case SDLK_a:
	  x = -1*(CELL_WIDTH); y = 0;
	  
	  ctrl_analogue(x, y);
	  update(default_display, default_world);
	  break;
	case SDLK_d:
	  x = (CELL_WIDTH); y = 0;
	  ctrl_analogue(x, y);
	  update(default_display, default_world);
	  break;
	case SDLK_s:
	  x = 0; y = (CELL_HEIGHT);
	  ctrl_analogue(x, y);
	  update(default_display, default_world);
	  break;
	case SDLK_w:
	  x = 0; y = -1*(CELL_HEIGHT);
	  ctrl_analogue(x, y);
	  update(default_display, default_world);
	  break;
	case SDLK_ESCAPE:
	  shutdown();
	case PSP_CTRL_CROSS:
	  ctrl_cross();
	  update(default_display, default_world);
	  break;
	case PSP_CTRL_CIRCLE:
	  ctrl_circle();
	  update(default_display, default_world);
	  break;
	case PSP_CTRL_TRIANGLE:
	  ctrl_triangle();
	  update(default_display, default_world);
	  break;
	case PSP_CTRL_SQUARE:
	  ctrl_square();
	  update(default_display, default_world);
	  break;
	case PSP_CTRL_START:
	  ctrl_start();
	  update(default_display, default_world);
	  break;
	case PSP_CTRL_SELECT:
	  ctrl_select();
	  update(default_display, default_world);
	  break;
	default:
	  break;
	}
      } else if (event.type == SDL_MOUSEBUTTONDOWN) {
	if(x<0 && y<0) {
	  x = event.button.x;
	  y = event.button.y;
	} else {
	  ctrl_analogue(x, y);
	  x = event.button.x;
	  y = event.button.y;
	  update(default_display, default_world);
	}
      } else if (event.type == SDL_QUIT) {
	shutdown();
      }
    }
    SDL_Delay(10);
    //    update(default_display, default_world);
    //    printf("looped!\n");
  }
}
#endif

void ctrl_left() {
  switch (default_display->current_view) {
  case VIEW_MENU:
    break;
  case VIEW_MAP:
    break;
  case VIEW_MAIN:
    if(default_world->armies[0].a[0].x > 0)
      default_world->armies[0].a[0].x--;
    break;
  case VIEW_PLAYERS:
    if (default_world->players[7].type < NUM_TYPES - 1)
      default_world->players[7].type++;
    else
      default_world->players[7].type = 0;
    break;
    break;
  }
}

void ctrl_right() {
  switch (default_display->current_view) {
  case VIEW_MENU:
    break;
  case VIEW_MAP:
    break;
  case VIEW_MAIN:
    if (default_world->armies[0].a[0].x < (default_world->width - 1))
      default_world->armies[0].a[0].x++;
    break;
  case VIEW_PLAYERS:
    if (default_world->players[5].type < NUM_TYPES - 1)
      default_world->players[5].type++;
    else
      default_world->players[5].type = 0;
    break;
    break;
  }
}

void ctrl_up() {
  switch (default_display->current_view) {
  case VIEW_MENU:
    break;
  case VIEW_MAP:
    break;
  case VIEW_MAIN:
    if(default_world->armies[0].a[0].y > 0)
      default_world->armies[0].a[0].y--;
    break;
  case VIEW_PLAYERS:
    if (default_world->players[6].type < NUM_TYPES - 1)
      default_world->players[6].type++;
    else
      default_world->players[6].type = 0;
    break;
    break;
  }
}

void ctrl_down() {
  switch (default_display->current_view) {
  case VIEW_MENU:
    break;
  case VIEW_MAP:
    break;
  case VIEW_MAIN:
    if (default_world->armies[0].a[0].y < (default_world->height - 1))
      default_world->armies[0].a[0].y++;
    break;
  case VIEW_PLAYERS:
    if (default_world->players[4].type < NUM_TYPES - 1)
      default_world->players[4].type++;
    else
      default_world->players[4].type = 0;
    break;
  }
}

void ctrl_ltrigger() {
  switch (default_display->current_view) {
  case VIEW_MENU:
    break;
  case VIEW_MAP:
    //    default_display->current_view = VIEW_MAIN;
    break;
  case VIEW_MAIN:
    /* select previous army */
    select_prev_army(default_world);
  break;
  }
}

void ctrl_rtrigger() {
  switch (default_display->current_view) {
  case VIEW_MENU:
    break;
  case VIEW_MAP:
    break;
  case VIEW_MAIN:
    /* select next army */
    select_next_army(default_world);
    break;
  }
}

void ctrl_cross() {
  struct world *w = default_world;

  switch (default_display->current_view) {
  case VIEW_MENU:
    /* new game */
    default_display->current_view = VIEW_PLAYERS;
    break;
  case VIEW_MAP:
    break;
  case VIEW_MAIN:
    break;
  case VIEW_PLAYERS:
    /* scroll player 0 */
    if (default_world->players[0].type < NUM_TYPES - 1)
      default_world->players[0].type++;
    else
      default_world->players[0].type = 0;
    break;
  }
}

void ctrl_circle() {
  switch (default_display->current_view) {
  case VIEW_MENU:
    /* Load game */
    break;
  case VIEW_MAP:
    break;
  case VIEW_MAIN:
    break;
  case VIEW_PLAYERS:
    /* scroll player 0 */
    if (default_world->players[1].type < NUM_TYPES - 1)
      default_world->players[1].type++;
    else
      default_world->players[1].type = 0;
    break;
  }
}

void ctrl_triangle() {
  switch (default_display->current_view) {
  case VIEW_MENU:
    break;
  case VIEW_MAP:
    break;
  case VIEW_MAIN:
    break;
  case VIEW_PLAYERS:
    /* scroll player 0 */
    if (default_world->players[2].type < NUM_TYPES - 1)
      default_world->players[2].type++;
    else
      default_world->players[2].type = 0;    
    break;
  }
}

void ctrl_square() {
  switch (default_display->current_view) {
  case VIEW_MENU:
    break;
  case VIEW_MAP:
    break;
  case VIEW_MAIN:
    break;
  case VIEW_PLAYERS:
    /* scroll player 0 */
    if (default_world->players[3].type < NUM_TYPES - 1)
      default_world->players[3].type++;
    else
      default_world->players[3].type = 0;    
    break;
  }
}

void ctrl_start() {
  switch(default_display->current_view) {
  case VIEW_PLAYERS:
    /* START THE GAME!!! */
    default_display->current_view = VIEW_MAIN;
    default_world->turn=-1;
    start_turn(default_world, default_display);
    break;
  case VIEW_MAIN:
    production(default_world, default_display);
  default:
    break;
  }
}

void ctrl_select() {
  switch(default_display->current_view) {
  case VIEW_MAIN:
    start_turn(default_world, default_display);
    break;
  default:
    break;
  }
}

void ctrl_analogue(int x, int y) {
  struct world *w = default_world;
  
  switch (default_display->current_view) {
  case VIEW_MENU:

    break;

  case VIEW_MAIN:

    VISX_MOD(w->vis_x, (x / 12));

    VISY_MOD(w->vis_y, (y / 12));

    break;

  case VIEW_MAP:

    break;
  }
}




void main_menu() {
  default_display->current_view = VIEW_MENU;
  update(default_display, default_world);  
}


void wait_on_x() {
  wait_on_button(PSP_CTRL_CROSS);
}

void wait_on_button(int button) {
  int done = 0;
#ifdef x86
  SDL_Event event;
#else
  SceCtrlData pad;
#endif  
  while(!done) {
    
#ifdef x86
    if(SDL_PollEvent(&event)) 
      if(event.type == SDL_KEYDOWN) {
	if(event.key.keysym.sym == button)
	  done=1;
      } else if (event.type == SDL_QUIT) {
	shutdown();
      }
#else    
    sceCtrlReadBufferPositive(&pad, 1);
    if (pad.Buttons & button)
      done=1;
#endif
    
  }
}

int wait_on_input() {
  int done = 0;
#ifdef x86
  SDL_Event event;
#else
  SceCtrlData pad;
#endif  
  while(!done) {
    
#ifdef x86
    if(SDL_PollEvent(&event)) 
      if(event.type == SDL_KEYDOWN) {
	done=event.key.keysym.sym;
      } else if (event.type == SDL_QUIT) {
	shutdown();
      }
#else    
    sceCtrlReadBufferPositive(&pad, 1);
    if (pad.Buttons & PSP_CTRL_SELECT)
      done=PSP_CTRL_SELECT;
    else if (pad.Buttons & PSP_CTRL_START)
      done=PSP_CTRL_START;
    else if (pad.Buttons & PSP_CTRL_UP)
      done=PSP_CTRL_UP;
    else if (pad.Buttons & PSP_CTRL_RIGHT)
      done=PSP_CTRL_RIGHT;
    else if (pad.Buttons & PSP_CTRL_DOWN)
      done=PSP_CTRL_DOWN;
    else if (pad.Buttons & PSP_CTRL_LEFT)
      done=PSP_CTRL_LEFT;
    else if (pad.Buttons & PSP_CTRL_LTRIGGER)
      done=PSP_CTRL_LTRIGGER;
    else if (pad.Buttons & PSP_CTRL_RTRIGGER)
      done=PSP_CTRL_RTRIGGER;
    else if (pad.Buttons & PSP_CTRL_TRIANGLE)
      done=PSP_CTRL_TRIANGLE;
    else if (pad.Buttons & PSP_CTRL_CIRCLE)
      done=PSP_CTRL_CIRCLE;
    else if (pad.Buttons & PSP_CTRL_CROSS)
      done=PSP_CTRL_CROSS;
    else if (pad.Buttons & PSP_CTRL_SQUARE)
      done=PSP_CTRL_SQUARE;
#endif
    
  }
  return done;
}