//package com.nano.KangooJumper;

import javax.microedition.lcdui.Image;
import javax.microedition.lcdui.Graphics;

public class Sprite
{
	// frame sequence playback modes
	public final static int FORWARD = 0;
	public final static int FORWARD_RESET = 1;
	public final static int FORWARD_LOOP = 2;
	public final static int PONG = 3;
	
	private Image m_image;
	private int frameWidth;
	private int frameHeight;
	private int framesNum;
	private int m_currentFrame;
	
	private int[] m_frameXOffsets;
	private int[] m_frameYOffsets;

	private int[] m_frameSequence;
	public int m_playbackStartTime;
	private int m_playbackType;
	private int m_timePerFrame;

	public	int	anchor = Graphics.LEFT | Graphics.TOP;
	public int posX, posY;
	public int mapX, mapY;
	public	int	dir;
	public	int	type;
	
	public boolean isMoving, isVisible = true;
	public int m_startX;
	public int m_startY;
	public int m_destX;
	public int m_destY;
	public int m_moveStartTime;
	public int m_moveStopTime;
	private boolean  m_pongSign = false;
	
	public Sprite (Image image, int aFrameWidth, int aFrameHeight)
	{
		m_image = image;
		frameWidth = aFrameWidth;
		frameHeight = aFrameHeight;
				
		calcFrameOffsets ();
	}
	
	public Sprite (int fileId, int aFrameWidth, int aFrameHeight)
	{
		m_image = Utils.LoadImage (fileId);
		frameWidth = aFrameWidth;
		frameHeight = aFrameHeight;
		
		calcFrameOffsets ();
	}

	/*public Sprite (int fileId, int palId, int aFrameWidth, int aFrameHeight)
	{
		m_image = PngLoader.loadImage (fileId, palId, Utils.getFileLen(palId) / 4);

		m_frameWidth = aFrameWidth;
		m_frameHeight = aFrameHeight;
		
		calcFrameOffsets ();
	}*/
	
	public void paint (Graphics g)
	{
		
        if (Main.pauseDuration != 0 && this != Main.GamePlay.sprKangoo) {
            System.out.println("Sprite.paint " + this);
            m_moveStartTime += Main.pauseDuration;
            m_moveStopTime += Main.pauseDuration;
        }		
		if (isMoving == false)
			paint (g, posX, posY);
		else
		{
			int time = Utils.getTime ();
			
			if (time > m_moveStopTime)
			{
				isMoving = false;
				posX = m_destX;
				posY = m_destY;
				paint (g, posX, posY);
			}
			else
			if (time >= m_moveStartTime)
			{
				int x = posX = Utils.interpolate (m_destX, m_moveStopTime, m_startX, m_moveStartTime, time);
				int y = posY = Utils.interpolate (m_destY, m_moveStopTime, m_startY, m_moveStartTime, time);

				paint (g, x, y);
			}
			else
			paint(g, m_startX, m_startY);
		}
	}
	
	public void paint (Graphics g, int x, int y)
	{
		//Utils.Log("paint: "+x+" "+y);
		int frame = m_currentFrame;
		
		if (m_frameSequence != null)
		{
			int dt = Utils.getTime () - m_playbackStartTime;
			if (dt < 0)
				dt = 0;
			int frameIndex = dt / m_timePerFrame;
			int	tmp = frameIndex;
			
			// pong patch
			if ((m_playbackType == PONG) && (m_pongSign))
				frameIndex = m_frameSequence.length - frameIndex -1;
			
			if (tmp >= m_frameSequence.length)
			{
				switch (m_playbackType)
				{
					case FORWARD:
						frame = m_currentFrame = m_frameSequence[m_frameSequence.length - 1];
						m_frameSequence = null;
						break;
					
					case FORWARD_RESET:
						frame = m_currentFrame;
						m_frameSequence = null;
						break;
						
					case PONG:
						m_pongSign = !m_pongSign;
						if (m_pongSign)
							frame = m_frameSequence[m_frameSequence.length - 1];
						else
							frame = m_frameSequence[0];
						
						
					case FORWARD_LOOP:
						m_playbackStartTime = Utils.getTime () - (dt - m_frameSequence.length * m_timePerFrame);
						frameIndex = m_frameSequence[0];
						break;
				}
			}
			else frame = m_frameSequence[frameIndex];
		}
		
		if ((frame < 0) || (!isVisible))
			return;
		
		g.setClip (x, y, frameWidth, frameHeight);
		g.drawImage (m_image,
					 x - m_frameXOffsets[frame],
					 y - m_frameYOffsets[frame],
					 anchor);

	}
	
