using System.Collections.ObjectModel;
using Shogi.Domain.YetToBeAssimilatedIntoDDD;
using BoardTile = System.Collections.Generic.KeyValuePair<System.Numerics.Vector2, Shogi.Domain.ValueObjects.Piece>;

namespace Shogi.Domain.ValueObjects;

public class BoardState
{
    /// <summary>
    /// Board state before any moves have been made, using standard setup and rules.
    /// </summary>
    public static BoardState StandardStarting => new(
        state: BuildStandardStartingBoardState(),
        player1Hand: new(),
        player2Hand: new(),
        whoseTurn: WhichPlayer.Player1,
        playerInCheck: null,
        previousMove: new Move());

    /// <summary>
    /// Key is position notation, such as "E4".
    /// </summary>
    private readonly Dictionary<string, Piece?> board;

    public BoardState(
        Dictionary<string, Piece?> state,
        List<Piece> player1Hand,
        List<Piece> player2Hand,
        WhichPlayer whoseTurn,
        WhichPlayer? playerInCheck,
        Move previousMove)
    {
        board = state;
        Player1Hand = player1Hand;
        Player2Hand = player2Hand;
        PreviousMove = previousMove;
        WhoseTurn = whoseTurn;
        InCheck = playerInCheck;
    }

    /// <summary>
    /// Copy constructor.
    /// </summary>
    public BoardState(BoardState other)
    {
        board = new(81);
        foreach (var kvp in other.board)
        {
            var piece = kvp.Value;
            board[kvp.Key] = piece == null ? null : Piece.Create(piece.WhichPiece, piece.Owner, piece.IsPromoted);
        }
        WhoseTurn = other.WhoseTurn;
        InCheck = other.InCheck;
        IsCheckmate = other.IsCheckmate;
        PreviousMove = other.PreviousMove;
        Player1Hand = new(other.Player1Hand);
        Player2Hand = new(other.Player2Hand);
    }

    public ReadOnlyDictionary<string, Piece?> State => new(board);
    public List<Piece> ActivePlayerHand => WhoseTurn == WhichPlayer.Player1 ? Player1Hand : Player2Hand;
    public Vector2 Player1KingPosition => Notation.FromBoardNotation(board.Where(kvp => kvp.Value != null).Single(kvp =>
    {
        var piece = kvp.Value;
        return piece!.IsKing() && piece!.Owner == WhichPlayer.Player1;
    }).Key);
    public Vector2 Player2KingPosition => Notation.FromBoardNotation(board.Where(kvp => kvp.Value != null).Single(kvp =>
    {
        var piece = kvp.Value;
        return piece!.IsKing() && piece!.Owner == WhichPlayer.Player2;
    }).Key);
    public List<Piece> Player1Hand { get; }
    public List<Piece> Player2Hand { get; }
    public Move PreviousMove { get; set; }
    public WhichPlayer WhoseTurn { get; set; }
    public WhichPlayer? InCheck { get; set; }
    public bool IsCheckmate { get; set; }

    public Piece? this[string notation]
    {
        // TODO: Validate "notation" here and throw an exception if invalid.
        get => board[notation];
        set => board[notation] = value;
    }

    public Piece? this[Vector2 vector]
    {
        get => this[Notation.ToBoardNotation(vector)];
        set => this[Notation.ToBoardNotation(vector)] = value;
    }

    public Piece? this[int x, int y]
    {
        get => this[Notation.ToBoardNotation(x, y)];
        set => this[Notation.ToBoardNotation(x, y)] = value;
    }

    /// <summary>
    /// Returns true if the given path can be traversed without colliding into a piece.
    /// </summary>
    public bool IsPathBlocked(IEnumerable<Vector2> path)
    {
        return !path.Any()
        || path.SkipLast(1).Any(position => this[position] != null)
        || this[path.Last()]?.Owner == WhoseTurn;
    }

    internal bool IsWithinPromotionZone(Vector2 position)
    {
        // TODO: Move this promotion zone logic into the StandardRules class.
        return WhoseTurn == WhichPlayer.Player1 && position.Y > 5
        || WhoseTurn == WhichPlayer.Player2 && position.Y < 3;
    }

    internal static bool IsWithinBoardBoundary(Vector2 position)
    {
        return position.X <= 8 && position.X >= 0
            && position.Y <= 8 && position.Y >= 0;
    }

    internal List<BoardTile> GetTilesOccupiedBy(WhichPlayer whichPlayer) => board
        .Where(kvp => kvp.Value?.Owner == whichPlayer)
        .Select(kvp => new BoardTile(Notation.FromBoardNotation(kvp.Key), kvp.Value!))
        .ToList();

