using System.Collections;
using System.Collections.Generic;
using System.Linq;
using Unity.MLAgents;
using UnityEngine;
using UnityEngine.UI;

public class AILearning : MonoBehaviour
{
    public static AILearning Main;
    public Text turnCounter;
    public Text Message;
    private List<string> Messages = new List<string>();
    private int cnt = 0;
    private int turnCount = 0;
    private List<AI> leftOvers = new List<AI>();
    static public int totalCount = 0;

    private float timer = 0;
    // Start is called before the first frame update
    void Start()
    {
        Main = this;
        TwitchIrc.Instance.OnServerMessage += OnServerMessage;
        TwitchIrc.Instance.OnUserJoined += OnUserJoined;
        TwitchIrc.Instance.OnChannelMessage += ChannelMessage;

        TwitchViewer.Load();

        StartCoroutine(RunAI());
    }

    private void OnApplicationQuit()
    {
        TwitchViewer.Save();
    }

    public void AddMessage(string message)
    {
        Messages.Insert(Messages.Count, message);
        Messages.Reverse();
        Messages = Messages.Take(25).ToList();
        Messages.Reverse();
        Message.text = string.Join("\n", Messages);
    }

    //Receive message from server
    void OnServerMessage(string message)
    {
        Debug.Log(message);
    }

    void OnUserJoined(Irc.UserJoinedEventArgs userJoinedArgs)
    {
        TwitchViewer user = TwitchViewer.GetUser(userJoinedArgs.User);
        if (user == null)
        {
            user = new TwitchViewer() {
                Username = userJoinedArgs.User
            };
            TwitchViewer.Viewers.List.Add(user);
        }
    }

    public void ChannelMessage(Irc.ChannelMessageEventArgs channelMessageArgs)
    {
        // IRC Message to commands here!
        TwitchViewer user = TwitchViewer.GetUser(channelMessageArgs.From);
        string msg = channelMessageArgs.Message;
        if (user != null && msg.StartsWith("!"))
        {
            if (msg.ToLower().StartsWith("!buy card "))
            {
                msg = msg.ToLower().TrimStart("!buy card ");
                user.BuyCard(msg);
            }
            else if (msg.ToLower().StartsWith("!buy stat "))
            {
                msg = msg.ToLower().TrimStart("!buy stat ");
                user.BuyStat(msg);
            }
            else if (msg.ToLower().StartsWith("!add "))
            {
                msg = msg.ToLower().TrimStart("!add ");
                user.AddCard(msg);
            }
            else if (msg.ToLower().StartsWith("!remove "))
            {
                msg = msg.ToLower().TrimStart("!remove ");
                user.RemoveCard(msg);
            }
            else if (msg.ToLower().StartsWith("!points"))
            {
                user.DisplayPoints();
            }
            else if (msg.ToLower().StartsWith("!join"))
            {
                user.Join();
            }
            else if (msg.ToLower().StartsWith("!cards"))
            {
                user.CardList();
            }
        }
    }


    private bool stuck = false;
    public void Update()
    {
        if (Time.realtimeSinceStartup - timer > 5)
        {
            StopAllCoroutines();
            stuck = true;
            GameData.lockHand = false;
            if (AI.ai.Count > 0)
            {
                foreach (AI ai in AI.ai)
                {
                    leftOvers.Add(ai);
                }
            }
            StartCoroutine(RunAI());
            timer = Time.realtimeSinceStartup;
        }
    }

