import org.kwis.msp.lcdui.*;

import java.io.*;
import java.util.Random;

public class MainCard extends Card implements Runnable{
	Thread mThread = new Thread(this);
	Display dis = Display.getDefaultDisplay();

	Graphics g;

	Random rnd = new Random();

	public final byte MAINSTATE_MENU = 0;
	public final byte MAINSTATE_GAME = 1;
	public final byte MAINSTATE_CLEAR = 2;
	public final byte MAINSTATE_GAMEOVER=3;

	public final byte MENU_STARTGAME = 0;
	public final byte MENU_CONTINUEGAME = 1;
	public final byte MENU_EXPGAME = 2;
	public final byte MENU_OPTION = 3;
	public final byte MENU_EXIT = 4;
	public final byte MENU_NUM = 5;
	public final byte LEFT = 0;
	public final byte RIGHT = 1;
	
	public final byte ENEMY_STATE_NONE=-1;
	public final byte ENEMY_STATE_STOP=0;
	public final byte ENEMY_STATE_MOVE=1;
	public final byte MAX_ENEMY_NUM=5;
	
	private final byte ENEMY_WIDTH=23;
	private final byte ENEMY_HEIGHT=20;
	private final byte ENEMY_SPEED=2;
	private final byte ENEMY_STOP_FRAME=6;
	private final byte ENEMY_MOVE_FRAME=8;
	
	
	private final static byte TILE_WIDTH = 16;
	private final static byte GROUND_HEIGHT = 20;
	private final static byte HERO_WIDTH = 21;
	private final static byte HERO_HEIGHT = 26;
	private final static byte HERO_SPEED=3;
	private final static byte HERO_JUMP_FRAME=6;
	private final static byte HERO_JUMP_PIXEL=5;
	private final static byte SCROLL_BOX_WIDTH=40;
		
	
	private final byte BULLET_WIDTH=4;
	private final byte BULLET_HEIGHT=2;
	private final byte BULLET_SPEED=2;
	
	private int bulletX;
	private int bulletY;
	private int bulletSpeed;
	private int scrollValue;
	
	int width, height;
	byte mainState;
	int menuCursor;

	private int heroX;
	private int heroY;
	private int heroDirection;
	private int heroSpeed;
	private int heroFrame;
	private boolean bHeroJump;
	private int scrollOffset;
	private int stageTileNum;
	private int[] stageMapData;
	private int[] enemyX=new int[MAX_ENEMY_NUM];
	private int[] enemyY=new int[MAX_ENEMY_NUM];
	private int[] enemyDirection = new int[MAX_ENEMY_NUM];
	private int[] enemyFrame=new int[MAX_ENEMY_NUM];
	private int[] enemyState = new int[MAX_ENEMY_NUM];
	
	
	Image imgGround[] = new Image[3];
	Image imgHero[] = new Image[6];
	Image imgEnemy[] = new Image[2];

	public final String MENU_TEXT[] = {"°ÔÀÓ½ÃÀÛ","À̾îÇϱâ","°ÔÀÓ¼³¸í","ȯ°æ¼³Á¤","°ÔÀÓÁ¾·á"};

	public MainCard(){		
		width = getWidth();
		height = getHeight();
		
		System.out.println("width->"+width+" height->"+height);
		
		setMainState(MAINSTATE_MENU);
	
		mThread.start();		
	}
	public void run(){
		while(true){
			repaint();
			try{Thread.sleep(100);}catch (InterruptedException ex){}
		}
	}
	public void paint(Graphics g){
		this.g = g;
		switch(mainState){
			case MAINSTATE_MENU:
				showMenu();				
				break;
			case MAINSTATE_GAME:
				showGame();
				break;
			case MAINSTATE_CLEAR:
				showClear();
				break;
			case MAINSTATE_GAMEOVER:
				showGameover();
				break;
		}
	}

	public void showMenu(){
		String text;

		g.setColor(255, 255, 255);
		g.fillRect(0, 0, width, height);
		g.setColor(0, 0, 0);
		for(int i=0; i<MENU_NUM; i++){
			if(i==menuCursor) text = "-> "+MENU_TEXT[i];
			else text = MENU_TEXT[i];
			g.drawString(text, width/2, 20+14*i, Graphics.HCENTER|Graphics.TOP);
		}
	}