    internal void Capture(Vector2 to)
    {
        var piece = this[to];
        if (piece == null) throw new InvalidOperationException("Cannot capture. Piece at position does not exist.");

        piece.Capture(WhoseTurn);
        ActivePlayerHand.Add(piece);
    }

    /// <summary>
    /// Does not include the start position.
    /// </summary>
    internal static IEnumerable<Vector2> GetPathAlongDirectionFromStartToEdgeOfBoard(Vector2 start, Vector2 direction)
    {
        var next = start;
        while (IsWithinBoardBoundary(next + direction))
        {
            next += direction;
            yield return next;
        }
    }

    internal Piece? QueryFirstPieceInPath(IEnumerable<Vector2> path)
    {
        foreach (var step in path)
        {
            if (this[step] != null) return this[step];
        }
        return null;
    }

    private static Dictionary<string, Piece?> BuildStandardStartingBoardState()
    {
        return new Dictionary<string, Piece?>(81)
        {
            ["A1"] = new Lance(WhichPlayer.Player1),
            ["B1"] = new Knight(WhichPlayer.Player1),
            ["C1"] = new SilverGeneral(WhichPlayer.Player1),
            ["D1"] = new GoldGeneral(WhichPlayer.Player1),
            ["E1"] = new King(WhichPlayer.Player1),
            ["F1"] = new GoldGeneral(WhichPlayer.Player1),
            ["G1"] = new SilverGeneral(WhichPlayer.Player1),
            ["H1"] = new Knight(WhichPlayer.Player1),
            ["I1"] = new Lance(WhichPlayer.Player1),

            ["A2"] = null,
            ["B2"] = new Bishop(WhichPlayer.Player1),
            ["C2"] = null,
            ["D2"] = null,
            ["E2"] = null,
            ["F2"] = null,
            ["G2"] = null,
            ["H2"] = new Rook(WhichPlayer.Player1),
            ["I2"] = null,

            ["A3"] = new Pawn(WhichPlayer.Player1),
            ["B3"] = new Pawn(WhichPlayer.Player1),
            ["C3"] = new Pawn(WhichPlayer.Player1),
            ["D3"] = new Pawn(WhichPlayer.Player1),
            ["E3"] = new Pawn(WhichPlayer.Player1),
            ["F3"] = new Pawn(WhichPlayer.Player1),
            ["G3"] = new Pawn(WhichPlayer.Player1),
            ["H3"] = new Pawn(WhichPlayer.Player1),
            ["I3"] = new Pawn(WhichPlayer.Player1),

            ["A4"] = null,
            ["B4"] = null,
            ["C4"] = null,
            ["D4"] = null,
            ["E4"] = null,
            ["F4"] = null,
            ["G4"] = null,
            ["H4"] = null,
            ["I4"] = null,

            ["A5"] = null,
            ["B5"] = null,
            ["C5"] = null,
            ["D5"] = null,
            ["E5"] = null,
            ["F5"] = null,
            ["G5"] = null,
            ["H5"] = null,
            ["I5"] = null,

            ["A6"] = null,
            ["B6"] = null,
            ["C6"] = null,
            ["D6"] = null,
            ["E6"] = null,
            ["F6"] = null,
            ["G6"] = null,
            ["H6"] = null,
            ["I6"] = null,

            ["A7"] = new Pawn(WhichPlayer.Player2),
            ["B7"] = new Pawn(WhichPlayer.Player2),
            ["C7"] = new Pawn(WhichPlayer.Player2),
            ["D7"] = new Pawn(WhichPlayer.Player2),
            ["E7"] = new Pawn(WhichPlayer.Player2),
            ["F7"] = new Pawn(WhichPlayer.Player2),
            ["G7"] = new Pawn(WhichPlayer.Player2),
            ["H7"] = new Pawn(WhichPlayer.Player2),
            ["I7"] = new Pawn(WhichPlayer.Player2),

            ["A8"] = null,
            ["B8"] = new Rook(WhichPlayer.Player2),
            ["C8"] = null,
            ["D8"] = null,
            ["E8"] = null,
            ["F8"] = null,
            ["G8"] = null,
            ["H8"] = new Bishop(WhichPlayer.Player2),
            ["I8"] = null,

            ["A9"] = new Lance(WhichPlayer.Player2),
            ["B9"] = new Knight(WhichPlayer.Player2),
            ["C9"] = new SilverGeneral(WhichPlayer.Player2),
            ["D9"] = new GoldGeneral(WhichPlayer.Player2),
            ["E9"] = new King(WhichPlayer.Player2),
            ["F9"] = new GoldGeneral(WhichPlayer.Player2),
            ["G9"] = new SilverGeneral(WhichPlayer.Player2),
            ["H9"] = new Knight(WhichPlayer.Player2),
            ["I9"] = new Lance(WhichPlayer.Player2)
        };
    }
}