using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml.Linq;
using System.Security.Cryptography;
using System.Collections;

namespace QwirkleClassLibrary
{

    public class Game : IPlayer, IRules
    {
        public ReadOnlyDictionary<Player, int> ScoreBoard => scoreBoard.AsReadOnly();
        private readonly Dictionary<Player, int> scoreBoard = new();
        
        private TileBag bag;
        public bool GameRunning { get; private set; }
        private Board board;

        public ReadOnlyCollection<Player> PlayerList => players.AsReadOnly();
        private readonly List<Player> players = new();

        public ReadOnlyCollection<Cell> CellsUsed => cellUsed.AsReadOnly();
        private readonly List<Cell> cellUsed = new();

        public event EventHandler<AddPlayerNotifiedEventArgs>? PlayerAddNotified;

        protected virtual void OnPlayerNotified(AddPlayerNotifiedEventArgs args)
            => PlayerAddNotified?.Invoke(this, args);

        public event EventHandler<NextPlayerNotifiedEventArgs>? NextPlayerNotified;

        protected virtual void OnNextPlayer(NextPlayerNotifiedEventArgs args)
            => NextPlayerNotified?.Invoke(this, args);

        public event EventHandler<PlaceTileNotifiedEventArgs>? PlaceTileNotified;

        protected virtual void OnPlaceTile(PlaceTileNotifiedEventArgs args)
            => PlaceTileNotified?.Invoke(this, args);

        public Game()
        {
            bag = CreateTileBag(3);
            board = CreateBoard();

        }

        public bool AddPlayerInGame(string? playerTag)
        {
            if (string.IsNullOrWhiteSpace(playerTag))
            {
                OnPlayerNotified(new AddPlayerNotifiedEventArgs("ERROR : The name is null or white space."));
                return false;
            }

            if(this.GameRunning)
            {
                OnPlayerNotified(new AddPlayerNotifiedEventArgs("ERROR : The game is running."));
                return false;
            }

            if (players.Count >= 4)
            {
                OnPlayerNotified(new AddPlayerNotifiedEventArgs("ERROR : The game is full."));
                return false;
            }

            foreach (var p in players)
            {
                if (p.NameTag == playerTag)
                {
                    OnPlayerNotified(new AddPlayerNotifiedEventArgs("ERROR : Name alreay taken"));
                    return false;
                }

            }

            players.Add(CreatePlayer(playerTag));
            OnPlayerNotified(new AddPlayerNotifiedEventArgs("Player was correctly added"));
            return true;
        }

        public Player CreatePlayer(string playerTag)
        {
            var player = new Player(playerTag);

            return player;
        }

        public Board GetBoard() { return board; }

        public Board CreateBoard()
        {
            board = new Board(8, 8);
            return board;
        }
        
        public TileBag CreateTileBag(int nbSet)
        {
            bag = new TileBag(nbSet);
            return bag;
        }

        public bool StartGame()
        {
            if (players.Count < 2 || players.Count >= 5) return false;
            this.GameRunning = true;
            return true;
        }
        
        public void AddCellUsed(Cell? c)
        {
            if (c != null) cellUsed.Add(c);
        }
        
        public void EmptyCellUsed()
        {
            cellUsed.Clear();
        }
        
        public Player GetPlayingPlayer()
        {
            if(GetPlayingPlayerPosition() == -1)
            {
                throw new ArgumentException("No player play.");
            }
            return players[GetPlayingPlayerPosition()];
        }

        public int GetPlayingPlayerPosition()
        {
            for (int i = 0; i < players.Count; i++)
            {
                if (players[i].IsPlaying)
                {
                    return i;
                }
            }
            return -1;
        }

        public Tile TileOfPlayerWithPos(int postile)
        {
            return players[GetPlayingPlayerPosition()].Tiles[postile];
        }

        public void GiveTilesToPlayers()
        {
            foreach (var p in players)
            {
                for (int j = 0; j < 6; j++)
                {
                    int val = RandomNumberGenerator.GetInt32(0, bag.TilesBag.Count);

                    p.AddTileToPlayer(bag.TilesBag[val]);
                    bag.RemoveTileInBag(bag.TilesBag[val]);
                }
            }
        }