    public IEnumerator RunAI()
    {
        yield return new WaitForSeconds(0.1f);
        while (cnt < 1000000)
        {
            leftOvers = leftOvers.Where(value => value != null).ToList();
            if (leftOvers.Count > 0)
            {
                //if (turnCount < 100)
                //{
                    TwitchIrc.Instance.Message(
                        string.Format(
                            "SirSword Winner is: {0} in team {1}",
                            string.Join(", ", leftOvers.Select(value => value.name)).ReplaceLast(", ", " and "),
                            leftOvers.FirstOrDefault().faction
                        )
                    );
                    foreach (AI ai in leftOvers)
                    {
                        TwitchViewer user = TwitchViewer.GetUser(ai.name.ToLower());
                        if (user != null)
                        {
                            user.AccumelatedPoints += 5;
                        }
                    }
                //}
                /*else
                {
                    TwitchIrc.Instance.Message(
                        string.Format(
                            "SirSad Tied with: {0}",
                            string.Join(", ", leftOvers.Select(value => value.name)).ReplaceLast(", ", " and ")
                        )
                    );
                    foreach (AI ai in leftOvers)
                    {
                        TwitchViewer user = TwitchViewer.GetUser(ai.name.ToLower());
                        if (user != null)
                        {
                            user.AccumelatedPoints += 2;
                        }
                    }
                }*/
            }

            cnt++;
            TwitchIrc.Instance.Message(string.Format("PowerUpL ROUND {0} PowerUpR", cnt));
            totalCount = 0;

            foreach (AI ai in leftOvers)
            {
                if (ai != null && ai.GetComponent<MonsterAgent>() != null)
                {
                    if (turnCount > 0 && !stuck)
                    {
                        ai.GetComponent<MonsterAgent>().AddReward(1);
                    }
                    ai.OnDeath.Invoke(ai, ai, 0, true);
                }
            }
            stuck = false;
            turnCount = 0;
            leftOvers.Clear();

            BattleMapGenerator.Instance.Reset();
            BattleMapGenerator.Instance.Generate();

            yield return new WaitForEndOfFrame();

            TrainerSpawner[] spawners = GetComponentsInChildren<TrainerSpawner>();
            foreach (TrainerSpawner spawner in spawners)
            {
                if(spawner != null)
                {
                    spawner.Spawn();
                    totalCount++;
                }
                yield return new WaitForEndOfFrame();
            }

            timer = Time.realtimeSinceStartup;
            while (AI.ai.Select(value => value.faction).Distinct().ToList().Count > 1 && turnCount < 1000)
            {
                turnCount++;
                turnCounter.text = string.Format("Turn: {0}", turnCount);
                Unit.SetOrder();
                List<AI> aiList = Unit.units.Where(value => value.GetType() != typeof(Unit)).Select(value => (AI)value).ToList();
                foreach (AI unit in aiList)
                {
                    unit.isMyTurn = true;
                    while (unit != null && unit.isMyTurn)
                    {
                        if (unit != null)
                        {
                            unit.GetComponent<MonsterAgent>().RequestDecision();
                            unit.GetComponent<MonsterAgent>().RequestAction();
                        }
                        yield return new WaitForEndOfFrame();

                        //if (Time.realtimeSinceStartup - timer < 60) break;
                    }
                    timer = Time.realtimeSinceStartup;
                }
                foreach (Unit unit in Unit.units)
                {
                    unit.PlayStack();
                }

               yield return Unit.StartQueue();
               Unit.units.ForEach(u =>
                {
                    u.stack.ForEach(c =>
                    {
                        if (c.keywords
                                .Select(value => value.Get<Game.Keyword.OnDiscard>())
                                .Where(value => value != null)
                                .All(value => value.OnDiscard(u, c)))
                        {
                            u.discardPile.Add(c);
                            if (u == GameData.Player) DiscardPile.main.UpdateDiscard();
                        }
                    });
                    u.stack.Clear();
                    u.CheckReShuffle();
                }
                );
                Unit.OnStackComplete.Invoke();
                yield return new WaitForEndOfFrame();
            }

            if(turnCount > 0 && spawners.Length > 0)
            {
                Academy.Instance.StatsRecorder.Add("Custom/Turns", turnCount);
                Academy.Instance.StatsRecorder.Add("Custom/Avg. Unit Turns", turnCount / spawners.Length);
            }

            if (AI.ai.Count > 0)
            {
                foreach (AI ai in AI.ai)
                {
                    leftOvers.Add(ai);
                }
            }

        }
    }
}