using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using QiHe.CodeLib;

namespace HH.WMS.Utils.ExcelLibrary.BinaryFileFormat
{
    public partial class Record
    {
        public UInt16 Type;
        public UInt16 Size;
        public byte[] Data;

        public List<Record> ContinuedRecords;

        public const UInt16 MaxContentLength = 8224;

        public Record()
        {
            ContinuedRecords = new List<Record>();
        }

        public Record(Record record)
        {
            Type = record.Type;
            Size = record.Size;
            Data = record.Data;
            ContinuedRecords = record.ContinuedRecords;
        }

        public virtual void Decode()
        {
        }

        public virtual void Encode()
        {
            this.ContinuedRecords.Clear();
            if (Size > 0 && Data.Length > MaxContentLength)
            {
                int index = MaxContentLength;
                while (index < Data.Length)
                {
                    CONTINUE continuedRecord = new CONTINUE();
                    int size = Math.Min(MaxContentLength, Data.Length - index);
                    continuedRecord.Data = Algorithm.ArraySection(Data, index, size);
                    continuedRecord.Size = (ushort)size;
                    this.ContinuedRecords.Add(continuedRecord);
                    index += size;
                }
                this.Size = MaxContentLength;
                this.Data = Algorithm.ArraySection(Data, 0, MaxContentLength);
            }
        }

        public static Record ReadBase(Stream stream)
        {
            BinaryReader reader = new BinaryReader(stream);
            Record record = new Record();
            record.Type = reader.ReadUInt16();
            record.Size = reader.ReadUInt16();
            record.Data = reader.ReadBytes(record.Size);
            return record;
        }

        /// <summary>
        /// Data size plus header size
        /// </summary>
        public int FullSize
        {
            get
            {
                int full_size = 4 + Size;
                foreach (Record record in ContinuedRecords)
                {
                    full_size += 4 + record.Size;
                }
                return full_size;
            }
        }

        public int TotalSize
        {
            get
            {
                int total_size = Size;
                foreach (Record record in ContinuedRecords)
                {
                    total_size += record.Size;
                }
                return total_size;
            }
        }

        public byte[] AllData
        {
            get
            {
                if (ContinuedRecords.Count == 0) return Data;
                else
                {
                    List<byte> data = new List<byte>(TotalSize);
                    data.AddRange(Data);
                    foreach (Record record in ContinuedRecords)
                    {
                        data.AddRange(record.AllData);
                    }
                    return data.ToArray();
                }
            }
        }

        public static object DecodeRK(uint value)
        {
            bool muled = (value & 0x01) == 1;
            bool isFloat = (value & 0x02) == 0;
            if (isFloat)
            {
                UInt64 data = ((UInt64)(value & 0xFFFFFFFC)) << 32;
                double num = TreatUInt64AsDouble(data);
                if (muled) num /= 100;
                return num;
            }
            else
            {
                Int32 num = (int)(value & 0xFFFFFFFC) >> 2;
                if (muled)
                {
                    return (decimal)num / 100;
                }
                return num;
            }
        }

        public static double TreatUInt64AsDouble(UInt64 data)
        {
            //byte[] bytes = new byte[8];
            //MemoryStream stream = new MemoryStream(bytes);
            //BinaryWriter writer = new BinaryWriter(stream);
            //BinaryReader reader = new BinaryReader(stream);
            //writer.Write(data);
            //stream.Position = 0;
            //return reader.ReadDouble();

            byte[] bytes = BitConverter.GetBytes(data);
            return BitConverter.ToDouble(bytes, 0);
        }

        public void Write(BinaryWriter writer)
        {
            writer.Write(this.Type);
            writer.Write(this.Size);
            if (this.Size > 0)
            {
                writer.Write(this.Data);
                if (this.ContinuedRecords.Count > 0)
                {
                    foreach (Record record in ContinuedRecords)
                    {
                        writer.Write(record.Type);
                        writer.Write(record.Size);
                        writer.Write(record.Data);
                    }
                }
            }
        }

        public string ReadString(BinaryReader reader, int lengthbits)
        {
            StringDecoder stringDecoder = new StringDecoder(this, reader);
            return stringDecoder.ReadString(lengthbits);
        }

        public static void WriteString(BinaryWriter writer, string text, int lengthbits)
        {
            if (lengthbits == 8)
            {
                writer.Write((byte)text.Length);
            }
            else if (lengthbits == 16)
            {
                writer.Write((ushort)text.Length);
            }
            else
            {
                throw new ArgumentException("Invalid lengthbits, must be 8 or 16.");
            }

            if (TextEncoding.FitsInASCIIEncoding(text))
            {
                writer.Write((byte)0);
                writer.Write(Encoding.ASCII.GetBytes(text));
            }
            else
            {
                writer.Write((byte)1);
                writer.Write(Encoding.Unicode.GetBytes(text));
            }
        }

        public static int GetStringDataLength(string text)
        {
            if (TextEncoding.FitsInASCIIEncoding(text))
            {
                return Encoding.ASCII.GetByteCount(text) + 3;
            }
            else
            {
                return text.Length * 2 + 3;
            }
        }

        public static void EncodeRecords(List<Record> records)
        {
            foreach (Record record in records)
            {
                record.Encode();
            }
        }

        public static int CountDataLength(List<Record> records)
        {
            int dataLength = 0;
            foreach (Record record in records)
            {
                dataLength += record.FullSize;
            }
            return dataLength;
        }
    }
}