        public string SetFirstPlayer()
        {
            if (GameRunning)
            {
                players[0].IsPlaying = true;
                OnNextPlayer(new NextPlayerNotifiedEventArgs(players[0]));
                return players[0].NameTag;
            }
            else
            {
                throw new ArgumentException("Game is not running");
            }

        }

        public string SetNextPlayer()
        {
            int i = GetPlayingPlayerPosition();

            if (i == -1)
            {
                return SetFirstPlayer();
            }

            players[i].IsPlaying = false;
            players[(i + 1) % players.Count].IsPlaying = true;
            OnNextPlayer(new NextPlayerNotifiedEventArgs(players[i]));

            return players[GetPlayingPlayerPosition()].NameTag;
        }

        public bool PlaceTile(Player player, Tile tile, int x, int y)
        {
            if (board.AddTileInCell(x, y, tile))
            {
                return player.RemoveTileToPlayer(tile);
            }
            else
            {
                return false;
            }
        }
        
        
        /// <summary>
        /// Allows a player to draw tiles from the bag as soon as he has less than 6 tiles
        /// </summary>
        /// <param name="player"></param>
        /// <returns></returns>
        public bool DrawTiles(Player player)
        {
            while(player.Tiles.Count < 6)
            {
                if (bag.TilesBag.Count == 0)
                {
                    return false;
                }

                int val = RandomNumberGenerator.GetInt32(0, bag.TilesBag.Count + 1);
                
                player.AddTileToPlayer(bag.TilesBag[val]);
                bag.RemoveTileInBag(bag.TilesBag[val]);
            }
            
            return true;
        }

        public bool SwapTiles(Player player, List<Tile> tilesToSwap)
        {
            if (tilesToSwap.Count == 0)
            {
                return false;
            }

            foreach (var t in tilesToSwap)
            {
                if (player.RemoveTileToPlayer(t) == false)
                {
                    return false;
                }
            }

            if (DrawTiles(player) == false)
            {
                return false;
            }

            foreach (var t in tilesToSwap)
            {
                bag.AddTileInBag(t);
            }

            return true;
        }

        /*        public bool CheckExtendedSurroundingCells(Tile tile, int x, int y, int dx, int dy, Board b)
                {
                    for (int i = 1; i < 7; i++)
                    {
                        var extendedCell = b.GetCell(x + i * dx, y + i * dy);

                        if (extendedCell?.GetTile == null)
                        {
                            break;
                        }

                        if (extendedCell.GetTile.GetColor != tile.GetColor && extendedCell.GetTile.GetShape != tile.GetShape)
                        {
                            OnPlaceTile(new PlaceTileNotifiedEventArgs(tile, "Color / Shape does not match with the surrounding tiles !"));
                            return false;
                        }

                        if (i == 6)
                        {
                            OnPlaceTile(new PlaceTileNotifiedEventArgs(tile, "Row/Column already 6 tiles long !"));
                            return false;
                        }
                    }

                    if (this.PlaceTile(this.GetPlayingPlayer(), tile, x, y))
                    {
                        this.AddCellUsed(this.GetBoard().GetCell(x, y));
                        OnPlaceTile(new PlaceTileNotifiedEventArgs(tile, "Tile correctement placé"));
                        return true;
                    }
                    return false;
                }*/

        public bool CheckExtendedSurroundingCells(Tile tile, int x, int y, int dx, int dy, Board b)
        {
            for (int i = 1; i < 7; i++)
            {
                var extendedCell = b.GetCell(x + i * dx, y + i * dy);

                if (extendedCell?.GetTile == null)
                {
                    break;
                }

                if (extendedCell.GetTile.GetColor != tile.GetColor && extendedCell.GetTile.GetShape != tile.GetShape)
                {
                    return false;
                }

                if (i == 6)
                {
                    return false;
                }
            }

            return true;
        }

        public bool CheckTilesInLine(List<Cell> cells, Board b, int x, int y)
        {
            if(cells.Count < 2)
            {
                return true;
            }
            
            var x1 = cells[0].GetX;
            var y1 = cells[0].GetY;
            var x2 = cells[1].GetX;
            var y2 = cells[1].GetY;

            if (x1 == x2)
            {
                return x == x1;
            }
            if (y1 == y2)
            {
                return y == y1;
            }

            return false;
        }

