using DigitalRuby.Tween;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using TMPro;
using UnityEngine;
using UnityEngine.UI;
using Random = UnityEngine.Random;

/// <summary>
/// Contains all game logic for the JustSign game
/// </summary>
public class JustSignController : AbstractFeedback
{
    /// <summary>
    /// All of the words that can be used in this session
    /// </summary>
    private List<Learnable> words = new List<Learnable>();

    /// <summary>
    /// The input field where the user can type his or her answer
    /// </summary>
    public TMP_InputField answerField;

    /// <summary>
    /// The feedback on the timing
    /// </summary>
    public TMP_Text timingFeedback;

    /// <summary>
    /// The current score
    /// </summary>
    public TMP_Text scoreDisplay;

    /// <summary>
    /// Reference to the minigame ScriptableObject
    /// </summary>
    public Minigame minigame;

    /// <summary>
    /// We keep the minigamelist as well so that the minigame-index doesn't get reset
    /// DO NOT REMOVE
    /// </summary>
    public MinigameList minigamelist;

    /// </summary>
    /// Reference to the list of available songs
    /// </summary>
    public SongList songList;

    /// <summary>
    /// Reference to the currently used song
    /// </summary>
    private Song currentSong;

    /// <summary>
    /// Reference to the perfect hitzone
    /// </summary>
    public RectTransform hitZonePerfect;

    /// <summary>
    /// Reference to the good hitzone
    /// </summary>
    public RectTransform hitZoneGood;

    /// <summary>
    /// Reference to the meh hitzone
    /// </summary>
    public RectTransform hitZoneMeh;

    /// <summary>
    /// Reference to the webcam
    /// </summary>
    public RawImage webcamScreen;

    /// <summary>
    /// Score obtained when getting a perfect hit
    /// </summary>
    private int perfectScore = 50;

    /// <summary>
    /// Score obtained when getting a good hit
    /// </summary>
    private int goodScore = 20;

    /// <summary>
    /// Score obtained when getting a meh hit
    /// </summary>
    private int mehScore = 10;

    /// <summary>
    /// Score obtained when getting a terrible hit
    /// </summary>
    private int terribleScore = -3;

    /// <summary>
    /// Score obtained when symbol goes offscreen
    /// </summary>
    private int offscreenScore = -5;

    /// <summary>
    /// Symbol prefab
    /// </summary>
    public GameObject symbolPrefab;

    /// <summary>
    /// Reference to symbol prefab
    /// </summary>
    public Transform symbolContainer;

    /// <summary>
    /// The theme we are currently using
    /// </summary>
    private Theme currentTheme;

    /// <summary>
    /// List of strings representing all words on the track
    /// </summary>
    private List<string> activeWords = new List<string>();

    /// <summary>
    /// List of objects representing all symbols on the track
    /// </summary>
    private List<GameObject> activeSymbols = new List<GameObject>();

    /// <summary>
    /// Have the symbols started spawning or not
    /// </summary>
    private bool gameIsActive = false;

    /// <summary>
    /// Controls movement speed of symbols (higher -> faster)
    /// </summary>
    private int moveSpeed = 100;

    /// <summary>
    /// Starting X-coordinate of a symbol = (-1920 - symbolsize) / 2
    /// </summary>
    private int trackX = 1920 / 2;

    /// <summary>
    /// Starting Y-coordinate of a symbol
    /// </summary>
    private int trackY = 0;

    /// <summary>
    /// Time at which the last symbol was spawned
    /// </summary>
    private float lastSpawn;

    /// <summary>
    /// Time at which the game started, needed to know when to stop
    /// </summary>
    private float beginTime;

    /// <summary>
    /// Time at which the last symbol should spawn
    /// </summary>
    private float lastSymbolTime;

    /// <summary>
    /// Counter that keeps track of how many signs get you score "perfect"
    /// </summary>
    private int perfectSigns;

    /// <summary>
    /// Counter that keeps track of how many signs get you score "good"
    /// </summary>
    private int goodSigns;

    /// <summary>
    /// Counter that keeps track of how many signs get you score "meh"
    /// </summary>
    private int mehSigns;

    /// <summary>
    /// Counter that keeps track of how many signs get you score "perfect"
    /// </summary>
    private int terribleSigns;

    /// <summary>
    /// Counter that keeps track of how many signs done incorrectly
    /// </summary>
    private int incorrectSigns;

    /// <summary>
    /// Reference to the scoreboard entries container
    /// </summary>
    public Transform scoreboardEntriesContainer;

