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

public class HangmanController : AbstractFeedback
{
    /// <summary>
    /// The scriptable with all the themes, will be used to select a random word for hangman.
    /// The spellingthemeList will be used for the words.
    /// </summary>
    public ThemeList themelist;

    /// <summary>
    /// The word that is currently being spelled
    /// </summary>
    private string currentWord;

    /// <summary>
    /// This integer holds the total amount of wrong guesses the player has made
    /// </summary>
    private int wrongs;

    /// <summary>
    /// This integer holds the total amount of times a user can be wrong to lose.
    /// </summary>
    private int maxWrong = 9;

    /// <summary>
    /// This integer holds the amount of correct letters of the word that the user has guessed
    /// </summary>
    private int corrects;

    /// <summary>
    /// This integer holds the length of the word that needs to be guessed, game ends in victory if corrects == word_length
    /// </summary>
    private int wordLength;

    /// <summary>
    /// Indicates if the game is still going
    /// </summary>
    private bool gameEnded;

    /// <summary>
    /// Letter prefab
    /// </summary>
    public GameObject letterPrefab;

    /// <summary>
    /// Reference to letter prefab
    /// </summary>
    public Transform letterContainer;

    /// <summary>
    /// The Image component for displaying the appropriate sprite
    /// </summary>
    public Image hangmanImage;

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

    /// <summary>
    /// This scriptable holds all the images for the different stages of hangman
    /// </summary>
    public HangmanImages images;

    /// <summary>
    /// This initially empty list holds all the previous guesses that the user has made, as to not allow repeated msitakes
    /// </summary>
    private List<char> guesses;

    /// <summary>
    /// This lists holds all valid guesses that the user can make
    /// </summary>
    private List<char> guessables = new List<char> { 'a', 'z', 'e', 'r', 't', 'y', 'u', 'i', 'o', 'p', 'q', 's', 'd', 'f', 'g', 'h', 'j', 'k', 'l', 'm', 'w', 'x', 'c', 'v', 'b', 'n' };

    // The following attributes are necessary for multiplayer interactions
    /// <summary>
    /// The panel holding the actual game
    /// </summary>
    public GameObject gamePanel;

    /// <summary>
    /// The panel holding the player-selection screen
    /// </summary>
    public GameObject playerPanel;

    /// <summary>
    /// The panel holding the screen where player 1 can input their word
    /// </summary>
    public GameObject inputPanel;

    /// <summary>
    /// This textfield holds the word that player 1 is typing
    /// </summary>
    public TMP_Text inputTextField;

    /// <summary>
    /// This int shows what mode we are in, used in update: 0 is playerselect, 1 is wordInput, 2 is the actual game
    /// </summary>
    private int mode;

    // The following attributes are necessary to finish and gameover

    /// <summary>
    /// "Game over" or "You win!"
    /// </summary>
    public TMP_Text endText;

    /// <summary>
    /// The game over panel
    /// </summary>
    public GameObject gameEndedPanel;

    /// <summary>
    /// Button for restarting the game
    /// </summary>
    public Button replayButton;

    /// <summary>
    /// Letters
    /// </summary>
    public TMP_Text lettersText;

    /// <summary>
    /// Letters ( right | wrong )
    /// </summary>
    public TMP_Text lettersRightText;
    public TMP_Text lettersWrongText;

    /// <summary>
    /// Accuracy
    /// </summary>
    public TMP_Text accuracyText;

    /// <summary>
    /// Words
    /// </summary>
    public TMP_Text wordsText;

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

    // The following attributes are necessary for user interaction

    /// <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 current user
    /// </summary>
    private User user;

    /// <summary>
    /// Reference to the minigame progress of the current user
    /// </summary>
    private PersistentDataController.SavedMinigameProgress progress = null;

    /// <summary>
    /// Reference to the scoreboard
    /// </summary>
    public Transform Scoreboard;

    /// <summary>
    /// Reference to the entries grid
    /// </summary>
    public Transform EntriesGrid;

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

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

    /// <summary>
    /// The button to go into the game
    /// </summary>
    public GameObject gottogamebutton;

    /// <summary>
    /// Current sign out of the predictor
    /// </summary>
    private String currentsign = "";

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

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

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

    /// <summary>
    /// Timer to keep track of how long a incorrect sign is performed
    /// </summary>
    protected DateTime timer;

