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

public class UnlockSystem : MonoBehaviour
{
    private GameObject unlockButton;
    public GameObject unlockPanel;
    private float playerScore;
    private ScoreManager scoreMgr;
    private DeathWall dWall;
    private SoundManager soundMgr;
    private ApplyForceToPlayer applyForce;
    private ApplyForceTouch applyForceTouch;
    private ApplyForceController applyForceController;
    private LevelGenerator levelGen;
    private AchievementSystem achSys;
    public Material trailParticleMat;
    private bool chillModeEnabled;

    private struct trailPreset
    {
        public float maxTrailWidth;
        public List<float> graphXPositions;
        public List<float> graphYPositions;
        public float trailTime;
        public float alphaPosition;
    };

    trailPreset defaultTrail = new trailPreset();
    trailPreset curvedTrail = new trailPreset();
    trailPreset longTrail = new trailPreset();
    trailPreset thickTrail = new trailPreset();

    public TextMeshProUGUI highScoreText;
    public Sprite defaultPlayerSprite;
    public GameObject defaultPlayerDeathParticles;
    public GameObject defaultPlayerImpactParticles;
    public TMP_Dropdown lightColorDrop;
    public TMP_Dropdown playerColorDrop;
    public TMP_Dropdown trailColorDrop;

    public GameObject unlocksGrid;
    private List<GameObject> unlockBarriers = new List<GameObject>();
    private List<GameObject> unlockButtons = new List<GameObject>();
    private List<GameObject> unlockChecks = new List<GameObject>();
    private List<TextMeshProUGUI> unlockCosts = new List<TextMeshProUGUI>();

    public string[] unlockTracks = new string[4];
    public AudioClip[] defaultImpactSounds = new AudioClip[12];
    public AudioClip[] impactSoundPackOne = new AudioClip[12];
    public AudioClip[] impactSoundPackTwo = new AudioClip[12];
    public int unlockIncrement;

    private GameObject playerObject;
    private Light playerLight;
    private PlayerColorTransition pColorTrans;
    private MultipleAudioClips playerImpactSounds;

    private Color[] playerLightColors = new Color[]
    {
        new Color(1, 1, 1, 1), //white
        new Color(0, 1, 0, 1), //green
        new Color(0, 0.75f, 1, 1), //blue
        new Color(1, 0, 0, 1), //red
        new Color(1, 0.67f, 0, 1), //orange
        new Color(1, 0.95f, 0, 1), //gold
        new Color(1, 0.32f, 0.93f, 1), //pink
        new Color(0.56f, 0, 1, 1) //purple
    };