    /// <summary>
    /// The GameObjects representing the letters
    /// </summary>
    private List<GameObject> scoreboardEntries = new List<GameObject>();

    /// <summary>
    /// Reference to the ScoreboardEntry prefab
    /// </summary>
    public GameObject scoreboardEntry;

    /// <summary>
    /// Reference to the current user
    /// </summary>
    private User user;

    /// <summary>
    /// LPM
    /// </summary>
    public TMP_Text lpmText;

    /// <summary>
    /// Perfect Signs Score
    /// </summary>
    public TMP_Text perfectSignsText;

    /// <summary>
    /// Good Signs Score
    /// </summary>
    public TMP_Text goodSignsText;

    /// <summary>
    /// Meh Signs Score
    /// </summary>
    public TMP_Text mehSignsText;

    /// <summary>
    /// Perfect Signs Score
    /// </summary>
    public TMP_Text terribleSignsText;

    /// <summary>
    /// Signs that were not found
    /// </summary>
    public TMP_Text notFoundSignsText;

    /// <summary>
    /// Score
    /// </summary>
    public TMP_Text scoreText;

    /// <summary>
    /// Reference to the gameEnded panel, so we can update its display
    /// </summary>
    public GameObject gameEndedPanel;

    /// <summary>
    /// Reference to the feedback field
    /// </summary>
    public TMP_Text feedbackText;

    /// <summary>
    /// Reference to the progress bar
    /// </summary>
    public Slider feedbackProgressBar;

    /// <summary>
    /// Reference to the progress bar image, so we can add fancy colors
    /// </summary>
    public Image feedbackProgressImage;

    /// <summary>
    /// Sprite shown when perfect score
    /// </summary>
    public Sprite perfectSprite;

    /// <summary>
    /// Sprite shown when good score
    /// </summary>
    public Sprite goodSprite;

    /// <summary>
    /// Sprite shown when meh score
    /// </summary>
    public Sprite mehSprite;

    /// <summary>
    /// Sprite shown when terrible score (too soon)
    /// </summary>
    public Sprite terribleSprite;

    /// <summary>
    /// Sprite shown when sign leaves screen
    /// </summary>
    public Sprite tooLateSprite;

    /// <summary>
    /// Reference to display the feedback image
    /// </summary>
    public Image imageFeedback;

    /// <summary>
    /// Message to display when there is no model
    /// </summary>
    public GameObject previewMessage;

    /// <summary>
    /// Reference to the score, feedback and image
    /// </summary>
    public GameObject userFeedback;

    /// <summary>
    /// Start is called before the first frame update
    /// </summary>
    public void Start()
    {
        currentTheme = minigame.themeList.themes[minigame.themeList.currentThemeIndex];
        signPredictor.SetModel(currentTheme.modelIndex);
        signPredictor.SwapScreen(webcamScreen);
        AddSelfAsListener();

        StartController();
    }

    /// <summary>
    /// Holds the game-specific logic to start the controller
    /// </summary>
    public void StartController()
    {
        userFeedback.SetActive(currentTheme.modelIndex != ModelIndex.NONE);
        previewMessage.SetActive(currentTheme.modelIndex == ModelIndex.NONE);
        perfectSigns = 0;
        goodSigns = 0;
        mehSigns = 0;
        terribleSigns = 0;
        incorrectSigns = 0;
        timingFeedback.text = "";
        imageFeedback.sprite = minigame.thumbnail;
        gameEndedPanel.SetActive(false);
        // Create entry in current user for keeping track of progress
        user = UserList.GetCurrentUser();
        var progress = user.GetMinigameProgress(minigame.index);
        if (progress == null)
        {
            progress = new PersistentDataController.SavedMinigameProgress();
            progress.minigameIndex = minigame.index;
            user.AddMinigameProgress(progress);
        }
        UserList.Save();

        scoreDisplay.text = $"Score: {CalculateScore()}";
        words.AddRange(currentTheme.learnables);
        currentSong = songList.songs[songList.currentSongIndex];
        AudioSource.PlayClipAtPoint(currentSong.song, Vector3.zero, 1.0f);
        beginTime = Time.time;
        lastSymbolTime = beginTime + currentSong.duration - 1920.0f / moveSpeed;

        StartCoroutine(WaitThenStart(currentSong.firstSymbolTime));
    }

    /// <summary>
    /// Wait for a given amount of time (specified in song) before spawning symbols
    /// </summary>
    IEnumerator WaitThenStart(float nrOfSeconds)
    {
        //yield on a new YieldInstruction that waits for nrOfSeconds seconds
        yield return new WaitForSeconds(nrOfSeconds);
        gameIsActive = true;
    }

