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

namespace EFT_Editor
{
    public class ShipDB : EFTDatabase<ShipDB.Ship>
    {
        // basic structure of this data file reading code thanks to Sunset Sunrise @goonfleet.com

        public class SkillRequirement
        {
            public Int32 SkillID;
            public Int32 Rank;

            internal SkillRequirement(BinaryReader dataReader)
            {
                SkillID = dataReader.ReadInt32();
                Rank    = dataReader.ReadInt32();
            }
        }

        public class ShipBonus
        {
            private const byte nModuleSlots = 5;

            public Int32 AttributeID;
            public Int32 SkillID;
            public float Value;
            public byte  Type;

            public Int32[] AffectedModules = new Int32[nModuleSlots];

            internal ShipBonus(BinaryReader dataReader)
            {
                AttributeID  = dataReader.ReadInt32();
                Value        = dataReader.ReadSingle();
                Type         = dataReader.ReadByte();
                SkillID      = dataReader.ReadInt32();

                for (int i = 0; i < nModuleSlots; i++)
                    AffectedModules[i] = dataReader.ReadInt32();
            }
        }

        public class Ship
        {
            private const byte nSkillReqs = 3;

            public string Name        { get; set; }
            public string Class       { get; set; }
            public string Description { get; set; }
            public Int16  RaceID      { get; set; }

            public Int32 LowSlots  { get; set; }
            public Int32 MidSlots  { get; set; }
            public Int32 HighSlots { get; set; }
            public Int32 Rigs      { get; set; }

            private Dictionary<Int32, float> _attributes;
            private List<SkillRequirement>   _reqSkills;
            private List<ShipBonus>          _bonuses;

            public Dictionary<Int32, float> ShipAttributes { get { return _attributes; } }
            public List<SkillRequirement>   RequiredSkills { get { return _reqSkills; } }
            public List<ShipBonus>          ShipBonuses    { get { return _bonuses;    } }

            internal Ship(BinaryReader dataReader)
            {
                ReadFromFile(dataReader);
            }

            internal void ReadFromFile(BinaryReader dataReader)
            {
                Name        = HelperFunctions.ReadString(dataReader, dataReader.ReadByte());
                Class       = HelperFunctions.ReadString(dataReader, dataReader.ReadByte());
                RaceID      = dataReader.ReadInt16();
                Description = HelperFunctions.ReadString(dataReader, dataReader.ReadInt32());

                LowSlots  = dataReader.ReadInt32();
                MidSlots  = dataReader.ReadInt32();
                HighSlots = dataReader.ReadInt32();
                Rigs      = dataReader.ReadInt32();

                _reqSkills = new List<SkillRequirement>(nSkillReqs);
                Int32 attributeCount = dataReader.ReadInt32();
                _attributes = new Dictionary<Int32, float>(attributeCount);
                Int32 bonusCount = dataReader.ReadInt32();
                _bonuses = new List<ShipBonus>(bonusCount);

                for (int i = 0; i < attributeCount; i++)
                {
                    Int32 id = dataReader.ReadInt32();
                    float value = dataReader.ReadSingle();
                    _attributes.Add(id, value);
                }

                for (int i = 0; i < bonusCount; i++)
                    _bonuses.Add(new ShipBonus(dataReader));

                for (int i = 0; i < nSkillReqs; i++)
                    _reqSkills.Add(new SkillRequirement(dataReader));
            }

            internal void WriteToFile(BinaryWriter dataWriter)
            {
                HelperFunctions.WriteString(dataWriter, Name, (byte)Name.Length);
                HelperFunctions.WriteString(dataWriter, Class, (byte)Class.Length);
                dataWriter.Write(RaceID);
                HelperFunctions.WriteString(dataWriter, Description, (Int32)Description.Length);

                dataWriter.Write(LowSlots);
                dataWriter.Write(MidSlots);
                dataWriter.Write(HighSlots);
                dataWriter.Write(Rigs);

                dataWriter.Write(_attributes.Count);
                dataWriter.Write(_bonuses.Count);

                foreach (KeyValuePair<Int32, float> attrib in _attributes)
                {
                    dataWriter.Write(attrib.Key);
                    dataWriter.Write(attrib.Value);
                }

                foreach (ShipBonus bonus in _bonuses)
                {
                    dataWriter.Write(bonus.AttributeID);
                    dataWriter.Write(bonus.Value);
                    dataWriter.Write(bonus.Type);
                    dataWriter.Write(bonus.SkillID);

                    foreach (Int32 module in bonus.AffectedModules)
                        dataWriter.Write(module);
                }

                foreach (SkillRequirement skill in _reqSkills)
                {
                    dataWriter.Write(skill.SkillID);
                    dataWriter.Write(skill.Rank);
                }
            }
        }

        public ShipDB(string filePath)
        {
            ReadFrom(filePath);
        }

        public override void ReadFrom(Stream dataStream)
        {
            BinaryReader dataReader = new BinaryReader(dataStream);

            int nShips = dataReader.ReadInt32();
            _dataStore = new List<Ship>(nShips);

            for (int i = 0; i < nShips; i++)
                _dataStore.Add(new Ship(dataReader));

            dataReader.Close();
        }

        public override void WriteTo(Stream dataStream)
        {
            BinaryWriter dataWriter = new BinaryWriter(dataStream);

            int nShips = _dataStore.Count;
            dataWriter.Write(_dataStore.Count);

            foreach (Ship ship in _dataStore)
                ship.WriteToFile(dataWriter);

            dataWriter.Close();
        }
    }
}