    private void Awake()
    {
        //values for default trail
        defaultTrail.maxTrailWidth = 0.9f;
        defaultTrail.graphXPositions = new List<float>();
        defaultTrail.graphYPositions = new List<float>();
        defaultTrail.graphXPositions.Add(0);
        defaultTrail.graphXPositions.Add(0.139f);
        defaultTrail.graphXPositions.Add(0.524f);
        defaultTrail.graphXPositions.Add(1);
        defaultTrail.graphYPositions.Add(1);
        defaultTrail.graphYPositions.Add(0.547f);
        defaultTrail.graphYPositions.Add(0.211f);
        defaultTrail.graphYPositions.Add(0);
        defaultTrail.trailTime = 0.5f;
        defaultTrail.alphaPosition = 0.141f;

        //values for curved trail
        curvedTrail.maxTrailWidth = 1;
        curvedTrail.graphXPositions = new List<float>();
        curvedTrail.graphYPositions = new List<float>();
        curvedTrail.graphXPositions.Add(0);
        curvedTrail.graphXPositions.Add(0.161f);
        curvedTrail.graphXPositions.Add(0.300f);
        curvedTrail.graphXPositions.Add(0.429f);
        curvedTrail.graphXPositions.Add(0.587f);
        curvedTrail.graphXPositions.Add(1);
        curvedTrail.graphYPositions.Add(0.783f);
        curvedTrail.graphYPositions.Add(0.867f);
        curvedTrail.graphYPositions.Add(0.623f);
        curvedTrail.graphYPositions.Add(0.711f);
        curvedTrail.graphYPositions.Add(0.251f);
        curvedTrail.graphYPositions.Add(0);
        curvedTrail.trailTime = 0.5f;
        curvedTrail.alphaPosition = 0.279f;

        //values for long trail
        longTrail.maxTrailWidth = 0.9f;
        longTrail.graphXPositions = new List<float>();
        longTrail.graphYPositions = new List<float>();

        longTrail.graphXPositions.Add(0);
        longTrail.graphXPositions.Add(0.164f);
        longTrail.graphXPositions.Add(0.417f);
        longTrail.graphXPositions.Add(1);

        longTrail.graphYPositions.Add(1);
        longTrail.graphYPositions.Add(0.463f);
        longTrail.graphYPositions.Add(0.155f);
        longTrail.graphYPositions.Add(0);

        longTrail.trailTime = 1f;
        longTrail.alphaPosition = 0.376f;

        //values for thick trail
        thickTrail.maxTrailWidth = 1.2f;
        thickTrail.graphXPositions = new List<float>();
        thickTrail.graphYPositions = new List<float>();

        thickTrail.graphXPositions.Add(0);
        thickTrail.graphXPositions.Add(0.183f);
        thickTrail.graphXPositions.Add(0.529f);
        thickTrail.graphXPositions.Add(1);

        thickTrail.graphYPositions.Add(1);
        thickTrail.graphYPositions.Add(0.602f);
        thickTrail.graphYPositions.Add(0.211f);
        thickTrail.graphYPositions.Add(0);

        thickTrail.trailTime = 0.6f;
        thickTrail.alphaPosition = 0.365f;

    }


    private void Start()
    {
        unlockButton = GUIManager.GetObject(15);
        scoreMgr = GetComponent<ScoreManager>();
        dWall = ObjectManager.GetObject(2).GetComponent<DeathWall>();
        soundMgr = GetComponent<SoundManager>();
        playerObject = ObjectManager.GetObject(0);
        pColorTrans = playerObject.GetComponent<PlayerColorTransition>();
        playerImpactSounds = playerObject.GetComponent<MultipleAudioClips>();
        applyForce = ObjectManager.GetObject(3).GetComponent<ApplyForceToPlayer>();
        applyForceTouch = ObjectManager.GetObject(3).GetComponent<ApplyForceTouch>();
        applyForceController = ObjectManager.GetObject(3).GetComponent<ApplyForceController>();
        levelGen = GetComponent<LevelGenerator>();
        achSys = ObjectManager.GetObject(4).GetComponent<AchievementSystem>();

        playerColorDrop.value = 1;
        lightColorDrop.value = 0;
        trailColorDrop.value = 2;

        foreach (RectTransform child in unlocksGrid.GetComponentsInChildren<RectTransform>())
        {
            if (child.name.Contains("Unlock Button"))
            {
                RectTransform[] buttonParts = child.GetComponentsInChildren<RectTransform>();

                for (int i = 0; i < buttonParts.Length; i++)
                {
                    if (buttonParts[i].name == "Unlock Image")
                    {
                        unlockButtons.Add(buttonParts[i].gameObject);
                    }

                    if (buttonParts[i].name == "Check Mark")
                    {
                        unlockChecks.Add(buttonParts[i].gameObject);
                        buttonParts[i].gameObject.SetActive(false);
                    }

                    if (buttonParts[i].name == "Cost Text")
                    {
                        unlockCosts.Add(buttonParts[i].GetComponent<TextMeshProUGUI>());
                    }

                    if (buttonParts[i].name == "Lock")
                    {
                        unlockBarriers.Add(buttonParts[i].gameObject);
                    }
                }
            }
        }

        foreach (Transform child in playerObject.GetComponentsInChildren<Transform>())
        {
            if (child.name == "Glow")
            {
                playerLight = child.GetComponent<Light>();
                break;
            }
        }

        SetUnlockCostTexts();
    }