	public void setFrame (int frame)
	{
		m_currentFrame  = frame;
		m_frameSequence = null;
	}

	public void setFrameSequence (int[] frameSeq, int playbackType, int timePerFrame)
	{
		m_frameSequence = frameSeq;
		m_playbackType = playbackType;
		m_timePerFrame = timePerFrame;
		m_playbackStartTime = Utils.getTime ();
	}

	public void setFrameSequenceTotalTime (int[] frameSeq, int playbackType, int totalTime)
	{
		m_frameSequence = frameSeq;
		m_playbackType = playbackType;
		
		m_timePerFrame = totalTime / frameSeq.length;
		m_playbackStartTime = Utils.getTime ();
	}

	
	public void moveTo (int x, int y, int time)
	{
		isMoving = true;
		m_startX = posX;
		m_startY = posY;
		m_destX = x;
		m_destY = y;
		m_moveStartTime = Utils.getTime ();
		m_moveStopTime = m_moveStartTime + time;
	}
	
	public void setPos (int x, int y)
	{
		posX = x;
		posY = y;
	}
	
	public int getFrame ()
	{
		if (m_frameSequence == null)
			return m_currentFrame;

		int dt = Utils.getTime () - m_playbackStartTime;
		if (dt < 0)
			dt = 0;		
		int frameIndex = dt / m_timePerFrame;
		int	tmp = frameIndex;

		// pong patch
		if ((m_playbackType == PONG) && (m_pongSign))
			frameIndex = m_frameSequence.length - frameIndex -1;

		if (tmp >= m_frameSequence.length)
		{
			switch (m_playbackType)
			{
				case FORWARD:
					return m_frameSequence[m_frameSequence.length - 1];
			
				case FORWARD_RESET:
					return m_currentFrame;
				
				case PONG:
					if (!m_pongSign)
						return m_frameSequence[m_frameSequence.length - 1];
					else
						return  m_frameSequence[0];

				case FORWARD_LOOP:
					return m_frameSequence[0];
			}
		}
		return m_frameSequence[frameIndex];
	}
	
	
	public boolean isPlayingAnim ()
	{
		return m_frameSequence != null;
	}
	
	private void calcFrameOffsets ()
	{
		if (frameWidth > m_image.getWidth())
			frameWidth = m_image.getWidth();
		if (frameHeight > m_image.getHeight())
			frameHeight = m_image.getHeight();
		
		int framesH = m_image.getWidth () / frameWidth;
		int framesV = m_image.getHeight () / frameHeight;
		
		framesNum = framesH * framesV;

		m_frameXOffsets = new int[framesNum];
		m_frameYOffsets = new int[framesNum];
		
		int frame = 0;
		
		for (int yloop = 0; yloop < framesV; yloop++)
		{
			for (int xloop = 0; xloop < framesH; xloop++)
			{
				m_frameXOffsets[frame] = xloop * frameWidth;
				m_frameYOffsets[frame] = yloop * frameHeight;
				frame++;
			}
		}
	}
	
	private	boolean	isIn(int x, int x1, int x2)
	{
		if (x1 < x2)
		{
			if ((x >= x1) && (x <= x2))
				return true;
			else
				return false;
		}
		else
		{
			if ((x >= x2) && (x <= x1))
				return true;
			else
				return false;
		}			
	}
	
	
	public	boolean	collide(Sprite spr)
	{
		if (spr != null)
		{
			//(x2 >= x3) && (x4 >= x1) && (y2 >= y3) && (y4 >= y1
			/*if (((spr.posX + spr.frameWidth) >= posX) &&
				((posX + frameWidth) >= spr.posX) &&
				(spr.posY >= (posY + frameHeight)) &&
				(posY >= (spr.posY + spr.frameHeight)))
				return true;*/
			
			if (((isIn( spr.posX, posX + 10, posX + frameWidth - 10)) ||
				(isIn( spr.posX + spr.frameWidth, posX + 10, posX + frameWidth - 10))) &&
				((isIn( spr.posY, posY +10, posY + frameHeight -10)) ||
				(isIn( spr.posY + spr.frameHeight, posY +10, posY + frameHeight - 10))))
				return true;
		}
		
		return false;
	}
	
	public void reset()
	{
		//posX = 0;
		//posY = 0;
		m_frameSequence = null;
		isMoving = false;
		isVisible = true;
		m_startX = 0;
		m_startY = 0;
		m_destX = 0;
		m_destY = 0;
		m_moveStartTime = 0;
		m_moveStopTime = 0;	
	}
}