using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.SceneManagement;

public class Quiz4Controller : MonoBehaviour {

    // References to answers 
    private List<GameObject> answers;

    // References to answers halo prefabs
    private List<GameObject> answersHaloEffects;

    public Text counterText;

    public Text scoreText;

    public Text questionText;

    public Button btnNextQuestion;

    public GameObject haloEffect;

    public GameObject[] answerModels;

    private int scoreValue;

    private int questionIdx = 0;

    private const int initialScore = 0;

    private const int numberOfAnswers = 4;

    private const int scoreCorrectAnswer = 10;

    private const int scoreIncorrectAnswer = -10;

    private const int scoreForProfessorAtom = 10;

    private const float counterInitialValue = 90;

    private const float counterDisplayAnswersInitialValue = 1.5f;

    private float counterValue;

    private float counterDisplayAnswersValue;

    private bool counterDisplayAnswersStarted = false;

    // List of selected answers
    private List<int> selectedAnswers;

    // List of questions and correct answers
    List<Question> questions = new List<Question>() {
            new Question("1. Neki od ovih prozora imaju 2-3 puta manje toplotnih gubitaka za razliku od drugih, koji su to?", new int[] {1, 4},
                new Answer[] {
                    new Answer(AnswerObjectModel.NOVI_PROZOR, "Novi prozor"),
                    new Answer(AnswerObjectModel.STARI_PROZOR, "Stari prozor"),
                    new Answer(AnswerObjectModel.SLOMLJENI_PROZOR, "Slomljeni prozor"),
                    new Answer(AnswerObjectModel.PROZOR_SA_ROLETNOM, "Prozor sa roletnom")}),
            new Question("2. Na jedan od načina možete uštedjeti i do 10 litara vode po osobi dnevno, uz koji predmet?", new int[] {3, 4},
                new Answer[] {
                    new Answer(AnswerObjectModel.UPALJENA_CESMA, "Upaljena česma"),
                    new Answer(AnswerObjectModel.PROZOR_SA_ROLETNOM, "Spuštene roletne"),
                    new Answer(AnswerObjectModel.UGASENA_CESMA, "Ugašena česma"),
                    new Answer(AnswerObjectModel.PROFESOR_ATOM_10, "Profesor Atom +10")}),
            new Question("3. Korištenjem jednog od sljedećih predmeta, u svjetlost se pretvara svega 5% uložene energije, dok se ostatak pretvara u toplotu, koji je to?", new int[] {1},
                new Answer[]{
                    new Answer(AnswerObjectModel.ZARNA_SIJALICA, "Žarne sijalice"),
                    new Answer(AnswerObjectModel.BICIKLO, "Biciklo"),
                    new Answer(AnswerObjectModel.VENTILATOR, "Ventilator"),
                    new Answer(AnswerObjectModel.KANTA_ZA_RECIKLIRANJE, "Kanta za recikliranje")}),
            new Question("4. Neki od navedenih predmeta uključeni u utičnicu, iako nisu u u funkciji, i dalje se znatno griju i troše električnu energiju.", new int[] {3},
                new Answer[]{
                    new Answer(AnswerObjectModel.NOVI_PROZOR, "Prozor"),
                    new Answer(AnswerObjectModel.KLIMA, "Klima"),
                    new Answer(AnswerObjectModel.ADAPTER, "Adapter"),
                    new Answer(AnswerObjectModel.MASINA_ZA_VES, "Veš mašina")}),
            new Question("5. Šta možemo ugraditi na radijatore da nam pomogne smanjiti troškove grijanja za 7-15%?", new int[] {1, 3},
                new Answer[]{
                    new Answer(AnswerObjectModel.TERMOSTAT_25, "Termostat"),
                    new Answer(AnswerObjectModel.PREKIDAC_ZA_SVJETLO, "Prekidač za svjetlo"),
                    new Answer(AnswerObjectModel.PROFESOR_ATOM_10, "Profesor Atom +10"),
                    new Answer(AnswerObjectModel.ADAPTER, "Adapter")}),
            new Question("6. Ako je vani temperatura 33°C, koja je optimalna temperatura u kući? ", new int[] {4},
                new Answer[]{
                    new Answer(AnswerObjectModel.KUCICA_17, "Kućica 17°C"),
                    new Answer(AnswerObjectModel.KUCICA_22, "Kućica 22°C"),
                    new Answer(AnswerObjectModel.KUCICA_33, "Kućica 33°C"),
                    new Answer(AnswerObjectModel.KUCICA_26, "Kućica 26°C")}),
            new Question("7. Kakvim načinom pranja posuđa, i uz koji uređaj od navedenih, trošimo 60% manje električne energije i do 85% manje vode?", new int[] {2, 3},
                new Answer[]{
                    new Answer(AnswerObjectModel.RUCNO_PRANJE_SUDJA, "Ručno pranje suđa"),
                    new Answer(AnswerObjectModel.MASINA_ZA_SUDJE, "Pranje u mašini za suđe"),
                    new Answer(AnswerObjectModel.PROFESOR_ATOM_10, "Profesor Atom +10"),
                    new Answer(AnswerObjectModel.STRIK, "Štrik")}),
            new Question("8. Koji uređaj u «stand by» načinu rada troši i do 24% energije u odnosu na potrošnju energije kada je upaljen?", new int[] {4},
                new Answer[]{
                    new Answer(AnswerObjectModel.RADIJATOR, "Radijator"),
                    new Answer(AnswerObjectModel.VENTILATOR, "Ventilator"),
                    new Answer(AnswerObjectModel.BICIKLO, "Biciklo"),
                    new Answer(AnswerObjectModel.TELEVIZOR, "Televizor")}),
            new Question("9. Jednom godišnje stručna osoba treba provjeriti prohodnost čega? Loša prohodnost doprinosi većoj potrošnji energije za grijanje.", new int[] {1},
                new Answer[]{
                    new Answer(AnswerObjectModel.DIMNJAK, "Dimnjak"),
                    new Answer(AnswerObjectModel.AUTO, "Auto"),
                    new Answer(AnswerObjectModel.NOVI_PROZOR, "Prozor"),
                    new Answer(AnswerObjectModel.UPALJENA_CESMA, "Česma sa vodom")}),
            new Question("10. Uvijek odaberite program s najnižom temperaturom vode koji još uvijek obezbjeđuje dobar kvalitet pranja, za šta od navedenog? ", new int[] {1, 4},
                new Answer[]{
                    new Answer(AnswerObjectModel.PROFESOR_ATOM_10, "Profesor Atom +10"),
                    new Answer(AnswerObjectModel.STRIK, "Štrik"),
                    new Answer(AnswerObjectModel.RUCNO_PRANJE_VESA, "Pranje na ruke"),
                    new Answer(AnswerObjectModel.MASINA_ZA_VES, "Mašina za veš")})
    };