    /// <summary>
    /// Update is called once per frame
    /// </summary>
    void Update()
    {
        if (gameIsActive)
        {
            // Destroy the oldest symbol if it leaves the screen
            if (activeSymbols.Count > 0)
            {
                if (activeSymbols[0].GetComponent<RectTransform>().localPosition.x > trackX)
                {
                    DestroySymbolAt(0);
                    incorrectSigns++;
                    timingFeedback.text = $"Te laat! \n {offscreenScore}";
                    imageFeedback.sprite = tooLateSprite;
                }
            }

            // Spawn new symbol every spawn period
            float currentTime = Time.time;
            if (currentTime - lastSpawn > currentSong.spawnPeriod && lastSymbolTime > currentTime)
            {
                lastSpawn = currentTime;
                SpawnNewSymbol();
            }

            // Check if the song has ended and activate scorescreen if it has
            if (currentTime - beginTime > currentSong.duration)
            {
                ActivateEnd();
            }

            // Move all active symbols to the right
            foreach (GameObject symbol in activeSymbols)
            {
                RectTransform rectTransform = symbol.GetComponent<RectTransform>();
                rectTransform.localPosition = new Vector3(rectTransform.localPosition.x + Time.deltaTime * moveSpeed, trackY, 0);
            }

            scoreDisplay.text = $"Score: {CalculateScore()}";
        }
    }

    /// <summary>
    /// Calculate the score
    /// </summary>
    /// <returns>The calculated score</returns>
    public int CalculateScore()
    {
        return goodSigns * goodScore + perfectSigns * perfectScore + mehScore * mehSigns + terribleScore * terribleSigns + incorrectSigns * offscreenScore;
    }

    /// <summary>
    /// Display Scoreboard + Metrics
    /// </summary>
    public void ActivateEnd()
    {
        gameIsActive = false;
        while (activeSymbols.Count > 0)
        {
            DestroySymbolAt(0);
        }
        // TODO: Scoreboard
        SaveScores();
        SetScoreMetrics();
        SetScoreBoard();
        gameEndedPanel.SetActive(true);
    }

    /// <summary>
    /// Destroy the symbol at the given index
    /// </summary>
    /// <param name="index">The index of the symbol to destroy</param>
    void DestroySymbolAt(int index)
    {
        activeWords.RemoveAt(index);
        GameObject symbol = activeSymbols[index];
        activeSymbols.RemoveAt(index);
        Destroy(symbol);
    }

    /// <summary>
    /// Create a new symbol at the start of the track
    /// </summary>
    void SpawnNewSymbol()
    {
        // Pick a word that isn't in use yet
        List<int> unusedWordIndices = new List<int>();

        for (int i = 0; i < words.Count; i++)
        {
            if (!activeWords.Contains(words[i].name))
            {
                unusedWordIndices.Add(i);
            }
        }

        Learnable newLearnable = words[unusedWordIndices[Random.Range(0, unusedWordIndices.Count)]];
        string nextSymbol = newLearnable.name;

        GameObject newSymbolObject = GameObject.Instantiate(symbolPrefab, new Vector3(0, trackY, 0), Quaternion.identity, symbolContainer);

        // Dynamically load appearance
        Image image = newSymbolObject.transform.Find("Image").GetComponent<Image>();
        image.sprite = newLearnable.image;

        // Place the word that the symbol represents under the image
        TMP_Text text = newSymbolObject.GetComponentInChildren<TMP_Text>();
        text.text = nextSymbol;

        activeWords.Add(nextSymbol.ToUpper());
        activeSymbols.Add(newSymbolObject);
    }

    /// <summary>
    /// Update and save the scores
    /// </summary>
    public void SaveScores()
    {
        // Calculate new score
        int newScore = CalculateScore();

        // Save the score as a tuple: < int score, string time ago>
        Score score = new Score();
        score.scoreValue = newScore;
        score.time = DateTime.Now.ToString();

        // Save the new score
        var progress = user.GetMinigameProgress(minigame.index);

        // Get the current list of scores
        List<Score> latestScores = progress.latestScores;
        List<Score> highestScores = progress.highestScores;

        // Add the new score
        latestScores.Add(score);
        highestScores.Add(score);

        // Sort the scores
        highestScores.Sort((a, b) => b.scoreValue.CompareTo(a.scoreValue));

        // Only save the top 10 scores, so this list doesn't keep growing endlessly
        progress.latestScores = latestScores.Take(10).ToList();
        progress.highestScores = highestScores.Take(10).ToList();

        PersistentDataController.GetInstance().Save();
    }

