using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using PkmnLibSharp.Library;
using PkmnLibSharp.Utilities;
using Item = PkmnLibSharp.Library.Items.Item;
using Nature = PkmnLibSharp.Library.Nature;

namespace PkmnLibSharp.Battling
{
    public class Pokemon : PointerWrapper
    {
        public Pokemon([NotNull] BattleLibrary library, [NotNull] Species species, [NotNull] Forme forme,
            byte level, uint experience, uint uid,
            Gender gender, byte coloring, [MaybeNull] Item heldItem, [MaybeNull] string nickname, bool hiddenAbility,
            byte abilityIndex,
            [NotNull] IReadOnlyCollection<LearnedMove> moves, StatisticSet<byte> ivs, StatisticSet<byte> evs,
            [NotNull] Nature nature)
            : base(Pkmnlib.Generated.Pokemon.Construct(
                library.Ptr, species.Ptr, forme.Ptr, level, experience,
                uid, (Pkmnlib.Gender) gender, coloring, heldItem?.Ptr ?? IntPtr.Zero, nickname.ToPtr(),
                hiddenAbility.ToNative(), abilityIndex,
                moves.Select(x => x?.Ptr ?? IntPtr.Zero).ToArray().ArrayPtr(),
                (ulong) moves.Count,
                ivs.HP, ivs.Attack, ivs.Defense, ivs.SpecialAttack,
                ivs.SpecialDefense, ivs.Speed, evs.HP, evs.Attack, evs.Defense,
                evs.SpecialAttack, evs.SpecialDefense, evs.Speed, nature.Ptr))
        {
            Library = library;
        }

        public BattleLibrary Library { get; }
        public Species Species
        {
            get
            {
                if (_species != null) return _species;
                var ptr = Creaturelibbattling.Generated.Creature.GetSpecies(Ptr);
                if (TryResolvePointer(ptr, out _species))
                    return _species;
                _species = new Species(ptr);
                return _species;
            }
        }
        public Forme Forme
        {
            get
            {
                if (_forme != null) return _forme;
                var ptr = Creaturelibbattling.Generated.Creature.GetVariant(Ptr);
                if (TryResolvePointer(ptr, out _forme))
                    return _forme;
                _forme = new Forme(ptr);
                return _forme;
            }
        }
        public byte Level => Creaturelibbattling.Generated.Creature.GetLevel(Ptr);
        public uint Experience => Creaturelibbattling.Generated.Creature.GetExperience(Ptr);
        public Gender Gender => (Gender) Creaturelibbattling.Generated.Creature.GetGender(Ptr);
        public byte Coloring => Creaturelibbattling.Generated.Creature.GetColoring(Ptr);
        public bool IsShiny => Coloring == 1;
        public uint CurrentHealth => Creaturelibbattling.Generated.Creature.GetCurrentHealth(Ptr);
        public uint MaxHealth => Creaturelibbattling.Generated.Creature.GetMaxHealth(Ptr);

        public string ActiveAbility
        {
            get
            {
                var ptr = IntPtr.Zero;
                Creaturelibbattling.Generated.Creature.GetActiveTalent(Ptr, ref ptr).Assert();
                return ptr.PtrString();
            }
        }

        // TODO: Change to wrapped
        public IntPtr Battle => Creaturelibbattling.Generated.Creature.GetBattle(Ptr);
        // TODO: Change to wrapped
        public IntPtr BattleSide => Creaturelibbattling.Generated.Creature.GetBattleSide(Ptr);
        public bool IsOnBattleField => Creaturelibbattling.Generated.Creature.IsOnBattleField(Ptr) == 1;

        public Item HeldItem
        {
            get
            {
                var ptr = Creaturelibbattling.Generated.Creature.GetHeldItem(Ptr);
                if (ptr == IntPtr.Zero) return null;
                if (!TryResolvePointer(ptr, out Item item))
                {
                    item = new Item(ptr);
                }
                return item;
            }
            set =>
                Creaturelibbattling.Generated.Creature.SetHeldItemFromItem(Ptr,
                    value?.Ptr ?? IntPtr.Zero);
        }

        public string Nickname
        {
            get
            {
                if (_nickname != null) return _nickname;
                _nickname = Creaturelibbattling.Generated.Creature.GetNickname(Ptr).PtrString();
                return _nickname;
            }
        }

        public void ChangeForme(Forme forme)
        {
            _forme = null;
            Creaturelibbattling.Generated.Creature.ChangeVariant(Ptr, forme.Ptr);
        }

        public bool HasHeldItem(string itemName)
        {
            return Creaturelibbattling.Generated.Creature.HasHeldItem(Ptr, itemName.ToPtr()) == 1;
        }

        public void SetHeldItem(string item)
        {
            if (string.IsNullOrEmpty(item))
                Creaturelibbattling.Generated.Creature.SetHeldItemFromItem(Ptr, IntPtr.Zero);
            else
                Creaturelibbattling.Generated.Creature.SetHeldItem(Ptr, item.ToPtr());
        }

        public bool HasType(string type)
        {
            var typeByte = Library.StaticLibrary.TypeLibrary.GetTypeId(type);
            return Creaturelibbattling.Generated.Creature.HasType(Ptr, typeByte) == 1;
        }

        public void ChangeLevelBy(sbyte amount)
        {
            Creaturelibbattling.Generated.Creature.ChangeLevelBy(Ptr, amount).Assert();
        }

        public void AddExperience(uint experience)
        {
            Creaturelibbattling.Generated.Creature.AddExperience(Ptr, experience).Assert();
        }

        public void Damage(uint damage, DamageSource source)
        {
            Creaturelibbattling.Generated.Creature.Damage(Ptr, damage, (Creaturelibbattling.DamageSource) source);
        }
        
        public void Heal(uint damage, bool canRevive)
        {
            Creaturelibbattling.Generated.Creature.Heal(Ptr, damage, canRevive.ToNative());
        }

        public void OverrideActiveAbility(string ability)
        {
            Creaturelibbattling.Generated.Creature.OverrideActiveTalent(Ptr, ability.ToPtr()).Assert();
        }

        public void ClearVolatileScripts()
        {
            Creaturelibbattling.Generated.Creature.ClearVolatileScripts(Ptr).Assert();
        }

        public void AddVolatileScript(string scriptName)
        {
            Creaturelibbattling.Generated.Creature.AddVolatileScriptByName(Ptr, scriptName.ToPtr()).Assert();
        }
        
        //TODO: Change to wrapper
        public void AddVolatileScript(IntPtr script)
        {
            Creaturelibbattling.Generated.Creature.AddVolatileScript(Ptr, script).Assert();
        }
        
        public void RemoveVolatileScript(string scriptName)
        {
            Creaturelibbattling.Generated.Creature.RemoveVolatileScriptByName(Ptr, scriptName.ToPtr()).Assert();
        }
        
        //TODO: Change to wrapper
        public void RemoveVolatileScript(IntPtr script)
        {
            Creaturelibbattling.Generated.Creature.RemoveVolatileScript(Ptr, script).Assert();
        }

        public bool HasVolatileScript(string scriptName)
        {
            return Creaturelibbattling.Generated.Creature.HasVolatileScript(Ptr, scriptName.ToPtr()) == 1;
        }
        
        



        private Species _species;
        private Forme _forme;
        private string _nickname;


        protected override void DeletePtr()
        {
            Pkmnlib.Generated.Pokemon.Destruct(Ptr);
        }
    }
}