    /// <summary>
    /// Current predicted sign
    /// </summary>
    protected string predictedSign = null;

    /// <summary>
    /// Previous incorrect sign, so we can keep track whether the user is wrong or the user is still changing signs
    /// </summary>
    protected string previousIncorrectSign = null;

    /// <summary>
    /// Start is called before the first frame update
    /// </summary>
    void Start()
    {
        StartController();

        signPredictor.ChangeModel(ModelIndex.FINGERSPELLING);
        AddSelfAsListener();
    }
    /// <summary>
    /// Called at the start of the scene AND when the scene is replayed
    /// </summary>
    public void StartController()
    {
        // Make sure the mode starts at zero
        mode = 0;


        // Make sure that only the player-selection panel is the one shown
        gamePanel.SetActive(false);
        inputPanel.SetActive(false);
        playerPanel.SetActive(true);

        // Create entry in current user for keeping track of progress
        user = UserList.GetCurrentUser();
        progress = user.GetMinigameProgress(minigame.index);
        if (progress == null)
        {
            progress = new PersistentDataController.SavedMinigameProgress();
            progress.minigameIndex = minigame.index;
            user.AddMinigameProgress(progress);
        }
        UserList.Save();
    }

    /// <summary>
    /// Hangman starts by asking the amount of players, so this function holds all the info needed to start the actual game
    /// </summary>
    public void StartGame()
    {
        // Change the mode
        mode = 2;

        // Activate the right panel
        gamePanel.SetActive(true);
        inputPanel.SetActive(false);
        playerPanel.SetActive(false);

        // Reset values of parameters, so that the replaybutton works properly
        corrects = 0;
        wrongs = 0;
        guesses = new List<char>();
        // Display a test-word to test the functionality
        wordLength = currentWord.Length;
        gameEnded = false;
        gameEndedPanel.SetActive(false);

        // Delete first, to make sure that the letters are empty
        DeleteWord();
        DisplayWord(currentWord);

        replayButton.onClick.AddListener(StartController);
        // Call to display the first image, corresponding to a clean image.
        ChangeSprite();
    }

    /// <summary>
    /// This function is called when the "two player"-button is clicked, it goed to the input-screen
    /// </summary>
    public void GoToInput()
    {
        // Change the mode
        mode = 1;

        // Initialise the word to an empty String
        currentWord = "";
        inputTextField.text = currentWord.ToString();

        // Activate the right panel
        gamePanel.SetActive(false);
        inputPanel.SetActive(true);
        playerPanel.SetActive(false);
    }
    /// <summary>
    /// This function is called if singleplayer is selected, we generate a random word for the player and start the game.
    /// </summary>
    public void SinglePlayer()
    {
        // This word is used for testing before dynamic word-fetching is added
        PickRandomWord();

        StartGame();
    }
    /// <summary>
    /// Randomly select a word from a randomly selected theme, use this word for the hangman game for singleplayer.
    /// </summary>
    private void PickRandomWord()
    {
        // Get a random index for the themes
        // Then get a random index for a word to pull

        // First get random index for the themes
        int amountThemes = themelist.themes.Count;
        System.Random r = new System.Random();
        int themeIndex = r.Next(amountThemes);

        // Check how many words are in this theme
        int amountWords = themelist.themes[themeIndex].learnables.Count;
        int wordIndex = r.Next(amountWords);

        // Take the word, but lowercase it. 
        currentWord = themelist.themes[themeIndex].learnables[wordIndex].name.ToLower();
    }

    /// <summary>
    /// This function starts the game after player 1 has entered their word, but only if its length >= 2.
    /// </summary>
    public void TwoPlayer()
    {
        if (currentWord.Length >= 2)
        {
            StartGame();
        }
    }