    /// <summary>
    /// Set score metrics
    /// </summary>
    private void SetScoreMetrics()
    {
        // In de zone
        perfectSignsText.text = perfectSigns.ToString();

        // Aanvaardbaar
        goodSignsText.text = goodSigns.ToString();

        // Nipt
        mehSignsText.text = mehSigns.ToString();

        // Slechte timing
        terribleSignsText.text = terribleSigns.ToString();

        // Niet Geraden
        notFoundSignsText.text = incorrectSigns.ToString();

        // LPM
        int duration = songList.songs[songList.currentSongIndex].duration;
        int correctSigns = goodSigns + perfectSigns + mehSigns + terribleSigns;
        lpmText.text = (60f * correctSigns / duration).ToString("#") + " GPM";

        // Score
        scoreText.text = $"Score: {CalculateScore()}";
    }

    /// <summary>
    /// Sets the scoreboard
    /// </summary>
    private void SetScoreBoard()
    {
        // Clean the previous scoreboard entries
        for (int i = 0; i < scoreboardEntries.Count; i++)
        {
            Destroy(scoreboardEntries[i]);
        }
        scoreboardEntries.Clear();

        // Instantiate new entries
        // Get all scores from all users
        List<Tuple<string, Score>> allScores = new List<Tuple<string, Score>>();
        foreach (User user in UserList.GetUsers())
        {
            // Get user's progress for this minigame
            var progress = user.GetMinigameProgress(minigame.index);
            if (progress != null)
            {
                // Add scores to dictionary
                List<Score> scores = progress.highestScores;
                foreach (Score score in scores)
                {
                    allScores.Add(new Tuple<string, Score>(user.GetUsername(), score));
                }
            }
        }

        // Sort allScores based on Score.scoreValue
        allScores.Sort((a, b) => b.Item2.scoreValue.CompareTo(a.Item2.scoreValue));

        // Instantiate scoreboard entries
        int rank = 1;
        foreach (Tuple<string, Score> tup in allScores.Take(10))
        {
            string username = tup.Item1;
            Score score = tup.Item2;

            GameObject entry = Instantiate(scoreboardEntry, scoreboardEntriesContainer);
            scoreboardEntries.Add(entry);

            // Set the player icon
            entry.transform.Find("Image").GetComponent<Image>().sprite = UserList.GetUserByUsername(username).GetAvatar();

            // Set the player name
            entry.transform.Find("PlayerName").GetComponent<TMP_Text>().text = username;

            // Set the score
            entry.transform.Find("Score").GetComponent<TMP_Text>().text = score.scoreValue.ToString();

            // Set the rank
            entry.transform.Find("Rank").GetComponent<TMP_Text>().text = rank.ToString();

            // Set the ago
            // Convert the score.time to Datetime
            DateTime time = DateTime.Parse(score.time);
            DateTime currentTime = DateTime.Now;
            TimeSpan diff = currentTime.Subtract(time);

            string formatted;
            if (diff.Days > 0)
            {
                formatted = $"{diff.Days}d ";
            }
            else if (diff.Hours > 0)
            {
                formatted = $"{diff.Hours}h ";
            }
            else if (diff.Minutes > 0)
            {
                formatted = $"{diff.Minutes}m ";
            }
            else
            {
                formatted = "now";
            }

            entry.transform.Find("Ago").GetComponent<TMP_Text>().text = formatted;


            // Alternating colors looks nice
            if (rank % 2 == 0)
            {
                Image image = entry.transform.GetComponent<Image>();
                image.color = new Color(image.color.r, image.color.g, image.color.b, 0f);
            }

            // Make new score stand out
            if (diff.TotalSeconds < 1)
            {
                Image image = entry.transform.GetComponent<Image>();
                image.color = new Color(0, 229, 255, 233);
            }

            rank++;
        }
    }

