using System.Collections.Generic;
using System.Threading;
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

public class GUIManager : MonoBehaviour
{
    private Slider staminaBar;
    private Slider healthBar;
    private GameObject[] barrierBars = new GameObject[4];
    private GameObject[] barrierBarsUpgraded = new GameObject[4];
    private Image[] keyImages = new Image[3];
    private GameObject[] levelSelectButtons = new GameObject[21];
    private GameObject playerObject;
    private GameManager gameMgr;
    private GameObject escapeMenu;
    private GameObject deathScreen;
    private GameObject escapeMenuSettings;
    private GameObject introOutroScreen;
    private GameObject introScreen;
    private GameObject outroScreen;
    private GameObject loreScreen;
    private GameObject tutorialScreen;
    private GameObject gamePlayScreen;
    private Text levelNameText;
    private KeyCode openEscapeMenu;

    private float currentStamina, currentHealth, currentBarrierCharge;
    private bool escapeMenuDisabled;
    private bool gamePlayMenuActivated;

    private void Awake()
    {
        gameMgr = GetComponent<GameManager>();
        openEscapeMenu = InputManager.GetInputKey(7);
    }

    private void Start()
    {
        SceneManager.sceneLoaded += OnSceneLoaded;

        if (SceneManager.GetActiveScene().name == "Main Menu")
            SetMainMenuReferences();
    }

    void OnSceneLoaded(Scene scene, LoadSceneMode mode)
    {
        if (scene.name == "Main Menu")
        {
            SetMainMenuReferences();
        }
        else
        {
            SetLevelReferences();
        }
    }

    private void Update()
    {
        if (escapeMenu != null)
        {
            int sceneIndex = SceneManager.GetActiveScene().buildIndex;

            if (sceneIndex == 1 || sceneIndex == 4 || sceneIndex == 7 || sceneIndex == 10 || sceneIndex == 13 || sceneIndex == 16 || sceneIndex == 19)
            {
                if (Input.GetKeyDown(openEscapeMenu) && !escapeMenuDisabled && !introScreen.activeSelf && !outroScreen.activeSelf && !loreScreen.activeSelf && !deathScreen.activeSelf)
                {
                    ChangeEscapeMenuState(!escapeMenu.activeSelf);
                }

                if (escapeMenu.activeSelf && (deathScreen.activeSelf || introScreen.activeSelf || outroScreen.activeSelf || loreScreen.activeSelf))
                {
                    ChangeEscapeMenuState(false);
                }
            }
            else
            {
                if (Input.GetKeyDown(openEscapeMenu) && !escapeMenuDisabled && !introScreen.activeSelf && !outroScreen.activeSelf && !deathScreen.activeSelf)
                {
                    ChangeEscapeMenuState(!escapeMenu.activeSelf);
                }

                if (escapeMenu.activeSelf && (deathScreen.activeSelf || introScreen.activeSelf || outroScreen.activeSelf))
                {
                    ChangeEscapeMenuState(false);
                }
            }
        }

        if (staminaBar != null)
        {
            float stamina = playerObject.GetComponent<PlayerMove>().GetPlayerStamina();

            if (stamina != currentStamina)
            {
                currentStamina = stamina;
                staminaBar.value = currentStamina;
            }
        }

        if(introOutroScreen != null)
        {
            if(introOutroScreen.GetComponent<IntroOutroInfo>().GetIntroPanel().GetComponent<FadeInOrOut>().GetFadeState() && !gamePlayMenuActivated)
            {
                gamePlayScreen.SetActive(true);
                tutorialScreen.SetActive(true);
                gamePlayMenuActivated = true;
            }
        }

        if (healthBar != null)
        {
            float health = playerObject.GetComponent<Health>().GetCurrentHealth();

            if (health != currentHealth)
            {
                currentHealth = health;
                healthBar.value = currentHealth;
            }
        }

        if (levelNameText != null)
        {
            if (levelNameText.text != ProgressTracker.GetLevelName(SceneManager.GetActiveScene().buildIndex - 1))
                levelNameText.text = ProgressTracker.GetLevelName(SceneManager.GetActiveScene().buildIndex - 1);
        }

        if (barrierBars[0] != null || barrierBarsUpgraded[0] != null)
        {
            if (playerObject.GetComponent<BarrierTool>().enabled)
            {
                if (playerObject.GetComponent<BarrierTool>().GetBarrierUpgradeState())
                {
                    if (!barrierBarsUpgraded[0].activeSelf)
                    {
                        foreach (GameObject barrierBar in barrierBarsUpgraded)
                            barrierBar.SetActive(true);

                        foreach (GameObject barrierBar in barrierBars)
                            barrierBar.SetActive(false);
                    }

                    barrierBarsUpgraded = SetBarrierBarsCharge(barrierBarsUpgraded);
                }
                else
                {
                    if (!barrierBars[0].activeSelf)
                    {
                        foreach (GameObject barrierBar in barrierBars)
                            barrierBar.SetActive(true);

                        foreach (GameObject barrierBar in barrierBarsUpgraded)
                            barrierBar.SetActive(false);
                    }

                    barrierBars = SetBarrierBarsCharge(barrierBars);
                }
            }
        }

        if (keyImages[0] != null)
            UpdateKeys();
    }

