using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public enum UpgradeTypes
{
    ENEMY_HEALTH,
    ENEMY_DAMAGE,
    ENEMY_ARMOR,
    MANA_COST,
}

class UpgradeData
{
    public Upgrade upgrade;
    public int count;

    public int GetUnadjustedNextUpgradeCost()
    {
        return (int)(upgrade.baseCost * (1 + count * upgrade.costMultiplier));
    }

    public float GetTotalEffectMultiplier()
    {
        return 1 + count * upgrade.effectMultiplier;
    }
}

public class StatsManager : MonoBehaviour
{

    public static StatsManager instance { get; private set; }

    EnemyStats currentEnemyStats;
    PlayerStats currentPlayerStats;
    [SerializeField] int currentMana;

    [SerializeField] List<Upgrade> availableUpgrades;
    Dictionary<UpgradeTypes, UpgradeData> upgrades = new Dictionary<UpgradeTypes, UpgradeData>();

    public EnemyStats GetEnemyStats()
    {
        return currentEnemyStats;
    }

    public PlayerStats GetPlayerStats(int stage)
    {
        // TODO use `stage`
        return currentPlayerStats;
    }

    public int GetMana()
    {
        return currentMana;
    }

    // Adjusts the given Mana cost based on the amount of Mana cost upgrades currently bought.
    public int GetAdjustedManaCost(int cost)
    {
        return (int)(cost * upgrades[UpgradeTypes.MANA_COST].GetTotalEffectMultiplier());
    }

    public int GetNextUpgradeCost(UpgradeTypes type)
    {
        return GetAdjustedManaCost(upgrades[type].GetUnadjustedNextUpgradeCost());
    }

    // Buys an upgrade, spending the required amount of Mana in the process. Returns false if not enough Mana is available.
    public bool BuyUpgrade(UpgradeTypes type)
    {
        if (!ModifyMana(GetNextUpgradeCost(type)))
        {
            return false;
        }
        upgrades[type].count++;
        RecalculateStatMultipliers();
        return true;
    }

    // Add (positive value) or spend (negative value) Mana.
    public bool ModifyMana(int delta)
    {
        if (currentMana + delta < 0)
        {
            return false;
        }
        currentMana += delta;
        return true;
    }

    void RecalculateStatMultipliers()
    {
        currentEnemyStats.healthMultiplier = upgrades[UpgradeTypes.ENEMY_HEALTH].GetTotalEffectMultiplier();
        currentEnemyStats.damageMultiplier = upgrades[UpgradeTypes.ENEMY_DAMAGE].GetTotalEffectMultiplier();
        currentEnemyStats.armorMultiplier = upgrades[UpgradeTypes.ENEMY_ARMOR].GetTotalEffectMultiplier();
    }

    void Awake()
    {
        if (instance == null)
        {
            instance = this;
        }
        else if (instance != this)
        {
            Destroy(gameObject);
        }
        DontDestroyOnLoad(gameObject);

        foreach (Upgrade upgrade in availableUpgrades)
        {
            UpgradeData upgradeData = new UpgradeData();
            upgrades.Add(upgrade.type, upgradeData);
        }

        currentEnemyStats.healthMultiplier = 1f;
        currentEnemyStats.damageMultiplier = 1f;
        currentEnemyStats.armorMultiplier = 1f;
        currentPlayerStats.healthMultiplier = 1f;
        currentPlayerStats.damageMultiplier = 1f;
        currentPlayerStats.armorMultiplier = 1f;
    }
}

public struct EnemyStats
{
    public float healthMultiplier;
    public float damageMultiplier;
    public float armorMultiplier;
}

public struct PlayerStats
{
    public float healthMultiplier;
    public float damageMultiplier;
    public float armorMultiplier;
}