using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;

namespace WOMGeneral
{
    public class TileBase
    {
        public int width = 16;
        public int height = 16;
        public bool[,] pixels = new bool[16, 16];
        public bool solid = false;
        public int colorPalette = 0;

        public TileBase(byte[] serialized)
        {
            Deserialize(serialized);
        }

        public TileBase()
        {
            //SetSprite(pixels);
        }

        public virtual void Deserialize(byte[] serialized)
        {
            MemoryStream ms = new MemoryStream(serialized);
            int serializeVersion = ms.ReadByte();
            byte[] serializedSprite = null;
            switch (serializeVersion)
            {
                case 0: throw new Exception("ERROR DESERIALIZING");
                case 1: //No nonsense, sprite only
                    this.solid = false;
                    serializedSprite = new byte[ms.Length - 1];
                    ms.Read(serializedSprite, 0, serializedSprite.Length);
                    SetSprite(serializedSprite);
                    break;
                case 2: //Solidness followed by sprite
                    if (ms.ReadByte() > 0) solid = true;
                    else solid = false;
                    serializedSprite = new byte[ms.Length - 2];
                    ms.Read(serializedSprite, 0, serializedSprite.Length);
                    SetSprite(serializedSprite);
                    break;
                case 3: //Empty tile
                    this.solid = false;
                    break;
                case 4: //Empty but solid tile
                    solid = true;
                    break;
            }
            ms.Close();

            if (serializedSprite != null)
            {
                SetSprite(serializedSprite);
            }
        }

        public virtual void SetSprite(bool[,] newPixels)
        {
            pixels = newPixels;
        }

        public void SetSprite(byte[] serialized)
        {
            MemoryStream ms = new MemoryStream(serialized);
            int serializeVersion = ms.ReadByte();

            switch (serializeVersion)
            {
                case 1: //Plain 16x16 black and white sprite, each pixel a byte
                    {
                        this.width = 16;
                        this.height = 16;
                        this.colorPalette = 0;

                        bool[,] readValues = new bool[16, 16];
                        for (int iy = 0; iy < 16; iy++)
                        {
                            for (int ix = 0; ix < 16; ix++)
                            {
                                if (ms.ReadByte() > 0) readValues[ix, iy] = true;
                                else readValues[ix, iy] = false;
                            }
                        }
                        SetSprite(readValues);
                        break;
                    }
                case 2: //16x16. Palette followed by binary booleans, 8 pixels per byte
                    {
                        this.width = 16;
                        this.height = 16;
                        this.colorPalette = ms.ReadByte();

                        bool[][] booleanSets = new bool[32][];
                        for (int i = 0; i < booleanSets.Length; i++)
                        {
                            byte b = (byte)ms.ReadByte();
                            booleanSets[i] = UtilBase.ByteToBooleans(b);
                        }

                        bool[,] readValues = new bool[16, 16];
                        for (int iy = 0; iy < 16; iy++)
                        {
                            for (int ix = 0; ix < 16; ix++)
                            {
                                int targetSet = iy * 2;
                                int targetNumber = ix;
                                if (ix > 7)
                                {
                                    targetSet++;
                                    targetNumber -= 8;
                                }
                                readValues[ix, iy] = booleanSets[targetSet][targetNumber];
                            }
                        }
                        SetSprite(readValues);
                        break;
                    }
            }

            ms.Close();
        }

        //Parameter allows you to serialize using a specific serialization version
        public virtual byte[] Serialize(int specifiedTileVersion = -1, int specifiedSpriteVersion = -1)
        {
            List<byte> toReturn = new List<byte>();

            if (specifiedTileVersion == -1) //Default; choose which to use
            {
                specifiedTileVersion = 1;

                if (solid) specifiedTileVersion = 2; //If it has properties, don't use #1
            }

            toReturn.Add((byte)specifiedTileVersion);

            //Serialize properties
            switch (specifiedTileVersion)
            {
                case 2:
                    if (solid) toReturn.Add(0x53); //S for Solid
                    else toReturn.Add(0x00);
                    break;
            }

            //Serialize sprite
            switch (specifiedTileVersion)
            {
                case 1:
                case 2:
                    if (specifiedSpriteVersion == -1) //Default; choose which to use
                    {
                        specifiedSpriteVersion = 2;
                    }

                    byte[] serializedSprite = SerializeSprite(specifiedSpriteVersion);
                    for(int i = 0; i < serializedSprite.Length; i++) { toReturn.Add(serializedSprite[i]); }
                    break;
            }

            return toReturn.ToArray();
        }

        public virtual byte[] SerializeSprite(int specifiedSpriteVersion = -1)
        {
            List<byte> toReturn = new List<byte>();

            toReturn.Add((byte)specifiedSpriteVersion);

            switch (specifiedSpriteVersion)
            {
                case 2:
                    toReturn.Add((byte)colorPalette);

                    //Transform booleans to bytes using black magic
                    for (int i = 0; i < 16; i++)
                    {
                        for (int ii = 0; ii < 2; ii++)
                        {
                            bool[] toConvert = new bool[8];
                            for (int iii = 0; iii < 8; iii++)
                            {
                                toConvert[iii] = pixels[8 * ii + iii, i];
                            }

                            toReturn.Add(UtilBase.BooleansToByte(toConvert));
                        }
                    }

                    break;
            }

            return toReturn.ToArray();
        }

        public virtual void Move(int offsetX, int offsetY)
        {
            
        }

        public virtual void EraseTile()
        {
            
        }

        public virtual void SetSpritePosition(int x, int y)
        {

        }
    }
}