package com.j2medev.chapter5;

import javax.microedition.lcdui.*;
import java.io.*;

public class PieceSprite
{
    Image sprImage;
    short[][][][] sprData;
    boolean isEndOfAnimation;
    public static final int TRANS_NONE = 0;
    public static final int TRANS_ROT90 = 5;
    public static final int TRANS_ROT180 = 3;
    public static final int TRANS_ROT270 = 6;
    public static final int TRANS_MIRROR = 2;
    public static final int TRANS_MIRROR_ROT90 = 7;
    public static final int TRANS_MIRROR_ROT180 = 1;
    public static final int TRANS_MIRROR_ROT270 = 4;
    //following params is equal to Graphics's paramas  ,so it is easy for porting
    public static final int HCENTER = 1;
    public static final int VCENTER = 2;
    public static final int LEFT = 4;
    public static final int RIGHT = 8;
    public static final int TOP = 16;
    public static final int BOTTOM = 32;
    /**
     * 當前動畫數據
     */
    short[][][] currentAnimation;
    /**
     * 當前幀數據
     */
    short[][] currentFrame;
    /**
     * 當前幀時間
     */
    short currentFrameTime;
    /**
     * 當前幀保留值
     */
    short currentFrameValue;
    /**
     * 當前幀水平偏移
     */
    short currentFrameGlobalX;
    /**
     * 當前幀垂直偏移
     */
    short currentFrameGlobalY;
    /**
     * 當前幀碰撞起始點X
     */
    short currentFrameCollisionX;
    /**
     * 當前幀碰撞機始點Y
     */
    short currentFrameCollisionY;
    /**
     * 當前幀碰撞寬度
     */
    short currentFrameCollisionW;
    /**
     * 當前幀碰撞高度
     */
    short currentFrameCollisionH;
    /**
     * 當前幀幀號
     */
    short currentFrameNr;
    /**
     * 是否連續播放
     */
    boolean isAnimationRepeat;
    /**
     * 幀的起始時間
     */
    long startFrameTime;
    /**
     * 是否是一次性載入標志
     */
    boolean b_LoadedOnce;
    /**
     * 構造函數直接通過傳入四維數組進行初始化
     * @param spriteSheet Image
     * @param spriteData short[][][][]
     */
    public PieceSprite(Image spriteSheet, short[][][][] spriteData)
    {
        sprImage = spriteSheet;
        sprData = spriteData;
    }

