using Giants.Core.Enums;
using Giants.Core.Exceptions;

namespace Giants.Core.Commands;

public class PrepareMatchCommand : BaseMatchCommand<PrepareMatchResult>
{
    public required IList<int> PlayerIDs { get; init; }

    protected override PrepareMatchResult LocalMatchExecute(Match match)
    {
        if (PlayerIDs.Count < 3 || PlayerIDs.Count > 5 || null == match)
            return new PrepareMatchResult();


        //Gestion des assets des joueurs
        for (int itePlayer = 0; itePlayer < PlayerIDs.Count; itePlayer++)
        {
            match.SetPlayer(itePlayer, PlayerIDs[itePlayer]);
            Player? player = match.GetPlayer(itePlayer);
            if (null == player)
                throw new ArgumentException($"Cannot get player {itePlayer} in PrepareMatchCommand");

            //socles 
            int nbSocle = NbSoclePerPlayer(PlayerIDs.Count);
            foreach (var socle in player.Bases)
            {
                if (nbSocle > 0)
                {
                    player.PutPieceInHiddenArea(socle);
                    nbSocle--;
                }
                else
                {
                    break;
                }
            }


            //marqueurs tribaux (on ajoute 2 par joueurs et le reste dans l'urne)
            int i = 0;
            foreach (var marker in player.Markers)
            {
                if (i < 2)
                {
                    player.PutPieceInHiddenArea(marker);
                }
                else
                {
                    match.AssignPiece(marker, PiecePosition.Urne);
                }
                i++;
            }

            //assigner les ouvriers (1 chef, 1 shaman et 1 worker chacun)
            match.AssignPiece(player.Chef, player.HiddenPosition);
            match.AssignPiece(player.Shaman, player.HiddenPosition);
            int nbWorker = 1;
            foreach (PieceIndex worker in player.Workers)
            {
                if (nbWorker > 0)
                {
                    match.AssignPiece(worker, player.HiddenPosition);
                    nbWorker--;
                }
                else
                {
                    match.AssignPiece(worker, PiecePosition.Urne);
                }
            }
            match.AssignPiece(player.Workers.First(), player.HiddenPosition);

            //score a zero
            for (int iteScore = 0; iteScore < match.NbPlayer; iteScore++)
            {
                match.SetScore(iteScore, 0);
            }

            //choix d'un 1er joueur

            Player? firstPlayer = match.GetPlayer(Random.Next(match.NbPlayer));
            if (null == firstPlayer)
                throw new InitialisationException("Cannot select first player, indexOutOfRange");
            match.AssignPiece(PieceIndex.StartPlayer, firstPlayer.VisiblePosition);


        }
        return new PrepareMatchResult()
        {
            Success = true,
            Match = match
        };
    }

    private static int NbSoclePerPlayer(int nbTotalPlayer)
    {
        return nbTotalPlayer switch
        {
            3 => 7,
            4 => 6,
            5 => 5,
            _ => throw new DataConversionException("Wrong player count for NbMarkerPerPlayer")
        };
    }
}

public class PrepareMatchResult : BaseCommandResult
{
    public Match? Match { get; init; }
}