#include "game/Mobs.h"

#include <map>
#include <algorithm>

namespace td {
namespace game {

bool Mob::isImmuneTo(TowerType type) {
    return std::find(getTowerImmunities().begin(), getTowerImmunities().end(), type) != getTowerImmunities().end();
}

bool Mob::isImmuneTo(EffectType type) {
    return std::find(getEffectImmunities().begin(), getEffectImmunities().end(), type) != getEffectImmunities().end();
}

EffectDuration& Mob::getEffect(EffectType effectType) {
    return *std::find_if(m_Effects.begin(), m_Effects.end(), [&effectType](EffectDuration effect) { return effect.type == effectType;});
}

void Mob::addEffect(EffectType effectType, float durationSec, const Tower* tower) {
    if (isImmuneTo(effectType))
        return;
    if (hasEffect(effectType)) {
        EffectDuration& effect = getEffect(effectType);
        if (effect.duration < durationSec)
            effect.duration = durationSec;    // setting new duration if it's greater then the actual
    } else {
        m_Effects.push_back({ effectType, durationSec, tower });
    }
}

void Mob::tick(std::uint64_t delta) {
    updateEffects(delta);
}

void Mob::updateEffects(std::uint64_t delta) {
    float deltaSec = (float)delta / 1000.0f;
    for (std::size_t i = 0; i < m_Effects.size(); i++) {
        EffectDuration& effect = m_Effects[i];
        effect.duration -= deltaSec;
        if (effect.duration < 0) {  // effect has gone
            m_Effects.erase(m_Effects.begin() + i);
            switch (effect.type) {
            case EffectType::Fire: {
                m_EffectFireTimer.reset();
                break;
            }

            case EffectType::Poison: {
                m_EffectPoisonTimer.reset();
                break;
            }

            case EffectType::Heal: {
                m_EffectHealTimer.reset();
            }

            default:
                break;
            }
        }
    }
    if (hasEffect(EffectType::Fire)) {
        if (m_EffectFireTimer.update(delta)) {
            damage(3, getEffect(EffectType::Fire).tower);
        }
    }
    if (hasEffect(EffectType::Poison)) {
        if (m_EffectPoisonTimer.update(delta)) {
            damage(1, getEffect(EffectType::Poison).tower);
        }
    }
    if (hasEffect(EffectType::Heal)) {
        if (m_EffectFireTimer.update(delta)) {
            heal(10);
        }
    }
}

bool Mob::hasEffect(EffectType type) {
    return std::find_if(m_Effects.begin(), m_Effects.end(), [&type](EffectDuration effect) { return effect.type == type;}) != m_Effects.end();
}




typedef std::pair<MobType, std::uint8_t> MobKey;

const std::map<MobKey, MobStats> MobConstants = {
    // damage  speed  size  money_cost  exp_cost  exp_reward  max_health
    {{MobType::Zombie, 1},{MobStats{1, 1.6, {1, 1}, 15, 0, 7, 40}}},
    {{MobType::Zombie, 2},{MobStats{1, 1.6, {1, 1}, 18, 88, 9, 56}}},
    {{MobType::Zombie, 3},{MobStats{1, 1.6, {1, 1}, 22, 153, 10, 78}}},
    {{MobType::Zombie, 4},{MobStats{1.5, 1.6, {1, 1}, 26, 268, 13, 110}}},
    {{MobType::Zombie, 5},{MobStats{2, 1.6, {1, 1}, 31, 469, 15, 154}}},

    {{MobType::Spider, 1},{MobStats{1, 1.6, {1, 1}, 25, 100, 15, 80}}},
    {{MobType::Spider, 2},{MobStats{1, 2, {1, 1}, 30, 175, 16, 112}}},
    {{MobType::Spider, 3},{MobStats{1.5, 2, {1, 1}, 36, 306, 18, 157}}},
    {{MobType::Spider, 4},{MobStats{2.5, 2, {1, 1}, 43, 536, 19, 222}}},
    {{MobType::Spider, 5},{MobStats{1.5, 2.5, {1, 1}, 52, 938, 22, 307}}},

    {{MobType::Skeleton, 1},{MobStats{1, 1.6, {1, 1}, 120, 200, 30, 350}}},
    {{MobType::Skeleton, 2},{MobStats{1, 1.6, {1, 1}, 144, 350, 33, 490}}},
    {{MobType::Skeleton, 3},{MobStats{1, 1.6, {1, 1}, 173, 613, 36, 686}}},
    {{MobType::Skeleton, 4},{MobStats{1.5, 1.6, {1, 1}, 225, 1072, 40, 960}}},
    {{MobType::Skeleton, 5},{MobStats{2, 1.6, {1, 1}, 255, 1876, 43, 1345}}},

    {{MobType::Pigman, 1},{MobStats{1, 2, {1, 1}, 100, 150, 22, 150}}},
    {{MobType::Pigman, 2},{MobStats{1, 2, {1, 1}, 120, 263, 24, 210}}},
    {{MobType::Pigman, 3},{MobStats{1, 2, {1, 1}, 144, 459, 25, 297}}},
    {{MobType::Pigman, 4},{MobStats{1, 2, {1, 1}, 173, 804, 25, 412}}},
    {{MobType::Pigman, 5},{MobStats{1.5, 2, {1, 1}, 207, 1407, 27, 576}}},

    {{MobType::Creeper, 1},{MobStats{1, 2, {1, 1}, 250, 325, 46, 350}}},
    {{MobType::Creeper, 2},{MobStats{1, 2, {1, 1}, 290, 550, 49, 460}}},
    {{MobType::Creeper, 3},{MobStats{2, 2, {1, 1}, 350, 800, 55, 630}}},
    {{MobType::Creeper, 4},{MobStats{3, 2, {1, 1}, 420, 1300, 61, 900}}},
    {{MobType::Creeper, 5},{MobStats{4, 2, {1, 1}, 510, 1850, 67, 1250}}},

    {{MobType::Silverfish, 1},{MobStats{1, 1.6, {1, 1}, 38, 125, 18, 120}}},
    {{MobType::Silverfish, 2},{MobStats{1, 1.6, {1, 1}, 50, 230, 19, 170}}},
    {{MobType::Silverfish, 3},{MobStats{1, 1.6, {1, 1}, 75, 340, 25, 225}}},
    {{MobType::Silverfish, 4},{MobStats{1.5, 1.6, {1, 1}, 170, 700, 33, 310}}},
    {{MobType::Silverfish, 5},{MobStats{1.5, 1.6, {1, 1}, 200, 1800, 36, 390}}},

    {{MobType::Blaze, 1},{MobStats{1, 1.6, {1, 1}, 500, 500, 105, 410}}},
    {{MobType::Blaze, 2},{MobStats{1, 1.6, {1, 1}, 600, 875, 111, 574}}},
    {{MobType::Blaze, 3},{MobStats{1, 1.6, {1, 1}, 720, 1531, 115, 804}}},
    {{MobType::Blaze, 4},{MobStats{1.5, 1.6, {1, 1}, 864, 2680, 121, 1125}}},
    {{MobType::Blaze, 5},{MobStats{2, 1.6, {1, 1}, 1037, 4689, 127, 1575}}},

    {{MobType::Witch, 1},{MobStats{1, 1.6, {1, 1}, 150, 300, 37, 300}}},
    {{MobType::Witch, 2},{MobStats{1, 1.6, {1, 1}, 165, 525, 39, 405}}},
    {{MobType::Witch, 3},{MobStats{1, 1.6, {1, 1}, 182, 918, 42, 547}}},
    {{MobType::Witch, 4},{MobStats{1.5, 1.6, {1, 1}, 200, 1606, 43, 738}}},
    {{MobType::Witch, 5},{MobStats{2, 1.6, {1, 1}, 220, 2810, 45, 996}}},

    {{MobType::Slime, 1},{MobStats{1, 0.8, {1, 1}, 1500, 1000, 300, 800}}},
    {{MobType::Slime, 2},{MobStats{1.5, 0.8, {1, 1}, 1800, 1750, 314, 880}}},
    {{MobType::Slime, 3},{MobStats{2, 0.8, {1, 1}, 2160, 3063, 330, 968}}},
    {{MobType::Slime, 4},{MobStats{2.5, 0.8, {1, 1}, 2592, 5359, 348, 1065}}},
    {{MobType::Slime, 5},{MobStats{3, 0.8, {1, 1}, 3110, 9379, 366, 1171}}},

    {{MobType::Giant, 1},{MobStats{10, 0.8, {1, 1}, 4000, 2250, 600, 6250}}},
    {{MobType::Giant, 2},{MobStats{20, 0.8, {1, 1}, 4500, 4000, 612, 9375}}},
    {{MobType::Giant, 3},{MobStats{30, 0.8, {1, 1}, 5062, 7250, 624, 14062}}},
    {{MobType::Giant, 4},{MobStats{40, 0.8, {1, 1}, 5695, 12500, 636, 21093}}},
    {{MobType::Giant, 5},{MobStats{50, 0.8, {1, 1}, 6407, 22000, 648, 31640}}},
};

const MobStats* getMobStats(MobType type, std::uint8_t level) {
    return &MobConstants.at(MobKey{ type, level });
}

const std::map<MobKey, TowerImmunities> MobsTowerImmunities = {
    {{MobType::Zombie, 1},{}},
    {{MobType::Zombie, 2},{}},
    {{MobType::Zombie, 3},{}},
    {{MobType::Zombie, 4},{}},
    {{MobType::Zombie, 5},{}},

    {{MobType::Spider, 1},{}},
    {{MobType::Spider, 2},{}},
    {{MobType::Spider, 3},{}},
    {{MobType::Spider, 4},{TowerType::Archer, TowerType::Artillery, TowerType::Leach, TowerType::Necromancer, TowerType::Poison, TowerType::Quake, TowerType::Sorcerer, TowerType::Turret, TowerType::Zeus}},
    {{MobType::Spider, 5},{TowerType::Archer, TowerType::Artillery, TowerType::Leach, TowerType::Necromancer, TowerType::Poison, TowerType::Quake, TowerType::Sorcerer, TowerType::Turret, TowerType::Zeus}},

    {{MobType::Skeleton, 1},{}},
    {{MobType::Skeleton, 2},{}},
    {{MobType::Skeleton, 3},{}},
    {{MobType::Skeleton, 4},{}},
    {{MobType::Skeleton, 5},{}},

    {{MobType::Pigman, 1},{TowerType::Zeus}},
    {{MobType::Pigman, 2},{TowerType::Zeus}},
    {{MobType::Pigman, 3},{TowerType::Zeus}},
    {{MobType::Pigman, 4},{TowerType::Zeus}},
    {{MobType::Pigman, 5},{TowerType::Zeus}},

    {{MobType::Creeper, 1},{}},
    {{MobType::Creeper, 2},{}},
    {{MobType::Creeper, 3},{}},
    {{MobType::Creeper, 4},{}},
    {{MobType::Creeper, 5},{}},

    {{MobType::Silverfish, 1},{}},
    {{MobType::Silverfish, 2},{}},
    {{MobType::Silverfish, 3},{}},
    {{MobType::Silverfish, 4},{}},
    {{MobType::Silverfish, 5},{}},

    {{MobType::Blaze, 1},{}},
    {{MobType::Blaze, 2},{}},
    {{MobType::Blaze, 3},{}},
    {{MobType::Blaze, 4},{}},
    {{MobType::Blaze, 5},{}},

    {{MobType::Witch, 1},{TowerType::Zeus, TowerType::Mage, TowerType::Poison}},
    {{MobType::Witch, 2},{TowerType::Zeus, TowerType::Mage, TowerType::Poison}},
    {{MobType::Witch, 3},{TowerType::Zeus, TowerType::Mage, TowerType::Poison}},
    {{MobType::Witch, 4},{TowerType::Zeus, TowerType::Mage, TowerType::Poison}},
    {{MobType::Witch, 5},{TowerType::Zeus, TowerType::Mage, TowerType::Poison}},

    {{MobType::Slime, 1},{}},
    {{MobType::Slime, 2},{}},
    {{MobType::Slime, 3},{}},
    {{MobType::Slime, 4},{}},
    {{MobType::Slime, 5},{}},

    {{MobType::Giant, 1},{}},
    {{MobType::Giant, 2},{}},
    {{MobType::Giant, 3},{}},
    {{MobType::Giant, 4},{}},
    {{MobType::Giant, 5},{}},
};

const TowerImmunities& getMobTowerImmunities(MobType type, std::uint8_t level) {
    return MobsTowerImmunities.at({ type, level });
}

const std::map<MobKey, EffectImmunities> MobsEffectImmunities = {
    {{MobType::Zombie, 1},{}},
    {{MobType::Zombie, 2},{}},
    {{MobType::Zombie, 3},{}},
    {{MobType::Zombie, 4},{}},
    {{MobType::Zombie, 5},{}},

    {{MobType::Spider, 1},{}},
    {{MobType::Spider, 2},{}},
    {{MobType::Spider, 3},{}},
    {{MobType::Spider, 4},{}},
    {{MobType::Spider, 5},{}},

    {{MobType::Skeleton, 1},{}},
    {{MobType::Skeleton, 2},{}},
    {{MobType::Skeleton, 3},{}},
    {{MobType::Skeleton, 4},{EffectType::Fire}},
    {{MobType::Skeleton, 5},{EffectType::Fire}},

    {{MobType::Pigman, 1},{EffectType::Fire}},
    {{MobType::Pigman, 2},{EffectType::Fire}},
    {{MobType::Pigman, 3},{EffectType::Fire}},
    {{MobType::Pigman, 4},{EffectType::Fire}},
    {{MobType::Pigman, 5},{EffectType::Fire}},

    {{MobType::Creeper, 1},{}},
    {{MobType::Creeper, 2},{}},
    {{MobType::Creeper, 3},{}},
    {{MobType::Creeper, 4},{}},
    {{MobType::Creeper, 5},{}},

    {{MobType::Silverfish, 1},{}},
    {{MobType::Silverfish, 2},{}},
    {{MobType::Silverfish, 3},{}},
    {{MobType::Silverfish, 4},{EffectType::Fire}},
    {{MobType::Silverfish, 5},{EffectType::Fire}},

    {{MobType::Blaze, 1},{EffectType::Fire}},
    {{MobType::Blaze, 2},{EffectType::Fire}},
    {{MobType::Blaze, 3},{EffectType::Fire}},
    {{MobType::Blaze, 4},{EffectType::Fire}},
    {{MobType::Blaze, 5},{EffectType::Fire}},

    {{MobType::Witch, 1},{}},
    {{MobType::Witch, 2},{}},
    {{MobType::Witch, 3},{}},
    {{MobType::Witch, 4},{}},
    {{MobType::Witch, 5},{}},

    {{MobType::Slime, 1},{}},
    {{MobType::Slime, 2},{}},
    {{MobType::Slime, 3},{}},
    {{MobType::Slime, 4},{EffectType::Fire}},
    {{MobType::Slime, 5},{EffectType::Fire}},

    {{MobType::Giant, 1},{EffectType::Stun}},
    {{MobType::Giant, 2},{EffectType::Stun}},
    {{MobType::Giant, 3},{EffectType::Stun}},
    {{MobType::Giant, 4},{EffectType::Stun}},
    {{MobType::Giant, 5},{EffectType::Stun}},
};

const EffectImmunities& getMobEffectImmunities(MobType type, std::uint8_t level) {
    return MobsEffectImmunities.at({ type, level });
}

MobPtr MobFactory::createMob(MobID id, MobType type, std::uint8_t level, PlayerID sender) {
    using MobCreator = std::function<std::shared_ptr<Mob>(MobID, std::uint8_t, PlayerID)>;

    static std::map<MobType, MobCreator> mobFactory = {
        {MobType::Zombie,      [](MobID id, std::uint8_t level, PlayerID sender) -> MobPtr {return std::make_shared<Zombie>(id, level, sender);} },
        {MobType::Spider,      [](MobID id, std::uint8_t level, PlayerID sender) -> MobPtr {return std::make_shared<Spider>(id, level, sender);} },
        {MobType::Skeleton,    [](MobID id, std::uint8_t level, PlayerID sender) -> MobPtr {return std::make_shared<Skeleton>(id, level, sender);} },
        {MobType::Pigman,      [](MobID id, std::uint8_t level, PlayerID sender) -> MobPtr {return std::make_shared<PigMan>(id, level, sender);} },
        {MobType::Creeper,     [](MobID id, std::uint8_t level, PlayerID sender) -> MobPtr {return std::make_shared<Creeper>(id, level, sender);} },
        {MobType::Silverfish,  [](MobID id, std::uint8_t level, PlayerID sender) -> MobPtr {return std::make_shared<Silverfish>(id, level, sender);} },
        {MobType::Blaze,       [](MobID id, std::uint8_t level, PlayerID sender) -> MobPtr {return std::make_shared<Blaze>(id, level, sender);} },
        {MobType::Witch,       [](MobID id, std::uint8_t level, PlayerID sender) -> MobPtr {return std::make_shared<Witch>(id, level, sender);} },
        {MobType::Slime,       [](MobID id, std::uint8_t level, PlayerID sender) -> MobPtr {return std::make_shared<Slime>(id, level, sender);} },
        {MobType::Giant,       [](MobID id, std::uint8_t level, PlayerID sender) -> MobPtr {return std::make_shared<Giant>(id, level, sender);} },
    };

    return mobFactory[type](id, level, sender);
}

std::string MobFactory::getMobName(MobType type) {
    switch (type) {
    case MobType::Zombie:
        return "Zombie";
    case MobType::Spider:
        return "Spider";
    case MobType::Skeleton:
        return "Skeleton";
    case MobType::Pigman:
        return "Pigman";
    case MobType::Creeper:
        return "Creeper";
    case MobType::Silverfish:
        return "Silverfish";
    case MobType::Blaze:
        return "Blaze";
    case MobType::Witch:
        return "Witch";
    case MobType::Slime:
        return "Slime";
    case MobType::Giant:
        return "Giant";
    default:
        return "Unknow";
    }
}

} // namespace game
} // namespace td