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;

namespace QwirkleClassLibrary
{
    public class Game : IPlayer, IRules
    {
        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<Score> ScoreList => scores.AsReadOnly();
        private readonly List<Score> scores = new();

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

        public bool AddPlayerInGame(string? playerTag)
        {
            if (string.IsNullOrWhiteSpace(playerTag) == true || this.GameRunning == true)
            {
                return false;
            }

            if (players.Count >= 4)
            {
                return false;
            }

            foreach (var p in players)
            {
                if (p.NameTag == playerTag)
                {
                    return false;
                }
            }

            players.Add(CreatePlayer(playerTag));
            scores.Add(new Score(players[players.Count - 1]));

            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 Player GetPlayingPlayer()
        {
            if(GetPlayingPlayerPosition() == -1)
            {
                throw new ArgumentException();
            }
            return players[GetPlayingPlayerPosition()];
        }

        public int GetPlayingPlayerPosition()
        {
            for (int i = 0; i < players.Count; i++)
            {
                if (players[i].IsPlaying == true)
                {
                    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 == true)
            {
                players[0].IsPlaying = true;
                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;

            return players[GetPlayingPlayerPosition()].NameTag;
        }

        public bool PlaceTile(Player player, Tile tile, int x, int y)
        {
            if (board.AddTileInCell(x, y, tile) == true)
            {
                return player.RemoveTileToPlayer(tile) == true;
            }
            else
            {
                return false;
            }
        }
        
        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 IsMoveCorrect(Tile t, int x, int y, Board b)
        // {
        //     if (b.HasOccupiedCase() == false)
        //     {
        //         return true;
        //     }
        //
        //     var surroundingCells = new List<Cell?>();
        //
        //     surroundingCells.Add(b.GetCell(x + 1, y));
        //     surroundingCells.Add(b.GetCell(x - 1, y));
        //     surroundingCells.Add(b.GetCell(x, y + 1));
        //     surroundingCells.Add(b.GetCell(x, y - 1));
        //     
        //     foreach (var cell in surroundingCells.ToList())
        //     {
        //         if (cell?.GetTile == null)
        //         {
        //             surroundingCells.Remove(cell);
        //             continue;
        //         }
        //         
        //         if (cell?.GetTile.GetColor != t.GetColor && cell?.GetTile.GetShape != t.GetShape)
        //         {
        //             return false;
        //         }
        //     }
        //
        //     if(surroundingCells.Count == 0) return false;
        //     
        //     foreach (var cell in surroundingCells.ToList())
        //     {
        //         var extendedCells = new List<Cell?>();
        //
        //         if (cell?.GetX == x && cell?.GetY == y + 1)
        //         {
        //             for (int i = 1; i < 7; i++)
        //             {
        //                 if (b.GetCell(x, y + i)?.GetTile != null)
        //                 {
        //                     extendedCells.Add(b.GetCell(x, y + i));
        //                 }
        //             }
        //         }
        //         
        //         else if (cell?.GetX == x && cell?.GetY == y - 1)
        //         {
        //             for (int i = 1; i < 7; i++)
        //             {
        //                 if (b.GetCell(x, y - i)?.GetTile != null)
        //                 {
        //                     extendedCells.Add(b.GetCell(x, y - i));
        //                 }
        //             }
        //         }
        //         
        //         else if (cell?.GetX == x + 1 && cell?.GetY == y)
        //         {
        //             for (int i = 1; i < 7; i++)
        //             {
        //                 if (b.GetCell(x + i, y)?.GetTile != null)
        //                 {
        //                     extendedCells.Add(b.GetCell(x + i, y));
        //                 }
        //             }
        //         }
        //         
        //         else if (cell?.GetX == x - 1 && cell?.GetY == y)
        //         {
        //             for (int i = 1; i < 7; i++)
        //             {
        //                 if (b.GetCell(x - i, y)?.GetTile != null)
        //                 {
        //                     extendedCells.Add(b.GetCell(x - i, y));
        //                 }
        //             }
        //         }
        //         
        //         foreach (var e in extendedCells)
        //         {
        //             if (e?.GetTile?.GetColor != t.GetColor && e?.GetTile?.GetShape != t.GetShape)
        //             {
        //                 return false;
        //             }
        //         }
        //         
        //         if (extendedCells.Count == 6)
        //         {
        //             return false;
        //         }
        //     }
        //     
        //     return true;
        // }

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

            var surroundingCells = new[]
            {
                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;

                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 != t.GetColor && extendedCell.GetTile.GetShape != t.GetShape)
                    {
                        return false;
                    }

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

            return surroundingCells.Any(cell => cell?.GetTile != null);
        }

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