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

/// <summary>
/// Contains all game logic for the JustSign game
/// </summary>
public class JustSignController : AbstractMinigameController
{
    /// <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 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>
    /// Score obtained when getting a perfect hit
    /// </summary>
    private const int perfectScore = 50;

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

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

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

    /// <summary>
    /// Score obtained when symbol goes offscreen
    /// </summary>
    private const 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>
    /// Controls movement speed of symbols (higher -> faster)
    /// </summary>
    private const int moveSpeed = 100;

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

    /// <summary>
    /// Starting Y-coordinate of a symbol
    /// </summary>
    private const 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>
    /// 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 feedback field
    /// </summary>
    public TMP_Text feedbackText;

    /// <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>
    /// Get the current theme
    /// </summary>
    protected override Theme signPredictorTheme
    {
        get { return currentTheme; }
    }

    /// <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}";
                    timingFeedback.color = new Color(0x10 / 255.0f, 0x10 / 255.0f, 0x10 / 255.0f);
                    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)
            {
                // The boolean that is passed is irrelevant for this game
                ActivateEnd(true);
            }

            // 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 override int CalculateScore()
    {
        return goodSigns * goodScore + perfectSigns * perfectScore + mehScore * mehSigns + terribleScore * terribleSigns + incorrectSigns * offscreenScore;
    }

    /// <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>
    /// Get the threshold for a given sign
    /// </summary>
    /// <param name="sign"></param>
    /// <returns></returns>
    public float GetThreshold(string sign)
    {
        var s = sign.ToUpper().Replace(" ", "-");
        Learnable predSign = currentTheme.learnables.Find(l => l.name.ToUpper().Replace(" ", "-") == s);
        return predSign.thresholdDistance;
    }

    /// <summary>
    /// The logic to process the signs sent by the signPredictor
    /// </summary>
    /// <param name="accuracy">The accuracy of the passed sign</param>
    /// <param name="predictedSign">The name of the passed sign</param>
    public override void ProcessMostProbableSign(float distance, string predictedSign)
    {
        float threshold = GetThreshold(predictedSign);

        // If there is a feedback-object, we wil change its appearance
        if (feedbackText != null && feedbackProgressImage != null)
        {
            Color col;
            if (distance < threshold)
            {
                feedbackText.text = $"Herkent '{predictedSign}'";
                col = new Color(0x8b / 255.0f, 0xd4 / 255.0f, 0x5e / 255.0f);
            }
            else if (distance < 1.5 * threshold)
            {
                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 = feedbackProgress.value;
            // use an exponential scale 
            float newValue = 1 - Mathf.Clamp(distance - threshold, 0.0f, 3.0f) / 3;
            feedbackProgress.gameObject.Tween("FeedbackUpdate", oldValue, newValue, 0.2f, TweenScaleFunctions.CubicEaseInOut, (t) =>
            {
                if (feedbackProgress != null)
                {
                    feedbackProgress.value = t.CurrentValue;
                }
            });
        }

        // The logic for the internal workings of the game
        if (distance < threshold)
        {
            int matchedSymbolIndex = activeWords.IndexOf(predictedSign.ToUpper());

            // Destroy the oldest symbol if the current input matches it
            if (0 <= matchedSymbolIndex)
            {
                MatchedSymbol(matchedSymbolIndex);
            }
        }
    }

    /// <summary>
    /// The logic to process a correct sign within the zones in the game
    /// </summary>
    /// <param name="index"></param>
    void MatchedSymbol(int index)
    {
        float x = activeSymbols[index].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(index);
    }

    /// <summary>
    /// The logic to set the scoreboard of justsign
    /// </summary>
    /// <param name="victory">Shows whether or not the player won, is not relevant for JustSIgn</param>
    protected override void SetScoreBoard(bool victory)
    {
        gameEndedPanel.GetComponent<JustSignGameEndedPanel>().GenerateContent(
            perfectSigns: perfectSigns,
            goodSigns: goodSigns,
            mehSigns: mehSigns,
            terribleSigns: terribleSigns,
            incorrectSigns: incorrectSigns,
            duration: currentSong.duration,
            score: CalculateScore()
        );
    }

    /// <summary>
    /// The justsign-specific logic that needs to be called at the start of the game
    /// </summary>
    protected override void StartGameLogic()
    {
        // Set the current theme so that it can be passed along

        currentTheme = minigame.themeList.themes[minigame.themeList.currentThemeIndex];

        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);

        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>
    /// The justsign-specific logic that needs to be called at the end of a game
    /// </summary>
    /// <param name="victory"></param>
    protected override void EndGameLogic(bool victory)
    {
        gameIsActive = false;
        while (activeSymbols.Count > 0)
        {
            DestroySymbolAt(0);
        }
    }

    /// <summary>
    /// Get sign for the first active symbol
    /// </summary>
    /// <returns></returns>
    public string GetFirstSign()
    {
        if (activeSymbols.Count > 0)
        {
            TMP_Text text = activeSymbols[0].GetComponentInChildren<TMP_Text>();
            return text.text;
        }
        return null;
    }
}