using PkmnLib.Static.Utils;

namespace PkmnLib.Dynamic.Models;

/// <summary>
/// A battle party is a wrapper around a Pokemon party that provides additional functionality for battles.
/// It indicates for which side and position the party is responsible, and holds the battle-scoped
/// <see cref="IBattlePokemon"/> wrappers for the party's Pokémon.
/// </summary>
public interface IBattleParty : IDeepCloneable
{
    /// <summary>
    /// The backing Pokemon party. Battle code should generally use <see cref="BattlePokemon"/> instead, as that
    /// view contains the battle-scoped wrappers.
    /// </summary>
    IPokemonParty Party { get; }

    /// <summary>
    /// The battle-scoped view of the party. Index-aligned with <see cref="Party"/>. Only available after
    /// <see cref="Initialize"/> has been called by the battle.
    /// </summary>
    IReadOnlyList<IBattlePokemon?> BattlePokemon { get; }

    /// <summary>
    /// Gets the battle-scoped wrapper for a Pokémon in this party. Returns null if the Pokémon is not in this
    /// party. Accepts either the underlying Pokémon or the wrapper itself.
    /// </summary>
    IBattlePokemon? GetBattlePokemon(IPokemon pokemon);

    /// <summary>
    /// Initializes the battle-scoped wrappers for this party. This is called by the battle when it is created,
    /// and should not be called by user code.
    /// </summary>
    void Initialize(IBattle battle);

    /// <summary>
    /// Whether the party is responsible for the specified side and position.
    /// </summary>
    bool IsResponsibleForIndex(ResponsibleIndex index);

    /// <summary>
    /// Whether the party has a living Pokemon left that is not in the field.
    /// </summary>
    bool HasUsablePokemonNotInField();

    /// <summary>
    /// Gets all usable Pokemon that are not currently in the field.
    /// </summary>
    IEnumerable<IBattlePokemon> GetUsablePokemonNotInField();
}

/// <summary>
/// A position on the battlefield that a party is responsible for.
/// Contains the index of the side and the position on that side.
/// </summary>
public record struct ResponsibleIndex(byte Side, byte Position);

/// <inheritdoc />
public class BattlePartyImpl : IBattleParty
{
    private readonly ResponsibleIndex[] _responsibleIndices;
    private IBattlePokemon?[] _battlePokemon = [];
    private IBattle? _battle;

    /// <inheritdoc cref="BattlePartyImpl"/>
    public BattlePartyImpl(IPokemonParty party, ResponsibleIndex[] responsibleIndices)
    {
        Party = party;
        _responsibleIndices = responsibleIndices;
    }

    /// <inheritdoc />
    public IPokemonParty Party { get; }

    /// <inheritdoc />
    public IReadOnlyList<IBattlePokemon?> BattlePokemon => _battlePokemon;

    /// <inheritdoc />
    public IBattlePokemon? GetBattlePokemon(IPokemon pokemon) =>
        _battlePokemon.FirstOrDefault(x => x != null && (x == pokemon || x.UnderlyingPokemon == pokemon));

    /// <inheritdoc />
    public void Initialize(IBattle battle)
    {
        if (_battle != null)
            throw new InvalidOperationException("This battle party has already been initialized for a battle.");
        if (_responsibleIndices.Length == 0)
            throw new InvalidOperationException("A battle party must be responsible for at least one position.");
        var sideIndex = _responsibleIndices[0].Side;
        if (_responsibleIndices.Any(x => x.Side != sideIndex))
            throw new InvalidOperationException("A battle party can only be responsible for a single side.");

        _battle = battle;
        _battlePokemon = new IBattlePokemon?[Party.Count];
        for (var i = 0; i < Party.Count; i++)
        {
            var pokemon = Party[i];
            if (pokemon != null)
                _battlePokemon[i] = new BattlePokemonImpl(pokemon, battle, sideIndex);
        }

        Party.OnSwapInto += (_, args) =>
        {
            var (pokemon, index) = args;
            _battlePokemon[index] = pokemon == null ? null : new BattlePokemonImpl(pokemon, battle, sideIndex);
        };
        Party.OnSwap += (_, args) =>
        {
            var (index1, index2) = args;
            (_battlePokemon[index1], _battlePokemon[index2]) = (_battlePokemon[index2], _battlePokemon[index1]);
        };
    }

    /// <inheritdoc />
    public bool IsResponsibleForIndex(ResponsibleIndex index) => _responsibleIndices.Contains(index);

    /// <inheritdoc />
    public bool HasUsablePokemonNotInField() =>
        _battlePokemon.WhereNotNull().Any(x => x.IsUsable && !x.IsOnBattlefield);

    /// <inheritdoc />
    public IEnumerable<IBattlePokemon> GetUsablePokemonNotInField() =>
        _battlePokemon.WhereNotNull().Where(x => x.IsUsable && !x.IsOnBattlefield);
}