    public void SetLevelReferences()
    {
        staminaBar = GameObject.Find("Stamina Bar").GetComponent<Slider>();
        healthBar = GameObject.Find("Health Bar").GetComponent<Slider>();
        barrierBars[0] = GameObject.Find("Barrier Bar");
        barrierBars[1] = GameObject.Find("Barrier Bar (1)");
        barrierBars[2] = GameObject.Find("Barrier Bar (2)");
        barrierBars[3] = GameObject.Find("Barrier Bar (3)");
        barrierBarsUpgraded[0] = GameObject.Find("Barrier Bar - Upgraded");
        barrierBarsUpgraded[1] = GameObject.Find("Barrier Bar (1) - Upgraded");
        barrierBarsUpgraded[2] = GameObject.Find("Barrier Bar (2) - Upgraded");
        barrierBarsUpgraded[3] = GameObject.Find("Barrier Bar (3) - Upgraded");
        playerObject = GameObject.Find("Player Object");
        keyImages[0] = GameObject.Find("Key Image").GetComponent<Image>();
        keyImages[1] = GameObject.Find("Key Image (1)").GetComponent<Image>();
        keyImages[2] = GameObject.Find("Key Image (2)").GetComponent<Image>();
        escapeMenu = GameObject.Find("Escape Menu UI");
        deathScreen = GameObject.Find("Death UI");
        gamePlayScreen = GameObject.Find("GamePlay UI");
        loreScreen = GameObject.Find("Lore UI");
        tutorialScreen = GameObject.Find("Tutorial UI");
        introOutroScreen = GameObject.Find("Intro_Outro UI");
        introScreen = GameObject.Find("Intro Panel");
        outroScreen = GameObject.Find("Outro Panel");
        levelNameText = GameObject.Find("Level Name Text").GetComponent<Text>();
        foreach (Transform child in escapeMenu.GetComponentsInChildren<Transform>())
            if (child.name == "Settings Panel")
                escapeMenuSettings = child.gameObject;


        if(SceneManager.GetActiveScene().buildIndex == 1)
        {
            gamePlayScreen.SetActive(false);
            tutorialScreen.SetActive(false);
            gamePlayMenuActivated = false;
        }

        outroScreen.SetActive(false);

        if(loreScreen != null)
            loreScreen.SetActive(false);

        deathScreen.SetActive(false);
        escapeMenu.SetActive(false);
        escapeMenuSettings.SetActive(false);

        foreach (Image img in keyImages)
            img.enabled = false;

        foreach (GameObject barrier in barrierBars)
            barrier.SetActive(false);

        foreach (GameObject barrierUpgraded in barrierBarsUpgraded)
            barrierUpgraded.SetActive(false);
    }

