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

public class Quiz2Controller : MonoBehaviour {

    public Text counterText;

    public Text scoreText;

    public GameObject[] answerModels;

    public GameObject haloEffectRed;

    public GameObject haloEffectGreen;

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

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

    private List<GameObject> answersGreenHaloEffects;

    private const int numberOfAnswers = 2;

    private const int scoreCorrectAnswer = 10;

    private const int scoreIncorrectAnswer = -10;

    private const float counterInitialValue = 90;

    private float counterValue;

    private int scoreValue;

    private int questionIdx;

    private int selectedAnswerIdx;

    private const float counterDisplayAnswersTotalValue = 1.5f;

    private float counterDisplayAnswersValue;

    private bool counterDisplayAnswersStarted = false;

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

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

    // List of questions and correct answers
    List<Question> questions = new List<Question>() {
            new Question(new int[] {2},
                new Answer[] {
                    new Answer(AnswerObjectModel.ZARNA_SIJALICA, "Sijalica"),
                    new Answer(AnswerObjectModel.STEDNA_SIJALICA, "Štedna sijalica")}),
            new Question(new int[] {1},
                new Answer[] {
                    new Answer(AnswerObjectModel.KLIMA, "Klima"),
                    new Answer(AnswerObjectModel.VENTILATOR, "Ventilator")}),
            new Question(new int[] {2},
                new Answer[] {
                    new Answer(AnswerObjectModel.STRUJA, "Struja"),
                    new Answer(AnswerObjectModel.SOLARNI_PANEL, "Solarni panel")}),
            new Question(new int[] {2},
                new Answer[] {
                    new Answer(AnswerObjectModel.AUTO, "Auto"),
                    new Answer(AnswerObjectModel.BICIKLO, "Biciklo")}),
            new Question(new int[] {2},
                new Answer[] {
                    new Answer(AnswerObjectModel.PAPIRI, "Papiri"),
                    new Answer(AnswerObjectModel.EMAIL, "Email")}),
            new Question(new int[] {2},
                new Answer[] {
                    new Answer(AnswerObjectModel.STARI_PROZOR, "Stari prozor"),
                    new Answer(AnswerObjectModel.NOVI_PROZOR, "Novi prozor")}),
            new Question(new int[] {2},
                new Answer[] {
                    new Answer(AnswerObjectModel.KANTA_ZA_SMECE, "Kanta za smeće"),
                    new Answer(AnswerObjectModel.KANTA_ZA_RECIKLIRANJE, "Kanta za recikliranje")}),
            new Question(new int[] {2},
                new Answer[] {
                    new Answer(AnswerObjectModel.FRIZIDER, "Frižider"),
                    new Answer(AnswerObjectModel.FRIZIDER_PLUS, "Frižider A++")}),
            new Question(new int[] {2},
                new Answer[] {
                    new Answer(AnswerObjectModel.TERMOSTAT_28, "Termostat 28°C"),
                    new Answer(AnswerObjectModel.TERMOSTAT_25, "Termostat 25°C")}),
            new Question(new int[] {1},
                new Answer[] {
                    new Answer(AnswerObjectModel.TAMNA_FASADA, "Tamna fasada"),
                    new Answer(AnswerObjectModel.SVIJETLA_FASADA, "Svijetla fasada")}),
            new Question(new int[] {2},
                new Answer[] {
                    new Answer(AnswerObjectModel.PROZOR_BEZ_ROLETNE, "Prozor sa dignutom roletnom"),
                    new Answer(AnswerObjectModel.PROZOR_SA_ROLETNOM, "Prozor sa spuštenom roletnom")}),
            new Question(new int[] {2},
                new Answer[] {
                    new Answer(AnswerObjectModel.PLASTICNA_KESA, "Plastična kesa"),
                    new Answer(AnswerObjectModel.CEKER, "Ceker")}),
            new Question(new int[] {2},
                new Answer[] {
                    new Answer(AnswerObjectModel.RUCNO_PRANJE_SUDJA, "Pranje suđa na ruke"),
                    new Answer(AnswerObjectModel.MASINA_ZA_SUDJE, "Mašina za suđe")}),
            new Question(new int[] {2},
                new Answer[] {
                    new Answer(AnswerObjectModel.UPALJENA_CESMA, "Voda curi dok četkaš zube"),
                    new Answer(AnswerObjectModel.UGASENA_CESMA, "Gasiš vodu dok četkaš zube")}),
            new Question(new int[] {1},
                new Answer[] {
                    new Answer(AnswerObjectModel.STRIK, "Štrik"),
                    new Answer(AnswerObjectModel.SUSILICA, "Sušilica za veš")}),
    };


