using System;
using System.Collections.Generic;
using System.Linq;

namespace PKHeX.Core
{
    public class ShadowInfoTableXD
    {
        private readonly List<ShadowInfoEntryXD> Entries;
        private readonly int MaxLength;

        public ShadowInfoTableXD(byte[] data)
        {
            Entries = new List<ShadowInfoEntryXD>();
            MaxLength = data.Length;
            const int eSize = ShadowInfoEntryXD.SIZE_ENTRY;
            int eCount = data.Length/eSize;
            for (int i = 0; i < eCount; i++)
            {
                byte[] d = new byte[eSize];
                Array.Copy(data, i*eSize, d, 0, eSize);

                var entry = new ShadowInfoEntryXD(d);
                //if (entry.Species != 0)
                    Entries.Add(entry);
            }
        }

        public byte[] FinalData => Entries.SelectMany(entry => entry.Data).Take(MaxLength).ToArray();

        public ShadowInfoEntryXD GetEntry(int Species, uint PID)
        {
            return Entries.Find(entry => entry.PID == PID && entry.Species == Species) ?? new ShadowInfoEntryXD();
        }

        public void SetEntry(ShadowInfoEntryXD Entry)
        {
            var entry = GetEntry(Entry.Species, Entry.PID);
            if (entry.IsEmpty)
                return;

            int index = Array.FindIndex(Entries.ToArray(), ent => ent.Species == entry.Species);
            if (index > 0)
                Entries[index] = entry;
            else
                Entries.Add(entry);
        }

        public ShadowInfoEntryXD this[int index] { get => Entries[index]; set => Entries[index] = value; }
        public int Count => Entries.Count;
    }

    public class ShadowInfoEntryXD
    {
        public byte[] Data { get; }
        internal const int SIZE_ENTRY = 72;

        public ShadowInfoEntryXD(byte[] data = null)
        {
            Data = data ?? new byte[SIZE_ENTRY];
        }

        public bool IsSnagged => Data[0] >> 6 != 0;
        public bool IsPurified { get => Data[0] >> 7 == 1; set { Data[0] &= 0x7F; if (value) Data[0] |= 0x80; } }
        public int Species { get => BigEndian.ToUInt16(Data, 0x1A); set => BigEndian.GetBytes((ushort)value).CopyTo(Data, 0x1A); }
        public uint PID { get => BigEndian.ToUInt32(Data, 0x1C); set => BigEndian.GetBytes(value).CopyTo(Data, 0x1C); }
        public int Purification { get => BigEndian.ToInt32(Data, 0x24); set => BigEndian.GetBytes(value).CopyTo(Data, 0x24); }

        public uint EXP { get => BigEndian.ToUInt32(Data, 0x04) >> 12; set => BigEndian.GetBytes((BigEndian.ToUInt32(Data, 0x04) & 0xFFF) | (value << 12)).CopyTo(Data, 0x04); }
        public bool IsEmpty => Species == 0;
    }

    public class ShadowInfoEntryColo
    {
        public byte[] Data { get; }
        internal const int SIZE_ENTRY = 12;

        public ShadowInfoEntryColo(byte[] data = null) => Data = data ?? new byte[SIZE_ENTRY];

        public uint PID { get => BigEndian.ToUInt32(Data, 0x00); set => BigEndian.GetBytes(value).CopyTo(Data, 0x00); }
        public int Met_Location { get => BigEndian.ToUInt16(Data, 0x06); set => BigEndian.GetBytes((ushort)value).CopyTo(Data, 0x06); }
        public uint _0x08 { get => BigEndian.ToUInt32(Data, 0x08); set => BigEndian.GetBytes(value).CopyTo(Data, 0x08); }
    }
}