    /// <summary>
    /// The updateFunction that is called when new probabilities become available
    /// </summary>
    /// <returns></returns>
    protected override IEnumerator UpdateFeedback()
    {
        // Get the predicted sign
        if (signPredictor != null && signPredictor.learnableProbabilities != null && gameIsActive)
        {
            // Get highest predicted sign
            string predictedSign = signPredictor.learnableProbabilities.Aggregate((a, b) => a.Value > b.Value ? a : b).Key;
            float accuracy = signPredictor.learnableProbabilities[predictedSign];

            // vvv TEMPORARY STUFF vvv
            if (predictedSign == "J" && accuracy <= 0.97f)
            {
                predictedSign = signPredictor.learnableProbabilities.Aggregate((x, y) => x.Value > y.Value && x.Key != "J" ? x : y).Key;
            }
            accuracy = signPredictor.learnableProbabilities[predictedSign];
            // ^^^ TEMPORARY STUFF ^^^

            Learnable predSign = currentTheme.learnables.Find(l => l.name.ToUpper().Replace(" ", "-") == predictedSign);

            if (feedbackText != null && feedbackProgressImage != null)
            {
                Color col;
                if (accuracy > predSign.thresholdPercentage)
                {
                    feedbackText.text = $"Herkent '{predictedSign}'";
                    col = new Color(0x8b / 255.0f, 0xd4 / 255.0f, 0x5e / 255.0f);
                }
                else if (accuracy > 0.9 * predSign.thresholdPercentage)
                {
                    feedbackText.text = $"Lijkt op '{predictedSign}'";
                    col = new Color(0xf2 / 255.0f, 0x7f / 255.0f, 0x0c / 255.0f);
                }
                else
                {
                    feedbackText.text = "Detecteren...";
                    col = new Color(0xf5 / 255.0f, 0x49 / 255.0f, 0x3d / 255.0f);
                }

                feedbackText.color = col;
                feedbackProgressImage.color = col;

                float oldValue = feedbackProgressBar.value;
                // use an exponential scale 
                float newValue = Mathf.Exp(4 * (Mathf.Clamp(accuracy / predSign.thresholdPercentage, 0.0f, 1.0f) - 1.0f));
                feedbackProgressBar.gameObject.Tween("FeedbackUpdate", oldValue, newValue, 0.2f, TweenScaleFunctions.CubicEaseInOut, (t) =>
                {
                    if (feedbackProgressBar != null)
                    {
                        feedbackProgressBar.value = t.CurrentValue;
                    }
                });
            }

            if (accuracy > predSign.thresholdPercentage)
            {
                int matchedSymbolIndex = activeWords.IndexOf(predictedSign.ToUpper());

                // Destroy the oldest symbol if the current input matches it
                if (0 <= matchedSymbolIndex)
                {
                    float x = activeSymbols[matchedSymbolIndex].transform.localPosition.x;

                    // parameters to define the Perfect hit zone
                    float perfectRange = hitZonePerfect.sizeDelta.x;
                    float perfectCenter = hitZonePerfect.localPosition.x;
                    // parameters to define the Good hit zone
                    float goodRange = hitZoneGood.sizeDelta.x;
                    float goodCenter = hitZoneGood.localPosition.x;
                    // parameters to define the Meh hit zone
                    float mehRange = hitZoneMeh.sizeDelta.x;
                    float mehCenter = hitZoneMeh.localPosition.x;

                    if (perfectCenter - perfectRange / 2 <= x && x <= perfectCenter + perfectRange / 2)
                    {
                        timingFeedback.text = $"Perfect! \n +{perfectScore}";
                        imageFeedback.sprite = perfectSprite;
                        perfectSigns++;
                        timingFeedback.color = new Color(0x8b / 255.0f, 0xd4 / 255.0f, 0x5e / 255.0f);
                    }
                    else if (goodCenter - goodRange / 2 <= x && x <= goodCenter + goodRange / 2)
                    {
                        timingFeedback.text = $"Goed \n +{goodScore}";
                        imageFeedback.sprite = goodSprite;
                        goodSigns++;
                        timingFeedback.color = new Color(0xf7 / 255.0f, 0xad / 255.0f, 0x19 / 255.0f);
                    }
                    else if (mehCenter - mehRange / 2 <= x && x <= mehCenter + mehRange / 2)
                    {
                        timingFeedback.text = $"Bijna... \n +{mehScore}";
                        imageFeedback.sprite = mehSprite;
                        mehSigns++;
                        timingFeedback.color = new Color(0xf2 / 255.0f, 0x7f / 255.0f, 0x0c / 255.0f);
                    }
                    else
                    {
                        timingFeedback.text = $"Te vroeg! \n {terribleScore}";
                        imageFeedback.sprite = terribleSprite;
                        terribleSigns++;
                        timingFeedback.color = new Color(0xf5 / 255.0f, 0x49 / 255.0f, 0x3d / 255.0f);
                    }

                    DestroySymbolAt(matchedSymbolIndex);
                }
            }
        }
        else if (feedbackProgressBar != null)
        {

            feedbackProgressBar.value = 0.0f;
        }
        yield return null;
    }
}