    /**  輸入流*/
    private InputStream is = null;
    /**  數據輸入流*/
    private DataInputStream dis = null;
    /**
     *當前動畫的長度
     */
    short CurrentAnimationFrameLength;
    /**
     *數據文件名
     */
    String m_strBinData;
    short m_rate;
    /**
     * 該構造方法用于播放單一的、連續的、幀頻數很多的動畫對像
     * @param spriteSheet Image
     * @param binData String
     * @param rate 縮放比例
     * @param bLoadAll boolean 是否將數據一次全部載入到數組中
     */
    public PieceSprite(Image spriteSheet, String binData, short rate,
                       boolean bLoadAll)
    {
        m_rate = rate;
        m_strBinData = binData;
        sprImage = spriteSheet;
        is = getClass().getResourceAsStream(binData);
        dis = new DataInputStream(is);

        b_LoadedOnce = bLoadAll;
        try
        {
            //讀取動畫長度
            short PlayerAnimationsLength = ReadShortFromBCC(dis);

            if (bLoadAll) //如果是一次載入
            {
                sprData = new short[PlayerAnimationsLength][][][];
                for (int i = 0; i < PlayerAnimationsLength; i++)
                {
                    sprData[i] = read_One_Animation();
                }
                dis.close();
            }
            else //如果是多次載入
            {
                CurrentAnimationFrameLength = ReadShortFromBCC(dis);
            }
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
    public void TRACE(String str)
    {

        System.out.println(str);
    }
    /**
     * 讀取動畫工程中的一個動畫
     * @return short[][][]
     */
    public short[][][] read_One_Animation()
    {
        //讀取該動畫包含的Frame的長度
        int CurrentAnimationFrameLength = ReadShortFromBCC(dis);
        short animationData[][][] = new short[CurrentAnimationFrameLength][][];

        for (int i = 0; i < CurrentAnimationFrameLength; i++)
        {
            animationData[i] = read_One_Frame();
        }
        return animationData;
    }
    /**
     * 讀取動畫中的一幀
     * @return short[][]
     */
    public short[][] read_One_Frame()
    {
        int globalOX = ReadShortFromBCC(dis);
        int globalOY = ReadShortFromBCC(dis);
        int time = ReadShortFromBCC(dis);
        int value = ReadShortFromBCC(dis);
        int rx = ReadShortFromBCC(dis);
        int ry = ReadShortFromBCC(dis);
        int rx2 = ReadShortFromBCC(dis);
        int ry2 = ReadShortFromBCC(dis);

        //讀取該Frame的包含的零件的長度
        int CurrentFramePieceLength = ReadShortFromBCC(dis);
        short frameData[][] = new short[CurrentFramePieceLength + 1][];

        for (int k = 0; k < CurrentFramePieceLength + 1; k++)
        {
            if (k == 0)
            {
                frameData[k] = new short[8];

                frameData[0][0] = (short) value;
                frameData[0][1] = (short) time;
                frameData[0][2] = (short) globalOX;
                frameData[0][3] = (short) globalOY;
                frameData[0][4] = (short) rx;
                frameData[0][5] = (short) ry;
                frameData[0][6] = (short) (rx2 - rx);
                frameData[0][7] = (short) (ry2 - ry);
            }
            else
            {
                frameData[k] = new short[6];

                int ox = ReadShortFromBCC(dis);
                int oy = ReadShortFromBCC(dis);
                rx = ReadShortFromBCC(dis);
                ry = ReadShortFromBCC(dis);
                rx2 = ReadShortFromBCC(dis);
                ry2 = ReadShortFromBCC(dis);

                frameData[k][0] = (short) rx;
                frameData[k][1] = (short) ry;
                frameData[k][2] = (short) (rx2 - rx);
                frameData[k][3] = (short) (ry2 - ry);
                frameData[k][4] = (short) ox;
                frameData[k][5] = (short) oy;
            }
        }
        return frameData;
    }
    /**
     *從BorlandC++語言中讀取 short數據
     */
    public short ReadShortFromBCC(DataInputStream dataInputStream)
    {
        short data[] = new short[2];
        try
        {
            for (int i = 0; i < 2; i++)
            {
                data[i] = (short) dataInputStream.readByte();
                if (data[i] < 0)
                {
                    data[i] = (short) (256 + data[i]);
                }
            }
        }
        catch (IOException ex)
        {
            ex.printStackTrace();
        }
        //  System.out.println("read int "+(data[0]+(int)(data[1]<<8)+(int)(data[2]<<16)+(int)(data[3]<<24)));
        return (short) ( (short) (data[0]) + (short) (data[1] << 8));
    }
    // RETURN FRAME VALUE
    public int setAnimation(int nr, boolean repeat)
    {
        isEndOfAnimation = false;
        isAnimationRepeat = repeat;
        if (!b_LoadedOnce)
        {
            return -1;
        }

        currentAnimation = sprData[nr];

        return setFrame( (short) 0);
    }
    // FRAME VALUE=0 TIME=100 GLOBAL_X=0 GLOBAL_Y=0 RX=0 RY=0 W=21 H=32
    public int setFrame(short nr)
    {
        currentFrameNr = nr;
        currentFrame = currentAnimation[nr];

        currentFrameValue = currentFrame[0][0];
        currentFrameTime = currentFrame[0][1];
        currentFrameGlobalX = currentFrame[0][2];
        currentFrameGlobalY = currentFrame[0][3];
        currentFrameCollisionX = currentFrame[0][4];
        currentFrameCollisionY = currentFrame[0][5];
        currentFrameCollisionW = currentFrame[0][6];
        currentFrameCollisionH = currentFrame[0][7];

        startFrameTime = System.currentTimeMillis();

        return currentFrameValue;
    }
    /**
     * SETTING ANIMATION NEXT FRAME
     * @return int - TRIGGER VALUE OR -1 IF FRAME NOT SWITCHED
     */
    public int setNextFrame()
    {
        if (b_LoadedOnce)
        {
            // CHECK IF WE CAN SWITCH FOR NEXT FRAME (IS FINISHED FRAME TIME)
            if (startFrameTime + currentFrameTime > System.currentTimeMillis())
            {
                return -1;