using System;
using System.Collections.Generic;
using System.ComponentModel;
using TheGameExtreme.model.effect;
using TheGameExtreme.model.@event;

namespace TheGameExtreme.model.manager
{
    public abstract class GameManager
    {

        public readonly int nbPlayer;
        protected int nbMaxCard;
        protected int currentIndexPlayer;
        protected List<Player> playerList = new List<Player>();
        protected List<InfiniteEffect> infiniteEffectsConstraintsList = new List<InfiniteEffect>();
        public List<Stack<Card>> ListOrderedStacks { get; set; }
        protected List<Card> deck = new List<Card>();
        protected bool win = true;
        public event EventHandler<TopRangeChangedEventArgs> TopRangeChanged;
        public event EventHandler<PlayerChangedEventArgs> PlayerChanged;
        //public event EventHandler<CurrentPlayerChangedEventArgs> CurrentPlayerChanged;
        public List<Card> CurrentHand { get; set; }


        public GameManager(int nbPlayer, List<String> players)
        {
            ListOrderedStacks = new List<Stack<Card>>();
            CurrentHand = new List<Card>();

            this.nbPlayer = nbPlayer;
            players.ForEach(player => playerList.Add(new Player(player)));

            ListOrderedStacks.Add(new Stack<Card>());
            ListOrderedStacks.Add(new Stack<Card>());
            ListOrderedStacks.Add(new Stack<Card>());
            ListOrderedStacks.Add(new Stack<Card>());

            for (int i = 0; i < 4; i++)
            {
                if (i < 2)
                {
                    ListOrderedStacks[i].Push(new Card(1));
                }
                else
                {
                    ListOrderedStacks[i].Push(new Card(100));
                }
            }

            createDeck();
            defineNbMaxCard();
            distribueCard();

            CurrentHand = playerList[currentIndexPlayer].getCardList();
        }

        protected void createDeck()
        {
            for (int i = 2; i <= 99; i++)
            {
                deck.Add(new Card(i));
            }
            melangeDeck();
        }

        protected void melangeDeck()
        {
            Random random = new Random();
            int place1;
            int place2;
            Card tmp;

            for (int i = 0; i < 1000; i++)
            {
                place1 = random.Next(0, 98);
                place2 = random.Next(0, 98);

                tmp = deck[place1];
                deck[place1] = deck[place2];
                deck[place2] = tmp;
            }
        }

        protected void defineNbMaxCard()
        {
            switch (nbPlayer)
            {
                case 1:
                    nbMaxCard = 8;
                    break;
                case 2:
                    nbMaxCard = 7;
                    break;
                default:
                    nbMaxCard = 6;
                    break;
            }
        }

        protected void distribueCard()
        {
            for (int i = 0; i < nbMaxCard; i++)
            {
                playerList.ForEach(player => {
                    player.pioche(deck[deck.Count - 1]);
                    deck.RemoveAt(deck.Count - 1);
                });
            }
        }

        public void joue(int valueCard, int orderedStackSelected)
        {
            CurrentHand.ForEach(card =>
            {
                if (valueCard == card.Value)
                {
                    if (orderedStackSelected >= 0 && orderedStackSelected < 4)
                    {
                        if (orderedStackSelected < 2)
                        {
                            testPossibility(card, ListOrderedStacks[orderedStackSelected], false);
                        }
                        else
                        {
                            testPossibility(card, ListOrderedStacks[orderedStackSelected], true);
                        }
                    }
                    return;
                }
            });
        }

        protected void testPossibility(Card card, Stack<Card> orderedStack, bool bottomUp)
        {
            if ((bottomUp && card.Value > orderedStack.Peek().Value) || (!bottomUp && card.Value < orderedStack.Peek().Value))
            {
                Card oldCard = orderedStack.Peek();
                playerList[currentIndexPlayer].joue(card);
                orderedStack.Push(card);
                OnTopRangeChanged(new TopRangeChangedEventArgs(card, oldCard, ListOrderedStacks.IndexOf(orderedStack)));
            }
            else
            {
                throw new Exception("La carte ne rentre pas dans la pile sectionné!");
            }
        }

        protected internal void OnTopRangeChanged(TopRangeChangedEventArgs args)
        {
            TopRangeChanged?.Invoke(this, args);
        }

        protected internal void OnPlayerChanged(PlayerChangedEventArgs args)
        {
            PlayerChanged?.Invoke(this, args);
        }

        //protected internal void OnCurrentPlayerChanged(CurrentPlayerChangedEventArgs args)
        //{
        //    CurrentPlayerChanged?.Invoke(this, args);
        //}

        public bool isCanPlay()
        {
            if (CurrentHand.Count > 0)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        abstract public void endTurn();

        abstract protected void pioche();

        abstract protected bool isEndGame();

        abstract protected void tryToFindSoluce(List<Card> playableCard);

        abstract protected bool testEndGame(List<Card> playableCard);

        abstract protected bool effectLose();

        public int getCurentIndexPlayer()
        {
            return currentIndexPlayer;
        }

    }
}