    /// <summary>
    /// Update is called once per frame
    /// </summary>
    public void Update()
    {
        if (mode == 1)
        {
            if (currentsign != null && currentsign != "")
            {
                char letter = currentsign.ToLower()[0];
                currentsign = "";
                currentWord = currentWord + letter.ToString();
                inputTextField.text = currentWord.ToString();
            }
            // We are in the word-input mode
            // We want to show the user what they are typing
            // Check to make sure the inputfield is not empty
            if (Input.inputString != "")
            {
                char firstLetter = Input.inputString.ToLower()[0];
                if (Input.GetKey(KeyCode.Backspace))
                {
                    // Remove the last letter from the currentword
                    if (currentWord.Length > 0)
                    {
                        currentWord = currentWord.Substring(0, currentWord.Length - 1);
                        inputTextField.text = currentWord.ToString();
                    }
                }
                else if (guessables.Contains(firstLetter))
                {
                    // Append the letter to the currentWord and display it to the user
                    currentWord = currentWord + firstLetter.ToString();
                    inputTextField.text = currentWord.ToString();
                }
            }
            gottogamebutton.SetActive(currentWord.Length > 2);
        }

        if (mode == 2)
        {
            // We are in the actual game
            if (!gameEnded)
            {
                // Get keyboard input
                // For the first input char given by the user, check if the letter is in the word that needs to be spelled.

                // Check to make sure the inputfield is not empty
                if (currentsign != null && currentsign != "")
                {
                    char firstLetter = currentsign.ToLower()[0];
                    currentsign = "";
                    // Check if the letter is a valid guess and that it has not been guessed before
                    if (!guesses.Contains(firstLetter) && guessables.Contains(firstLetter))
                    {
                        if (currentWord.Contains(firstLetter))
                        {
                            // The guess was correct, we can display all the letters that correspond to the guess
                            UpdateWord(firstLetter);
                        }
                        else
                        {
                            // The guess was wrong, the wrongs integer needs to be incremented
                            wrongs++;

                            // For now, we will loop back to stage zero after we reach the losing stage 10
                            wrongs = wrongs % 11;

                            // Afterwards, the next stage needs to be displayed
                            ChangeSprite();
                        }

                        guesses.Add(firstLetter);
                    }
                }

                if (corrects == wordLength)
                {
                    // Victory
                    ActivateWin();
                }
                else if (wrongs == maxWrong)
                {
                    // You lost
                    ActivateGameOver();
                }
            }

        }
    }
    /// <summary>
    /// Change the image that is being displayed
    /// </summary>
    private void ChangeSprite()
    {

        // Load the new sprite from the HangmanImages scriptable
        Sprite sprite = images.hangmanStages[wrongs];

        // Set the new sprite as the Image component's source image
        hangmanImage.sprite = sprite;
    }
    /// <summary>
    /// In this function, the letters of the word selected in DisplayWord are updated after a correct guess.
    /// </summary>
    /// <param name="c">The letter that needs to be updated</param>
    private void UpdateWord(char c)
    {
        for (int i = 0; i < currentWord.Length; i++)
        {
            if (currentWord[i] == c)
            {
                // Display the letter and change its background to green
                Image background = letters[i].GetComponent<Image>();
                background.color = Color.green;
                TMP_Text txt = letters[i].GetComponentInChildren<TMP_Text>();
                txt.text = Char.ToString(c);

                // You correctly guessed a letter
                corrects++;
            }
        }
    }
    /// <summary>
    /// This function returns the score that the user currently has
    /// </summary>
    /// <returns>The current score of the user</returns>
    private int getScore()
    {
        // Scoring works as follows:
        // You get 3 points for each letter in the word that is correctly guessed (corrects * 3)
        // You get 9 points for each part of the hangman figure which is NOT displayed ((10 - wrongs) * 9)

        return 3 * corrects + (10 - wrongs) * 9;
    }

    /// <summary>
    /// Set score metrics
    /// </summary>
    private void SetScoreMetrics()
    {
        // Letters ( right | wrong ) total
        lettersRightText.text = corrects.ToString();
        lettersWrongText.text = wrongs.ToString();
        lettersText.text = (corrects + wrongs).ToString();

        // Accuracy
        if (corrects + wrongs > 0)
        {
            accuracyText.text = ((corrects) * 100f / (corrects + wrongs)).ToString("#.##") + "%";
        }
        else
        {
            accuracyText.text = "-";
        }


        // The word that needed to be guessed
        wordsText.text = currentWord.ToString();

        // Score
        scoreText.text = "Score: " + getScore().ToString();
    }

    // The following functions originate from Spellingbee

    /// <summary>
    /// Delete all letter objects
    /// </summary>
    private void DeleteWord()
    {
        for (int i = 0; i < letters.Count; i++)
        {
            Destroy(letters[i]);
        }
        letters.Clear();
    }