    // Use this for initialization
    void Start () {
        // Init counters and score
        questionIdx = 0;
        scoreValue = 0;
        counterValue = counterInitialValue;
        counterDisplayAnswersValue = 0;
        counterDisplayAnswersStarted = false;
        answers = new List<GameObject>();
        answersRedHaloEffects = new List<GameObject>();
        answersGreenHaloEffects = new List<GameObject>();
        UpdateCounter();
        UpdateScore(true);
        InstantiateAnswers();
        InstantiateRedHaloPrefabs();
        InstantiateGreenHaloPrefabs();
        UpdateScene();
    }
	
	// Update is called once per frame
	void Update ()
    {
        Debug.Log(counterDisplayAnswersValue.ToString());
        // Main counter
        // Game over
        if (counterValue < 0)
        {
            SceneManager.LoadScene("EntryScene");
            return;
        }
            
        counterValue -= Time.deltaTime;
        UpdateCounter();

        // Load next pair
        if((counterDisplayAnswersValue > counterDisplayAnswersTotalValue) && counterDisplayAnswersStarted)
        {
            // Load next pair
            LoadNextPair();
        }

        if (counterDisplayAnswersValue < counterDisplayAnswersTotalValue && counterDisplayAnswersStarted)
            counterDisplayAnswersValue += Time.deltaTime;


        // 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);
                counterDisplayAnswersStarted = true;
                // Set glow
                selectedAnswerIdx = GetAnswerIdx(hit.transform.gameObject.name);
                SetGlowEffect(selectedAnswerIdx, true, IsAnswerCorrect(selectedAnswerIdx, questions[questionIdx].getCorrectAnswers()));
                // Update score
                UpdateScore();
            }
        }
    }

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

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

    /// <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>
    /// Adds red Halo prefabs to all answers
    /// </summary>
    private void InstantiateRedHaloPrefabs()
    {
        for (int i = 0; i < answers.Count; i++)
        {
            GameObject answerPrefab = Instantiate(haloEffectRed) as GameObject;
            answerPrefab.SetActive(false);
            answerPrefab.transform.SetParent(answers[i].transform, false);
            answersRedHaloEffects.Add(answerPrefab);
        }
    }

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

    void LoadNextPair()
    {
        counterDisplayAnswersValue = 0;
        counterDisplayAnswersStarted = false;
        ClearCurrentSceneGlowEffect();
        questionIdx = questionIdx + 1;
        if (questionIdx == questions.Count)
            SceneManager.LoadScene("EntryScene");
        else
            UpdateScene();
    }

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

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

    /// <summary>
    /// Updates scene with new question and related answers
    /// </summary>
    private void UpdateScene()
    {
        // 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>
    /// 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()
    {
        return IsAnswerCorrect(selectedAnswerIdx, questions[questionIdx].getCorrectAnswers()) ? scoreCorrectAnswer : scoreIncorrectAnswer;
    }

    private bool IsAnswerCorrect(int selectedAnswerIdx, int[] correctAnswers)
    {
        return ((selectedAnswerIdx % 2) ^ (correctAnswers[0] % 2)) == 0;
    }

}