#include "weapon.h"
#include "creature.h"
#include "rules.h"
#include "dice.h"
#include <string>
#include <sstream>
#include <algorithm>

using namespace std;

namespace entry {
    string getTextHelper(const Weapon& w, string toHitBonus, string damageBonus) {
        stringstream text;
        text << "+" << toHitBonus << " to hit, ";
        if(w.getReach() > 0) {
            text << "reach " << w.getReach() << " ft.";
            if(w.getRange().second > 0) {
                text << " or ";
            }
        }
        if(w.getRange().second > 0) {
            text << "range " << w.getRange().first << "/" << w.getRange().second << " ft.";
        }
        text << " Hit: ";
        auto dmgs = w.getDamage();
        for(size_t i = 0; i < dmgs.size(); i++) {
            const Damage& d = dmgs[i];
            text << d.dmg_die_count << "d" << d.dmg_die_sides;
            if(i == 0) {
                if(w.getProperties().count("versatile")) {
                    text << " (or " << d.dmg_die_count << "d" << d.dmg_die_sides + 2 << " if two-handed)";
                }
                text << " + " << damageBonus;
            }
            text << " " << d.dmg_type << " damage";
            if(i < dmgs.size()-1) {
                if(d.is_or) {
                    text << " or ";
                } else {
                    text << " plus ";
                }
            }
        }
        text << ".";
        auto props = w.getProperties();
        // We don't care about finesse nor versatile because they're already handled
        props.erase("finesse");
        props.erase("versatile");
        if(! props.empty()) {
            text << " Additional properties: " << utils::join(props, ", ") << ".";
        }
        if(! w.Entry::getText().empty()) {
            text << " " << w.Entry::getText();
        }
        text << " " << w.Substantial::getText();
        return text.str();
    }

    vector<Damage> rollDmg(const Weapon& w, bool versatile) {
        vector<Damage> dmgs = w.getDamage();
        bool first = true;
        for(Damage& d : dmgs) {
            d.rolled = 0;
            int sides = d.dmg_die_sides;
            if(first && versatile && w.getProperties().count("versatile")) {
                sides += 2;
            }
            first = false;
            for(int i = 0; i < d.dmg_die_count; i++) {
                d.rolled += dice::roll(sides);
            }
        }
        return dmgs;
    }

    string formatDmg(const Weapon& w, const creature::Creature& c) {
        stringstream text;
        vector<Damage> dmgsNoVersatile = rollDmg(w, false);
        vector<Damage> dmgsVersatile = rollDmg(w, true);
        int abilityBonus = c.getBonus(creature::getBestAbility(getAbilityOptions(w), c));
        for(size_t i = 0; i < dmgsNoVersatile.size(); i++) {
            if(i == 0) {
                text << dmgsNoVersatile[i].rolled + abilityBonus;
                if(w.getProperties().count("versatile")) {
                    text << " (or " << dmgsVersatile[i].rolled + abilityBonus << " if two-handed)";
                }
            } else {
                text << dmgsNoVersatile[i].rolled;
            }
            text << " " << dmgsNoVersatile[i].dmg_type << " damage";
            if(i < dmgsNoVersatile.size()-1) {
                if(dmgsNoVersatile[i].is_or) {
                    text << " or ";
                } else {
                    text << " plus ";
                }
            }
        }
        return text.str();
    }

    vector<rules::Ability> getAbilityOptions(const Weapon& w) {
        // Do finesse
        if(w.getProperties().count("finesse")) {
            return {rules::Ability::Str(), rules::Ability::Dex()};
        }
        // Do melee weapons
        if(w.getReach() > 0) {
            return {rules::Ability::Str()};
        }
        // Do range weapons (thrown melee were done above)
        if(w.getRange().second > 0) {
            return {rules::Ability::Dex()};
        }
        cerr << "Error processing weapon!" << endl;
        return {rules::Ability::Str()};
    }

    string Weapon::getText() const {
        auto abilities = getAbilityOptions(*this);
        string abilityString;
        if(abilities.size() == 1) {
            abilityString = string(abilities[0]);
        } else {
            abilityString = "max(" + utils::join(abilities, ", ") + ")";
        }
        return getTextHelper(*this, "(" + abilityString + " + prof)", abilityString);

    }

    string Weapon::getText(const creature::Creature& c) const {
        stringstream text;
        text << getName() << " (" << getType() << "): ";
        // Determine best ability bonus
        int abilityBonus = c.getBonus(creature::getBestAbility(getAbilityOptions(*this), c));
        text << getTextHelper(*this, to_string(abilityBonus + c.getProficiency()), to_string(abilityBonus));
        return text.str();
    }
}