    public void SetMainMenuReferences()
    {
        for (int i = 1; i <= levelSelectButtons.Length; i++)
        {
            levelSelectButtons[i - 1] = GameObject.Find("Level Button " + i);
        }

        levelSelectButtons[0].transform.parent.parent.gameObject.SetActive(false);

        if (levelSelectButtons[0] != null)
        {
            ProgressTracker.SetTrackerValues();

            for (int i = 0; i < levelSelectButtons.Length; i++)
            {
                if (ProgressTracker.GetLevelCompleteState(i))
                {
                    levelSelectButtons[i].GetComponent<ButtonFunctions>().DisableBlocker();
                }
            }
        }
    }

    public GameObject[] SetBarrierBarsCharge(GameObject[] bars)
    {
        float charge = playerObject.GetComponent<BarrierTool>().GetCurrentBarrierCharge();

        if (charge != currentBarrierCharge)
        {
            currentBarrierCharge = charge;

            if (currentBarrierCharge >= 0.75f)
                bars[0].GetComponent<Slider>().value = Mathf.InverseLerp(0.75f, 1.0f, currentBarrierCharge);
            else if (currentBarrierCharge >= 0.50f && currentBarrierCharge < 0.75f)
            {
                bars[0].GetComponent<Slider>().value = 0.0f;
                bars[1].GetComponent<Slider>().value = Mathf.InverseLerp(0.50f, 0.75f, currentBarrierCharge);
            }
            else if (currentBarrierCharge >= 0.25f && currentBarrierCharge < 0.50f)
            {
                bars[0].GetComponent<Slider>().value = 0.0f;
                bars[1].GetComponent<Slider>().value = 0.0f;
                bars[2].GetComponent<Slider>().value = Mathf.InverseLerp(0.25f, 0.50f, currentBarrierCharge);
            }
            else if (currentBarrierCharge >= 0 && currentBarrierCharge < 0.25f)
            {
                bars[0].GetComponent<Slider>().value = 0.0f;
                bars[1].GetComponent<Slider>().value = 0.0f;
                bars[2].GetComponent<Slider>().value = 0.0f;
                bars[3].GetComponent<Slider>().value = Mathf.InverseLerp(0.0f, 0.25f, currentBarrierCharge);
            }
        }

        return bars;
    }

    public void ResetLevelProgress()
    {
        for (int i = 1; i < levelSelectButtons.Length; i++)
        {
            ProgressTracker.SetLevelCompleteState(i, false);
            levelSelectButtons[i].GetComponent<ButtonFunctions>().EnableBlocker();
        }
    }

    public void UpdateKeys()
    {
        List<Key> playerKeys = playerObject.GetComponent<ItemInventory>().GetKeysList();

        for (int i = 0; i < playerKeys.Count; i++)
        {
            if (!keyImages[i].enabled)
            {
                keyImages[i].enabled = true;
                keyImages[i].sprite = playerKeys[i].GetItemSprite();
            }
        }
    }

    public void ChangeEscapeMenuState(bool state)
    {
        if (!deathScreen.activeSelf)
        {
            if (state == false && escapeMenuSettings.activeSelf)
                escapeMenuSettings.SetActive(false);

            escapeMenu.SetActive(state);

            if (state == true)
                Time.timeScale = 0;
            else
                Time.timeScale = 1;
        }
    }

    public void ChangeDeathScreenState(bool state)
    {
        deathScreen.SetActive(state);
    }

    public void SetNewEscapeMenuKey()
    {
        openEscapeMenu = InputManager.GetInputKey(7);
    }

    public void SetEscapeMenuState(bool state)
    {
        escapeMenuDisabled = state;
    }

    public bool GetEscapeMenuState()
    {
        return escapeMenu.activeSelf;
    }

    public void ClearLevelBlockers()
    {
        for (int i = 1; i < levelSelectButtons.Length; i++)
        {
            ProgressTracker.SetLevelCompleteState(i, true);
            levelSelectButtons[i].GetComponent<ButtonFunctions>().DisableBlocker();
        }
    }
}