    private void Update()
    {
        if (unlockButton.GetComponent<Button>().interactable == true)
        {
            if (playerObject.transform.position.y + 3.5 > dWall.movementThreshold)
            {
                unlockButton.GetComponent<Animator>().SetTrigger("fadeOut");
                unlockPanel.SetActive(false);

                if (unlockButton.GetComponent<Animator>().GetCurrentAnimatorStateInfo(0).IsName("Idle"))
                {
                    unlockButton.GetComponent<Button>().interactable = false;
                }
            }
        }
    }

    public void SetUnlockCostTexts()
    {
        int costValue = unlockIncrement;

        for (int i = 0; i < 24; i++)
        {
            unlockCosts[i].text = costValue.ToString();
            costValue += unlockIncrement;
        }
    }

    public void SetChillModeState(bool state)
    {
        chillModeEnabled = state;
    }

    public void ActivateUnlocksButton()
    {
        unlockButton.GetComponent<Button>().interactable = true;
        unlockButton.GetComponent<Animator>().SetTrigger("fadeIn");
    }

    public void CheckHighestScore()
    {
        playerScore = scoreMgr.GetHighestScoreAchieved();

        highScoreText.text = "Session Score: " + playerScore;

        int index = 0;
        int maxUnlockScore = unlockIncrement * 24;

        for (int i = unlockIncrement; (i <= playerScore && i <= maxUnlockScore); i += unlockIncrement)
        {
            if (unlockBarriers[index] != null)
            {
                unlockBarriers[index].SetActive(false);
                unlockButtons[index].GetComponent<Button>().interactable = true;
                index++;
            }
            else
                break;
        }

        if (playerScore >= maxUnlockScore)
            achSys.SetAllUnlocksGot(true);

        if (!unlockBarriers[9].activeSelf && !unlockBarriers[16].activeSelf && !unlockBarriers[19].activeSelf)
            achSys.SetAllColorDropsGot(true);

        //for all unlock barriers after the last indexed one, lock them.
        for (int i = index; i < 24; i++)
        {
            if (unlockBarriers[i] != null)
            {
                unlockBarriers[i].SetActive(true);
                unlockButtons[i].GetComponent<Button>().interactable = false;
            }
        }
    }

    public void ApplyScoreBoost(int boostAmt)
    {
        scoreMgr.SetBoostAmount(boostAmt);
    }

    public void ApplySpeedBoost()
    {
        if (applyForce.enabled)
            applyForce.SetUnlockBoosted(true);
        else if (applyForceTouch.enabled)
            applyForceTouch.SetUnlockBoosted(true);
        else if (applyForceController.enabled)
            applyForceController.SetUnlockBoosted(true);
    }

    public void EnableSlowMotion()
    {
        //call to the player object to enable the slow motion script
        playerObject.GetComponent<SlowMotionAbility>().enabled = true;
    }

    public void ChangeScoreGainParticles(int systemID)
    {
        //call to GUIManager to change particle system
        GUIManager.SetNewScoreParticleSystem(systemID);
    }

    public void ChangePlayerModel(Sprite newSprite)
    {
        playerObject.GetComponent<SpriteRenderer>().sprite = newSprite;

        string spriteName = newSprite.name;

        if (spriteName.Contains("Square"))
        {
            playerObject.GetComponent<CircleCollider2D>().enabled = false;

            playerObject.GetComponent<BoxCollider2D>().enabled = true;
        }
        else if (spriteName.Contains("Hexagon") || spriteName.Contains("Diamond"))
        {
            if (playerObject.GetComponent<PolygonCollider2D>())
                Destroy(playerObject.GetComponent<PolygonCollider2D>());

            playerObject.GetComponent<CircleCollider2D>().enabled = false;

            playerObject.AddComponent<PolygonCollider2D>();

            playerObject.GetComponent<PolygonCollider2D>().enabled = true;
            playerObject.GetComponent<BoxCollider2D>().enabled = false;
        }
        else if (spriteName.Contains("Circle"))
        {
            playerObject.GetComponent<CircleCollider2D>().enabled = true;

            playerObject.GetComponent<BoxCollider2D>().enabled = false;
        }
    }