    // Positions for answers 1, 2, 3 and 4
    private Vector3[] answerPositions = new Vector3[]
    {
        new Vector3(-10, 10, -5),
        new Vector3(-10, 5, -7),
        new Vector3(10, 5, -7),
        new Vector3(10, 10, -5)
    };

    private Vector3 answerScale = new Vector3(0.15f, 0.15f, 0.15f);

    /// <summary>
    /// Use this for initialization
    /// </summary>
    void Start () {
        scoreValue = initialScore;
        UpdateScore(true);
        questionIdx = 0;
        // Set counter to 90s
        counterValue = counterInitialValue;
        UpdateCounter();

        selectedAnswers = new List<int>();
        answersHaloEffects = new List<GameObject>();
        answers = new List<GameObject>();
        
        // Instantiate answers and halo effects
        InstantiateAnswers();
        InstantiateHaloPrefabs();
        
        UpdateScene();
        btnNextQuestion.GetComponent<Button>().onClick.AddListener(LoadNextQuestion);
    }


    /// <summary>
    /// // Update is called once per frame
    /// </summary>
    void Update()
    {
        if (counterValue > 0)
        {
            // We pause timer to show correct answers
            /*
            if (!counterDisplayAnswersStarted)
            {
                counterValue -= Time.deltaTime;
                UpdateCounter();
            }*/
            
            counterValue -= Time.deltaTime;
            UpdateCounter();
        }
        else
        {
            if (questionIdx == questions.Count)
            {
                SceneManager.LoadScene("EntryScene");
                return;
            }
            else
                LoadNextQuestion();
        }
        if (counterDisplayAnswersValue > 0 && counterDisplayAnswersStarted)
            counterDisplayAnswersValue -= Time.deltaTime;
        else
        {
            if (questionIdx == questions.Count)
            {
                SceneManager.LoadScene("EntryScene");
                return;
            }
            else
            {
                UpdateScene();
                counterDisplayAnswersStarted = false;
            }
        }
        
        // Select answers event handler
        if (Input.GetMouseButtonDown(0))
        {
            Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
            RaycastHit hit;

            if (Physics.Raycast(ray, out hit, 100))
            {
                if (counterDisplayAnswersStarted)
                    return;
                Debug.Log(hit.transform.gameObject.name);
                // answerArrayIdx: [1, 40]
                int answerArrayIdx = GetAnswerIdx(hit.transform.gameObject.name);
                // answerIdx: [1, 4]
                int answerIdx = answerArrayIdx - numberOfAnswers * questionIdx;
                // Answer not selected - select it
                if (!selectedAnswers.Contains(answerIdx))
                {
                    SetGlowEffect(answerArrayIdx, true);
                    selectedAnswers.Add(answerIdx);
                }
                // Answer selected - unselect it
                else
                {
                    SetGlowEffect(answerArrayIdx, false);
                    selectedAnswers.Remove(answerIdx);
                }   
            }
        }
    }