	public void showGame(){
		g.setColor(0, 0, 0);
		g.fillRect(0, 0, width, height);
		g.setColor(255, 255, 255);	
		g.fillRect(0, height-GROUND_HEIGHT, width, GROUND_HEIGHT);
		drawMap();
		drawHero();
		gameUpdate();
		drawBullet();
		drawEnemy();
	}
	private void showClear(){
		g.setColor(255,255,255);
		g.drawString("Clear", width/2, height/2, Graphics.HCENTER|Graphics.TOP);
	}
	private void showGameover(){
		g.setColor(255,255,255);
		g.drawString("Game OVer",width/2,height/2,Graphics.HCENTER|Graphics.TOP);
	}
	private void gameUpdate() {
		// TODO Auto-generated method stub
		if(hitCheck()){
			setMainState(MAINSTATE_GAMEOVER);
			return;
		}
		if(getRatio(10)) makeBullet();
		if(heroX>=width){
			setMainState(MAINSTATE_CLEAR);
			return;
		}
		heroUpdate();
		bulletUpdate();
		enemyUpdate();
	}
	public void setEnemy(int x,int y){
		for(int i=0;i<MAX_ENEMY_NUM;i++){
			if(enemyState[i]==ENEMY_STATE_NONE){
				enemyX[i]=x;
				enemyY[i]=y;
				enemyDirection[i]=LEFT;
				enemyFrame[i]=0;
				enemyState[i]=ENEMY_STATE_MOVE;
				return;
			}
		}
	}
	public void enemyUpdate(){
		for(int i=0;i<MAX_ENEMY_NUM;i++){
			switch(enemyState[i]){
			case ENEMY_STATE_STOP:
				if(enemyFrame[i]>=ENEMY_STOP_FRAME){
					enemyDirection[i]=(enemyDirection[i]+1)%2;
					enemyState[i]=ENEMY_STATE_MOVE;
					enemyFrame[i]=0;
				}
				else enemyFrame[i]++;
				break;
				
			case ENEMY_STATE_MOVE:
				if(enemyFrame[i]>=ENEMY_STATE_MOVE){
					enemyState[i]=ENEMY_STATE_STOP;
					enemyFrame[i]=0;
					break;
				}
				if(enemyDirection[i]==LEFT){
					if(stageMapData[(enemyX[i]=ENEMY_SPEED-ENEMY_WIDTH/2)/TILE_WIDTH]==2){
						enemyState[i]=ENEMY_STATE_STOP;
						enemyFrame[i]=0;
						break;
					}
					enemyX[i]-=ENEMY_SPEED;
				}
				else if(enemyDirection[i]==RIGHT){
					if(stageMapData[(enemyX[i]+ENEMY_SPEED+ENEMY_WIDTH/2)/TILE_WIDTH]==2){
						enemyState[i]=ENEMY_STATE_STOP;
						enemyFrame[i]=0;
						break;
					}
					enemyX[i]+=ENEMY_SPEED;
				}
				enemyFrame[i]++;
				break;
			}			
		}
	}
	public boolean hitCheck(){
		if(stageMapData[(heroX+scrollOffset)/TILE_WIDTH]==2&&!bHeroJump){
			return true;
		}
		else if(bulletX!=-1){
			if(bulletX>heroX-HERO_WIDTH/2&&bulletX<heroX+HERO_WIDTH/2&&bulletY<heroY+HERO_HEIGHT/2&&bulletY>heroY-HERO_HEIGHT/2){
				return true;
			}
		}
		for(int i=0;i<MAX_ENEMY_NUM;i++){
			if(enemyState[i]!=ENEMY_STATE_NONE){
				if(enemyX[i]-scrollOffset > heroX-HERO_WIDTH/2&&enemyX[i]-scrollOffset<heroX+HERO_WIDTH/2&&enemyY[i]<heroY+HERO_HEIGHT/2&&enemyY[i]>heroY-HERO_HEIGHT/2){
					return true;
				}
			}
		}
		return false;
	}
	public void drawEnemy(){
		for(int i=0;i<MAX_ENEMY_NUM;i++){
			if(enemyState[i]!=ENEMY_STATE_NONE)
				g.drawImage(imgEnemy[(enemyFrame[i]/3)%2],enemyX[i]-scrollOffset-ENEMY_WIDTH/2,enemyY[i]-ENEMY_HEIGHT/2,0);			
		}
	}
	private void heroUpdate() {
		// TODO Auto-generated method stub
		heroX+=heroSpeed;
		if(bHeroJump){
			if(heroFrame!=0 && heroY==height-GROUND_HEIGHT-HERO_HEIGHT/2)
				bHeroJump=false;
			else if(heroFrame<HERO_JUMP_FRAME) heroY-=HERO_JUMP_PIXEL;
			else if(heroFrame>HERO_JUMP_FRAME) heroY+=HERO_JUMP_PIXEL;
		}
		if(heroSpeed!=0||bHeroJump) heroFrame++;
		if((heroX>width/2+SCROLL_BOX_WIDTH/2||heroX<width/2-SCROLL_BOX_WIDTH/2)&&(scrollOffset!=stageTileNum*TILE_WIDTH -width-1)){
			scrollOffset+=heroSpeed;
			heroX-=heroSpeed;
			if(scrollOffset<0) scrollOffset=0;
			else if(scrollOffset>=stageTileNum*TILE_WIDTH-width-1){
				scrollOffset=stageTileNum*TILE_WIDTH-width-1;
				heroX += heroSpeed;
			}
		}
		if(heroX<0) heroX=0;
	}
	public void bulletUpdate(){
		if(bulletX!=-1){
			bulletX+=bulletSpeed-scrollValue;
			if(bulletX<0||bulletX>width){
				bulletX=-1;
				bulletY=-1;
				bulletSpeed=0;
			}
		}
	}
	public void makeBullet(){
		if(bulletX==-1){
			bulletX=0+getRandom(2)*width;
			bulletY=height-GROUND_HEIGHT-HERO_HEIGHT/2;
			bulletSpeed=bulletX==0?BULLET_SPEED:(-1)*BULLET_SPEED;
		}
	}
	public void drawBullet(){
		if(bulletX!=-1){
			g.setColor(255,0,0);
			g.fillRect(bulletX-BULLET_WIDTH/2, bulletY-BULLET_HEIGHT/2, BULLET_WIDTH, BULLET_HEIGHT);
		}
	}
	public void drawHero(){		
//		g.drawImage(imgHero, heroX-HERO_WIDTH/2, heroY-HERO_HEIGHT/2, 0);
		if(bHeroJump)
			g.drawImage(imgHero[3*heroDirection+2], heroX-HERO_WIDTH/2, heroY-HERO_HEIGHT/2, 0);
		else g.drawImage(imgHero[3*heroDirection+(heroFrame/3)&2], heroX-HERO_WIDTH/2, heroY-HERO_HEIGHT/2, 0);
	}
	public void drawMap(){
		for(int i =scrollOffset/TILE_WIDTH;i<=(scrollOffset+width)/TILE_WIDTH;i++)
			g.drawImage(imgGround[stageMapData[i]],0-scrollOffset%TILE_WIDTH+TILE_WIDTH*(i-scrollOffset/TILE_WIDTH),height-GROUND_HEIGHT,0);		
	}
	public boolean keyNotify(int type, int key){
		if(type == EventQueue.KEY_PRESSED){
			switch(mainState){
				case MAINSTATE_MENU:
					keyMenu(key);				
					break;
				case MAINSTATE_GAME:
					keyGame(key);
					break;
				case MAINSTATE_CLEAR:
					keyClear(key);
					break;
				case MAINSTATE_GAMEOVER:
					keyGameover(key);
			}
		}
		repaint();
		return true;
	}
	public void keyClear(int key){
		switch(Display.getGameAction(key)){
		case EventQueue.FIRE:
			setMainState(MAINSTATE_MENU);
			unloadGame();
			break;
		}
	}
	public int getGameAction(int key){
		if((key >= EventQueue.KEY_NUM0 && key < EventQueue.KEY_NUM9) || key == EventQueue.KEY_POUND || key == EventQueue.KEY_STAR)
			return key;
		else
			return Display.getGameAction(key);
//			return dis.getGameAction(key);
	}

