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

public enum SkillID {
    BASIC_ATTACK,
    DOUBLE_JUMP,
    EXECUTION,
    BLOWBACK_SHOT,
    LIGHTNING_DASH,
    ARROW_BARRAGE,
    STUNNING_STRIKE,
}

public class SkillStats {
    public float speedModifier;
    public int maxMonstersHit;
    public float cooldown; // In seconds
    public List<int> hitboxHitCounts;
    public List<float> hitboxPowers;

    public SkillStats(float speedModifier,
                      int maxMonstersHit,
                      float cooldown,
                      List<int> hitboxHitCounts = null,
                      List<float> hitboxPowers = null) {
        this.speedModifier = speedModifier;
        this.maxMonstersHit = maxMonstersHit;
        this.cooldown = cooldown;
        this.hitboxHitCounts = hitboxHitCounts;
        this.hitboxPowers = hitboxPowers;
    }

    public string WriteUp() {
        // TODO: Implement
        return "";
    }
}

public class SkillState {
    public int skillPoints = 0;
    public Hashtable skillLevels = new Hashtable() { // Hashtable<SkillID, int>
        { SkillID.BASIC_ATTACK, 1 },
        { SkillID.EXECUTION, 5 },
        { SkillID.DOUBLE_JUMP, 5 },
        { SkillID.BLOWBACK_SHOT, 5 },
        { SkillID.LIGHTNING_DASH, 5 },
        { SkillID.ARROW_BARRAGE, 5 },
        { SkillID.STUNNING_STRIKE, 5 },
    };

    public bool LevelUp(SkillID skillID) {
        Skill skill = ((Skill)Skill.skillData[skillID]);
        if (State.state.stats.level >= skill.requiredLevel &&
            State.state.skillState.skillPoints > 0) {
            if (skillLevels.ContainsKey(skillID)) {
                int currentSkillLevel = (int)skillLevels[skillID];
                if (currentSkillLevel >= skill.maxSkillLevel) {
                    return false;
                }
                skillLevels[skillID] = currentSkillLevel + 1;
            } else {
                skillLevels[skillID] = 1;
            }
            return true;
        }
        return false;
    }

    public bool CheckSkillLevel(SkillID skillID, int minimumLevel) {
        return (int)skillLevels[skillID] >= minimumLevel;
    }
}

public class Skill {
    public int requiredLevel;
    public int maxSkillLevel;
    public List<SkillStats> statsPerLevel; // Presumably length = maxSkillLevel

    public Skill(int requiredLevel, List<SkillStats> statsPerLevel) {
        this.requiredLevel = requiredLevel;
        this.statsPerLevel = statsPerLevel;
        this.maxSkillLevel = statsPerLevel.Count;
    }

    public static Hashtable skillData = new Hashtable() { // Hashtable<SkillID, Skill>
        { SkillID.BASIC_ATTACK,
            new Skill(1,
                new List<SkillStats>() {
                    new SkillStats(0, 3, 0.5f,
                        new List<int>()   { 2 },
                        new List<float>() { 1f })
                }
                )},
        { SkillID.DOUBLE_JUMP,
            new Skill(1,
                new List<SkillStats>() {
                    new SkillStats(0.5f, 0, 0.1f),
                    new SkillStats(0.6f, 0, 0.1f),
                    new SkillStats(0.7f, 0, 0.1f),
                    new SkillStats(0.8f, 0, 0.1f),
                    new SkillStats(0.9f, 0, 0.1f),
                }
                )},
        { SkillID.STUNNING_STRIKE,
            new Skill(15,
                new List<SkillStats>() {
                    new SkillStats(0, 1, 4.0f,
                        new List<int>()   { 1 },
                        new List<float>() { 6f }),
                    new SkillStats(0, 1, 3.7f,
                        new List<int>()   { 1 },
                        new List<float>() { 7f }),
                    new SkillStats(0, 1, 3.3f,
                        new List<int>()   { 1 },
                        new List<float>() { 8f }),
                    new SkillStats(0, 1, 2.9f,
                        new List<int>()   { 1 },
                        new List<float>() { 9f }),
                    new SkillStats(0, 2, 2.5f,
                        new List<int>()   { 1 },
                        new List<float>() { 10f }),
                }
                )},
        { SkillID.LIGHTNING_DASH,
            new Skill(15,
                new List<SkillStats>() {
                    new SkillStats(0, 3, 4.0f,
                        new List<int>()   { 4 },
                        new List<float>() { 1.2f }),
                    new SkillStats(0, 3, 3.7f,
                        new List<int>()   { 4 },
                        new List<float>() { 1.4f }),
                    new SkillStats(0, 4, 3.3f,
                        new List<int>()   { 5 },
                        new List<float>() { 1.6f }),
                    new SkillStats(0, 4, 2.9f,
                        new List<int>()   { 5 },
                        new List<float>() { 1.8f }),
                    new SkillStats(0, 5, 2.5f,
                        new List<int>()   { 6 },
                        new List<float>() { 5f }),
                }
                )},
        { SkillID.BLOWBACK_SHOT,
            new Skill(30,
                new List<SkillStats>() {
                    new SkillStats(1.0f, 3, 2f,
                        new List<int>()   { 3 },
                        new List<float>() { 3f }),
                    new SkillStats(0, 3, 1.6f,
                        new List<int>()   { 3 },
                        new List<float>() { 3.5f }),
                    new SkillStats(0, 4, 1.3f,
                        new List<int>()   { 3 },
                        new List<float>() { 4f }),
                    new SkillStats(0, 4, 1.0f,
                        new List<int>()   { 3 },
                        new List<float>() { 4.5f }),
                    new SkillStats(1.0f, 5, 0.5f,
                        new List<int>()   { 3 },
                        new List<float>() { 5f }),
                }
                )},
        // The SpeedModifier for Arrow Barrage is the length of its spawner duration.
        { SkillID.ARROW_BARRAGE,
            new Skill(40,
                new List<SkillStats>() {
                    new SkillStats(3.0f, 4, 10f,
                        new List<int>()   { 3 },
                        new List<float>() { 0.3f }),
                    new SkillStats(3.5f, 4, 9f,
                        new List<int>()   { 3 },
                        new List<float>() { 0.4f }),
                    new SkillStats(4.0f, 5, 8f,
                        new List<int>()   { 4 },
                        new List<float>() { 0.5f }),
                    new SkillStats(4.5f, 5, 7f,
                        new List<int>()   { 4 },
                        new List<float>() { 0.6f }),
                    new SkillStats(5.0f, 6, 6f,
                        new List<int>()   { 5 },
                        new List<float>() { 0.7f }),
                }
                )},
        { SkillID.EXECUTION,
            new Skill(50,
                new List<SkillStats>() {
                    new SkillStats(0, 2, 4f,
                        new List<int>()   { 6 },
                        new List<float>() { 1.1f }),
                    new SkillStats(0, 2, 3.5f,
                        new List<int>()   { 6 },
                        new List<float>() { 1.2f }),
                    new SkillStats(0, 3, 3f,
                        new List<int>()   { 7 },
                        new List<float>() { 1.3f }),
                    new SkillStats(0, 3, 2.75f,
                        new List<int>()   { 7 },
                        new List<float>() { 1.4f }),
                    new SkillStats(0, 4, 2.5f,
                        new List<int>()   { 8 },
                        new List<float>() { 1.5f }),
                }
                )},
    };
}