    public void ChangePlayerTrail(int presetID)
    {
        AnimationCurve newCurve = new AnimationCurve();
        TrailRenderer playerTrail = playerObject.GetComponent<TrailRenderer>();

        switch (presetID)
        {
            case 0:
                newCurve.AddKey(defaultTrail.graphXPositions[0], defaultTrail.graphYPositions[0]);
                newCurve.AddKey(defaultTrail.graphXPositions[1], defaultTrail.graphYPositions[1]);
                newCurve.AddKey(defaultTrail.graphXPositions[2], defaultTrail.graphYPositions[2]);
                newCurve.AddKey(defaultTrail.graphXPositions[3], defaultTrail.graphYPositions[3]);

                playerTrail.widthCurve = newCurve;
                playerTrail.widthMultiplier = defaultTrail.maxTrailWidth;
                playerTrail.time = defaultTrail.trailTime;
                playerTrail.colorGradient.alphaKeys[1].time = defaultTrail.alphaPosition;

                break;

            case 1:
                newCurve.AddKey(thickTrail.graphXPositions[0], thickTrail.graphYPositions[0]);
                newCurve.AddKey(thickTrail.graphXPositions[1], thickTrail.graphYPositions[1]);
                newCurve.AddKey(thickTrail.graphXPositions[2], thickTrail.graphYPositions[2]);
                newCurve.AddKey(thickTrail.graphXPositions[3], thickTrail.graphYPositions[3]);

                playerTrail.widthCurve = newCurve;
                playerTrail.widthMultiplier = thickTrail.maxTrailWidth;
                playerTrail.time = thickTrail.trailTime;
                playerTrail.colorGradient.alphaKeys[1].time = thickTrail.alphaPosition;

                break;

            case 2:
                newCurve.AddKey(longTrail.graphXPositions[0], longTrail.graphYPositions[0]);
                newCurve.AddKey(longTrail.graphXPositions[1], longTrail.graphYPositions[1]);
                newCurve.AddKey(longTrail.graphXPositions[2], longTrail.graphYPositions[2]);
                newCurve.AddKey(longTrail.graphXPositions[3], longTrail.graphYPositions[3]);

                playerTrail.widthCurve = newCurve;
                playerTrail.widthMultiplier = longTrail.maxTrailWidth;
                playerTrail.time = longTrail.trailTime;
                playerTrail.colorGradient.alphaKeys[1].time = longTrail.alphaPosition;

                break;

            case 3:
                newCurve.AddKey(curvedTrail.graphXPositions[0], curvedTrail.graphYPositions[0]);
                newCurve.AddKey(curvedTrail.graphXPositions[1], curvedTrail.graphYPositions[1]);
                newCurve.AddKey(curvedTrail.graphXPositions[2], curvedTrail.graphYPositions[2]);
                newCurve.AddKey(curvedTrail.graphXPositions[3], curvedTrail.graphYPositions[3]);
                newCurve.AddKey(curvedTrail.graphXPositions[4], curvedTrail.graphYPositions[4]);
                newCurve.AddKey(curvedTrail.graphXPositions[5], curvedTrail.graphYPositions[5]);

                playerTrail.widthCurve = newCurve;
                playerTrail.widthMultiplier = curvedTrail.maxTrailWidth;
                playerTrail.time = curvedTrail.trailTime;
                playerTrail.colorGradient.alphaKeys[1].time = curvedTrail.alphaPosition;

                break;
        }
    }

    public void ChangePlayerTrailColor()
    {
        Color newColor = playerLightColors[trailColorDrop.value];

        trailParticleMat.EnableKeyword("_EMISSION");
        trailParticleMat.SetColor("_EmissionColor", newColor);
        playerObject.GetComponent<PlayerTrailParticles>().SetParticleColor(newColor);

        newColor.a = 0;

        playerObject.GetComponent<TrailRenderer>().startColor = newColor;
        playerObject.GetComponent<TrailRenderer>().endColor = newColor;

    }

    public void ChangePlayerLightColor()
    {
        //may want to also change intensity of light based on color
        playerLight.color = playerLightColors[lightColorDrop.value];
    }

    public void ChangePlayerColor()
    {
        pColorTrans.PlayerColor = playerLightColors[playerColorDrop.value];
        pColorTrans.EndingColor = playerLightColors[playerColorDrop.value];
    }