	public void keyMenu(int key){
		switch(getGameAction(key)){
			case EventQueue.UP:
			case EventQueue.LEFT:
				menuCursor--;
				if(menuCursor < 0)
					menuCursor = MENU_NUM-1;
				break;

			case EventQueue.DOWN:
			case EventQueue.RIGHT:
				menuCursor++;
				if(menuCursor == MENU_NUM)
					menuCursor = 0;
				break;

			case EventQueue.FIRE:
				switch(menuCursor){
					case MENU_STARTGAME:
						setMainState(MAINSTATE_GAME);
						loadGame();
						break;
					case MENU_CONTINUEGAME:
						break;
					case MENU_EXPGAME:
						break;
					case MENU_OPTION:
						break;
					case MENU_EXIT:
						break;
				}
				break;
		}
	}

	public void keyGame(int key){
		switch(getGameAction(key)){
			case EventQueue.UP:
			case EventQueue.FIRE:
				if(bHeroJump) break;
				bHeroJump=true;
				heroFrame=0;
				break;
			case EventQueue.DOWN:	
				break;
			case EventQueue.LEFT:
				if(bHeroJump) break;
				if(heroDirection!=LEFT) heroSpeed=0;
				else if(heroSpeed>HERO_SPEED*(-2)) heroSpeed-=HERO_SPEED;
				heroDirection=LEFT;
				break;
			case EventQueue.RIGHT:
				if(bHeroJump) break;
				if(heroDirection!=RIGHT) heroSpeed=0;
				else if(heroSpeed < HERO_SPEED*(2)) heroSpeed+=HERO_SPEED;
				heroDirection=RIGHT;
				break;
		}
	}
	public void keyGameover(int key){
		switch(getGameAction(key)){
		case EventQueue.FIRE:
			setMainState(MAINSTATE_MENU);
			unloadGame();
			break;
		case EventQueue.UP:
		case EventQueue.DOWN:
		case EventQueue.LEFT:
		case EventQueue.RIGHT:
			break;			
		}
	}
	public void setMainState(byte state){
		mainState = state;
		switch(mainState){
			case MAINSTATE_MENU:				
				initMenu();				
				break;
			case MAINSTATE_GAME:
				initGame();
				break;
			case MAINSTATE_GAMEOVER:
				break;
		}
	}

