namespace Supercell.Laser.Titan.Math
{
    using System.Text;
    using Supercell.Laser.Titan.DataStream;
    using Supercell.Laser.Titan.Util;

    public class LogicCompressedString
    {
        public int Length;
        public byte[] Data;

        public LogicCompressedString()
        {
            this.Length = -1;
            this.Data = null;
        }

        public LogicCompressedString(byte[] data, int length)
        {
            this.Length = length;
            this.Data = data;
        }

        public LogicCompressedString(string value)
        {
            this.Length = -1;
            this.Data = null;

            if (value != null)
            {
                this.SetString(value);
            }
        }

        public void SetString(string value)
        {
            if (value == null)
            {
                return;
            }

            byte[] raw = Encoding.UTF8.GetBytes(value);
            byte[] compressed;
            int compressedLength = ZLibHelper.CompressInZLibFormat(raw, out compressed);

            this.Length = compressedLength;
            this.Data = compressed;
        }

        public string GetString()
        {
            if (this.Length < 0)
            {
                return null;
            }

            byte[] decompressed;
            int result = ZLibHelper.DecompressInMySQLFormat(this.Data, out decompressed);

            if (result < 0)
            {
                return null;
            }

            return Encoding.UTF8.GetString(decompressed);
        }

        public bool HasString()
        {
            return this.Length >= 0;
        }

        public void Encode(ByteStream stream)
        {
            stream.WriteBytes(this.Data, this.Length);
        }

        public static void Encode(LogicCompressedString value, ByteStream stream)
        {
            if (value != null)
            {
                stream.WriteBytes(value.Data, value.Length);
            }
            else
            {
                stream.WriteBytes(null, -1);
            }
        }

        public static LogicCompressedString Decode(ByteStream stream)
        {
            int length = stream.ReadBytesLength();
            byte[] data = stream.ReadBytes(length, 900000);

            return new LogicCompressedString(data, length);
        }
    }
}