    /// <summary>
    /// Displays the word that needs to be spelled
    /// </summary>
    /// <param name="word">The word to display</param>
    private void DisplayWord(string word)
    {
        for (int i = 0; i < word.Length; i++)
        {
            // Create instance of prefab
            GameObject instance = GameObject.Instantiate(letterPrefab, letterContainer);
            letters.Add(instance);

            // Dynamically load appearance
            Image background = instance.GetComponent<Image>();
            background.color = Color.red;
            TMP_Text txt = instance.GetComponentInChildren<TMP_Text>();
            txt.text = Char.ToString(' ');
        }
    }

    /// <summary>
    /// Update and save the scores
    /// </summary>
    private void SaveScores()
    {
        // Calculate new score
        int newScore = getScore();
        // 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
        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();

        UserList.Save();
    }

    /// <summary>
    /// Display win screen
    /// </summary>
    private void ActivateWin()
    {
        // @lukas stuff
        DeleteWord();
        endText.text = "YOU WIN!";

        SetScoreMetrics();

        gameEndedPanel.SetActive(true);
        gameEndedPanel.transform.SetAsLastSibling();

        gameEnded = true;

        //Save the scores and show the scoreboard
        SaveScores();
        SetScoreBoard();
    }

    /// <summary>
    /// Displays the game over panel and score values
    /// </summary>
    private void ActivateGameOver()
    {
        DeleteWord();
        endText.text = "GAME OVER";

        SetScoreMetrics();

        gameEndedPanel.SetActive(true);
        gameEndedPanel.transform.SetAsLastSibling();

        gameEnded = true;

        // Save the scores and show the scoreboard
        SaveScores();
        SetScoreBoard();
    }

    /// <summary>
    /// Sets the scoreboard
    /// </summary>
    private void SetScoreBoard()
    {
        // Clean the previous scoreboard entries
        for (int i = 0; i < entries.Count; i++)
        {
            Destroy(entries[i]);
        }
        entries.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
            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, EntriesGrid);
            entries.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 current sign
        string currentSign = "A";
        // Get the predicted sign
        if (signPredictor != null && signPredictor.learnableProbabilities != null &&
            currentSign != null && signPredictor.learnableProbabilities.ContainsKey(currentSign))
        {
            float accuracy = signPredictor.learnableProbabilities[currentSign];
            if (feedbackText != null && feedbackProgressImage != null)
            {
                if (accuracy > 0.90)
                {
                    feedbackText.text = "Goed";
                    feedbackText.color = Color.green;
                    feedbackProgressImage.color = Color.green;
                }
                else if (accuracy > 0.80)
                {
                    feedbackText.text = "Bijna...";
                    Color col = new Color(0xff / 255.0f, 0x66 / 255.0f, 0x00 / 255.0f);
                    feedbackText.color = col;
                    feedbackProgressImage.color = col;
                }
                else
                {
                    feedbackText.text = "Detecteren...";
                    feedbackText.color = Color.red;
                    feedbackProgressImage.color = Color.red;
                }

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

            // Check whether (in)correct sign has high accuracy
            foreach (var kv in signPredictor.learnableProbabilities)
            {
                if (kv.Value > 0.90)
                {
                    predictedSign = kv.Key;
                    // Correct sign
                    if (predictedSign == currentSign)
                    {
                        yield return new WaitForSeconds(1.0f);
                        CheckEquality(predictedSign);
                        timer = DateTime.Now;
                        predictedSign = null;
                        previousIncorrectSign = null;
                    }
                    // Incorrect sign
                    else
                    {
                        if (previousIncorrectSign != predictedSign)
                        {
                            timer = DateTime.Now;
                            previousIncorrectSign = predictedSign;
                        }
                        else if (DateTime.Now - timer > TimeSpan.FromSeconds(2.0f))
                        {
                            CheckEquality(predictedSign);
                            timer = DateTime.Now;
                            predictedSign = null;
                            previousIncorrectSign = null;
                        }
                    }
                    break;
                }
            }
        }
        else if (feedbackProgress != null)
        {

            feedbackProgress.value = 0.0f;
        }

    }
    private void CheckEquality(string sign)
    {
        currentsign = sign;
    }
}