    /// <summary>
    /// Adds Halo prefabs to all answers
    /// </summary>
    private void InstantiateHaloPrefabs()
    {
        for (int i = 0; i < answers.Count; i++)
        {
            GameObject answerPrefab = Instantiate(haloEffect) as GameObject;
            answerPrefab.SetActive(false);
            answerPrefab.transform.SetParent(answers[i].transform, false);
            answersHaloEffects.Add(answerPrefab);
        }
    }

    /// <summary>
    /// Instantiates all answer objects
    /// </summary>
    private void InstantiateAnswers()
    {
        for(int qIdx = 0; qIdx < questions.Count; ++qIdx)
        {
            for(int ansIdx = 0; ansIdx < numberOfAnswers; ++ansIdx)
            {
                Answer ans = questions[qIdx].getPossibleAnswers()[ansIdx];
                string answerName = "Answer" + (qIdx * numberOfAnswers + ansIdx + 1).ToString();
                InstantiateAnswerObject(answerName, ansIdx, ans.getAnswerModel(), ans.getAnswerCaption());
            }
        }
    }

    /// <summary>
    /// Instantiates answer object according to its type and sets its transform
    /// </summary>
    /// <param name="answerName"></param>
    /// <param name="answerIdx"></param>
    /// <param name="model"></param>
    /// <param name="answerCaption"></param>
    private void InstantiateAnswerObject(string answerName, int answerIdx, AnswerObjectModel model, string answerCaption)
    {
        GameObject answerGameObject = Instantiate(answerModels[(int)model]) as GameObject;
        answerGameObject.SetActive(true);
        answerGameObject.name = answerName;
        answerGameObject.transform.position = answerPositions[answerIdx];
        answerGameObject.transform.localScale = answerScale;
        answerGameObject.GetComponent<ObjectController>().modelCaption.text = answerCaption;
        answers.Add(answerGameObject);
    }

    /// <summary>
    /// Next question btn click event handler
    /// </summary>
    void LoadNextQuestion()
    {
        if (counterDisplayAnswersStarted)
            return;
    
        UpdateScore();
        selectedAnswers.Clear();
        ClearCurrentSceneGlowEffect();
        // Start display answers counter
        counterDisplayAnswersValue = counterDisplayAnswersInitialValue;
        counterDisplayAnswersStarted = true;
        ShowAnswers();
        questionIdx = questionIdx + 1;
    }

    /// <summary>
    /// Updates score value
    /// </summary>
    private void UpdateScore(bool initialization = false)
    {
        if (!initialization)
        {
            scoreValue += GetScore();
            if (scoreValue < 0)
                scoreValue = 0;
        }
        scoreText.text = scoreValue.ToString("D3");
    }

    /// <summary>
    /// Updates counter value - called from Update() method
    /// </summary>
    private void UpdateCounter()
    {
        counterText.text = counterValue.ToString("f0");
    }

    /// <summary>
    /// Shows correct answers
    /// </summary>
    private void ShowAnswers()
    {
        for(int i = numberOfAnswers * questionIdx; i < numberOfAnswers * (questionIdx + 1); i++)
        {
            MarkAnswer(questions[questionIdx].getCorrectAnswers().Contains(i - questionIdx * numberOfAnswers + 1), i);
        }
    }