	public void loadGame(){
		try	{
			for(int i=0;i<6;i++) imgHero[i] = Image.createImage("img/hero"+(i+1)+".png");
			for(int i=0;i<3;i++) imgGround[i]=Image.createImage("img/ground"+(i+1)+".png");
			for(int i=0;i<2;i++) imgEnemy[i]=Image.createImage("img/enemy"+(i+1)+".png");
		}catch(IOException e){}
	}
	public void unloadGame(){
		for(int i=0;i<3;i++) imgGround[i]= null;
		for(int i=0;i<6;i++) imgHero[i] = null;
		for(int i=0;i<2;i++) imgEnemy[i]= null;
		stageMapData = null;
		
		System.gc();
	}

	public void initMenu(){
		menuCursor = 0;		
	}

	public void initGame(){
		int i;
		heroX = width/2;
		heroY = height - GROUND_HEIGHT - HERO_HEIGHT/2;	
		heroDirection = RIGHT;
		heroSpeed = 0;
		heroFrame = 0;
		bHeroJump=false;
		stageTileNum=50;
		scrollOffset=0;
		bulletX=-1;
		bulletY=-1;
		bulletSpeed=0;
		makeMap();
		
		for(i=0;i<MAX_ENEMY_NUM;i++){
			enemyX[i]=-1;
			enemyY[i]=-1;
			enemyDirection[i]=-1;
			enemyFrame[i]=-1;
			enemyState[i]=ENEMY_STATE_NONE;
		}
		for(i=0;i<2;i++)
			setEnemy(i*80+100,height-GROUND_HEIGHT-ENEMY_HEIGHT/2);
	}
	private void makeMap() {
		// TODO Auto-generated method stub
		stageMapData = new int[stageTileNum];
		
		for(int i=0;i<stageTileNum;i++){
			stageMapData[i]=i%2;
			if(getRatio(10)) stageMapData[i]=2;
		}
		for(int i=0;i<5;i++) stageMapData[i]=0;
		for(int i=stageTileNum-1;i>stageTileNum-6;i--) stageMapData[i]=0;

	}
	public int getRandom(int limit){
		int number = rnd.nextInt();
		number=(number>>>16)&0xFFFF;
		number/=(0xFFFF/limit);
		
		return number;
	}
	public boolean getRatio(int ratio){
		if(getRandom(1000)%100<ratio) return true;
		else return false;
	}
}