    public void ChangePlayerDeathParticles(GameObject newParticles)
    {
        playerObject.GetComponent<PlayerDeathEffects>().SetDeathParticles(newParticles);
    }

    public void ChangePlayerImpactParticles(GameObject newParticles)
    {
        playerObject.GetComponent<PlayerImpactEffect>().SetNewImpactParticles(newParticles);
    }

    public void AddSongToLibrary(int trackID)
    {
        soundMgr.AddMusicToLibrary(unlockTracks[trackID]);
    }

    public void ChangeImpactSounds(int listID)
    {
        switch (listID)
        {
            default:
                playerImpactSounds.SetClips(defaultImpactSounds.ToList());
                break;
            case 0:
                playerImpactSounds.SetClips(impactSoundPackOne.ToList());
                break;
            case 1:
                playerImpactSounds.SetClips(impactSoundPackTwo.ToList());
                break;
        }
    }

    public void ChangeBackground()
    {
        //call to the level gen to change the background of all created tiles.
        levelGen.ChangeAllTilesBackgroundMaterials();
    }

    public void ResetCosmetics()
    {
        playerColorDrop.value = 1;
        lightColorDrop.value = 0;
        trailColorDrop.value = 2;

        playerObject.GetComponent<SpriteRenderer>().sprite = defaultPlayerSprite;
        playerObject.GetComponent<SpriteRenderer>().color = Color.green;
        pColorTrans.PlayerColor = Color.green;
        ChangePlayerTrail(0);
        playerObject.GetComponent<TrailRenderer>().startColor = new Color(0, 0.79f, 1, 0);
        playerObject.GetComponent<TrailRenderer>().endColor = new Color(0, 0.79f, 1, 0);
        playerLight.color = Color.white;
        playerImpactSounds.SetClips(defaultImpactSounds.ToList());
        playerObject.GetComponent<PlayerDeathEffects>().SetDeathParticles(defaultPlayerDeathParticles);
        playerObject.GetComponent<PlayerImpactEffect>().SetNewImpactParticles(defaultPlayerImpactParticles);
        GUIManager.SetNewScoreParticleSystem(0);
        ChangeImpactSounds(-1);

        unlockChecks[0].SetActive(false);
        unlockChecks[1].SetActive(false);
        unlockChecks[2].SetActive(false);
        unlockChecks[3].SetActive(false);
        unlockChecks[4].SetActive(false);
        unlockChecks[6].SetActive(false);
        unlockChecks[7].SetActive(false);
        unlockChecks[11].SetActive(false);
        unlockChecks[12].SetActive(false);
        unlockChecks[14].SetActive(false);
        unlockChecks[15].SetActive(false);
        unlockChecks[18].SetActive(false);
        unlockChecks[20].SetActive(false);
        unlockChecks[21].SetActive(false);

        playerObject.GetComponent<CircleCollider2D>().enabled = true;

        if (playerObject.GetComponent<BoxCollider2D>())
            playerObject.GetComponent<BoxCollider2D>().enabled = false;

        if (playerObject.GetComponent<PolygonCollider2D>())
            playerObject.GetComponent<PolygonCollider2D>().enabled = false;

        levelGen.RevertAllBackgroundMaterials();
    }

    public void ResetAddedSongs()
    {
        soundMgr.RemoveMusicFromLibrary(unlockTracks);

        unlockChecks[5].SetActive(false);
        unlockChecks[10].SetActive(false);
        unlockChecks[17].SetActive(false);
    }

    public void ResetBoosts()
    {
        //remove any score or speed boosts
        applyForce.SetUnlockBoosted(false);
        applyForceController.SetUnlockBoosted(false);
        applyForceTouch.SetUnlockBoosted(false);
        scoreMgr.SetBoostAmount(0);
        playerObject.GetComponent<SlowMotionAbility>().enabled = false;

        unlockChecks[8].SetActive(false);
        unlockChecks[13].SetActive(false);
        unlockChecks[22].SetActive(false);
        unlockChecks[23].SetActive(false);
    }
}