    /// <summary>
    /// Updates scene with new question and related answers
    /// </summary>
    private void UpdateScene()
    {
        RemoveMarks();
        // Set new question
        questionText.text = questions[questionIdx].getQuestionText();
        // Set answers for selected question
        for(int i = 0; i < answers.Count; i++)
        {
            if (i >= numberOfAnswers * questionIdx && i < numberOfAnswers * (questionIdx + 1))
            {
                answers[i].SetActive(true);
            }
            else
                answers[i].SetActive(false);
        }
    }

    /// <summary>
    /// Hides correct/incorrect images for currently shown answers
    /// </summary>
    private void RemoveMarks()
    {
        for(int i = 0; i < numberOfAnswers; i++) {
            int answerIdx = questionIdx * numberOfAnswers + i;
            answers[answerIdx].GetComponent<ObjectController>().imageCorrect.enabled = false;
            answers[answerIdx].GetComponent<ObjectController>().imageIncorrect.enabled = false;
        }
    }

    /// <summary>
    /// Sets visibility of correct/incorrect overlay images
    /// </summary>
    /// <param name="isCorrect"></param>
    /// <param name="idx"></param>
    private void MarkAnswer(bool isCorrect, int idx)
    {
        answers[idx].GetComponent<ObjectController>().imageCorrect.enabled = isCorrect;
        answers[idx].GetComponent<ObjectController>().imageIncorrect.enabled = !isCorrect;
    }

    /// <summary>
    /// Clears glow from all currently shown answers
    /// </summary>
    private void ClearCurrentSceneGlowEffect()
    {
        for (int i = 0; i < numberOfAnswers; i++)
        {
            int prefabIdx = questionIdx * numberOfAnswers + i;
            answersHaloEffects[prefabIdx].SetActive(false);
        }
    }

    /// <summary>
    /// Clears/Adds glow from a specific answer GameObject
    /// </summary>
    /// <param name="prefabIdx"></param>
    private void SetGlowEffect(int prefabIdx, bool showGlowEffect)
    {
        answersHaloEffects[prefabIdx - 1].SetActive(showGlowEffect);
    }

    /// <summary>
    /// Returns answer index (X) from answer's name (AnswerX)
    /// </summary>
    /// <param name="gameObjName">GameObject's name</param>
    /// <returns></returns>
    private int GetAnswerIdx(string gameObjName)
    {
        string resultString = Regex.Match(gameObjName, @"\d+").Value;
        return System.Int32.Parse(resultString);
    }

    /// <summary>
    /// Returns score for a particular question
    /// </summary>
    /// <returns></returns>
    private int GetScore() {
        int score = 0;
        // Correct answers
        int[] correctAnswers = questions[questionIdx].getCorrectAnswers();
        // Selected answers: selectedAnswers
        for (int ansIdx = 1; ansIdx <= numberOfAnswers; ++ansIdx)
        {
            // Correct and selected
            if (correctAnswers.Contains(ansIdx) && selectedAnswers.Contains(ansIdx))
                score += scoreCorrectAnswer;
            // Correct and not selected
            else if (correctAnswers.Contains(ansIdx) && !selectedAnswers.Contains(ansIdx))
                score += scoreIncorrectAnswer;
            // Incorrect and selected
            else if (!correctAnswers.Contains(ansIdx) && selectedAnswers.Contains(ansIdx))
                score += scoreIncorrectAnswer;
            // Incorrect and not selected
            else
                score += scoreCorrectAnswer;
        }
        int profAtomIdx = questions[questionIdx].getProfessorAtomIdx();
        if (profAtomIdx != -1 && selectedAnswers.Contains(profAtomIdx))
            score += scoreForProfessorAtom;
        return score;
    }

    /// <summary>
    /// Compares selected answers with correct answers
    /// </summary>
    /// <param name="selectedAnswers">List of selected answers</param>
    /// <param name="correctAnswers">Array of correct answers</param>
    /// <returns></returns>
    private bool IsAnswerCorrect(List<int> selectedAnswers, int[] correctAnswers)
    {
        HashSet<int> correctAnswersSet = new HashSet<int>(new List<int>(correctAnswers));
        return correctAnswersSet.SetEquals(selectedAnswers);
    }

}