        /*public bool IsMoveCorrect(Tile t, int x, int y, Board b)
        {
            if (!b.HasOccupiedCase())
            {
                    return true;
            }

            var surroundingCells = new List<Cell?>
            {
                b.GetCell(x + 1, y),
                b.GetCell(x - 1, y),
                b.GetCell(x, y + 1),
                b.GetCell(x, y - 1)
            };

            foreach (var cell in surroundingCells)
            {
                if (cell?.GetTile == null)
                {
                    continue;
                }
                
                if (cell.GetTile.GetColor != t.GetColor && cell.GetTile.GetShape != t.GetShape)
                {
                    OnPlaceTile(new PlaceTileNotifiedEventArgs(t, "Tile ne correspond pas au bonne couleur des tiles a coté"));
                    return false;
                }   

                var dx = cell.GetX - x;
                var dy = cell.GetY - y;
                
                return CheckExtendedSurroundingCells(t, x, y, dx, dy, b);
            }

            if (CheckTilesInLine(this.cellUsed, b, x, y) && surroundingCells.Any(cell => cell?.GetTile != null))
            {
                if(this.PlaceTile(this.GetPlayingPlayer(), t, x, y))
                {
                    this.AddCellUsed(this.GetBoard().GetCell(x, y));
                    OnPlaceTile(new PlaceTileNotifiedEventArgs(t, "Tile correctement placé"));
                    return true;
                }
                OnPlaceTile(new PlaceTileNotifiedEventArgs(t, "Cell Already use"));
            }
            OnPlaceTile(new PlaceTileNotifiedEventArgs(t, "La tuile n'a pu etre placé"));
            return false;
        } */

        public bool IsMoveCorrect(Tile t, int x, int y, Board b)
        {
            if (!b.HasOccupiedCase())
            {
                return true;
            }

            var surroundingCells = new List<Cell?>
            {
                b.GetCell(x + 1, y),
                b.GetCell(x - 1, y),
                b.GetCell(x, y + 1),
                b.GetCell(x, y - 1)
            };

            foreach (var cell in surroundingCells)
            {
                if (cell?.GetTile == null)
                {
                    continue;
                }

                if (cell.GetTile.GetColor != t.GetColor && cell.GetTile.GetShape != t.GetShape)
                {
                    return false;
                }

                var dx = cell.GetX - x;
                var dy = cell.GetY - y;

                if (CheckExtendedSurroundingCells(t, x, y, dx, dy, b) == false)
                {
                    return false;
                }
            }

            return CheckTilesInLine(this.cellUsed, b, x, y) && surroundingCells.Any(cell => cell?.GetTile != null);
        }

        public int GetPlayerScore(Player player, ReadOnlyCollection<Cell> cellsPlayed, Board b)
        {
            int score = cellsPlayed.Count;

            foreach (var cell in cellsPlayed)
            {
                score += CalculateAdjacentScore(cell, b, cellsPlayed);
            }

            
            if(scoreBoard.TryAdd(player, score) == false)
            {
                scoreBoard[player] += score;
            }

            return score;
        }

        private int CalculateAdjacentScore(Cell cell, Board b, ReadOnlyCollection<Cell> cellsPlayed)
        {
            int score = 0;

            var surroundingCells = new[]
            {
                b.GetCell(cell.GetX + 1, cell.GetY),
                b.GetCell(cell.GetX - 1, cell.GetY),
                b.GetCell(cell.GetX, cell.GetY + 1),
                b.GetCell(cell.GetX, cell.GetY - 1)
            };

            foreach (var adjacentCell in surroundingCells)
            {
                if (adjacentCell?.GetTile == null || cellsPlayed.Contains(adjacentCell))
                {
                    continue;
                }

                int dx = adjacentCell.GetX - cell.GetX;
                int dy = adjacentCell.GetY - cell.GetY;

                score += CalculateLineScore(cell, dx, dy, b);
            }

            return score;
        }

        private int CalculateLineScore(Cell cell, int dx, int dy, Board b)
        {
            int score = 0;

            for (int i = 1; i < b.Rows; i++)
            {
                var extendedCell = b.GetCell(cell.GetX + i * dx, cell.GetY + i * dy);

                if (extendedCell?.GetTile == null)
                {
                    break;
                }

                score++;
            }

            return score;
        }


        public bool IsGameOver()
        {
            return true;
        }
    }
}