#include "cmd.h"
#include "utils.h"
#include "creature.h"
#include "item.h"
#include "spellcasting.h"
#include "settings.h"
#include <sstream>
#include <memory>
#include <cstdlib>
#include <fstream>
#include <iterator>

namespace fs = std::filesystem;

namespace cmd {
    std::string healOrDamage(bool heal, std::vector<std::string> args, std::vector<std::string> flags) {
        std::stringstream text;
	std::vector<rules::Qualifier> qualifiers;
	if(! heal) {
	    for(auto flag : flags) {
		if(flag == "m" || flag == "magical") {
		    qualifiers.push_back(rules::Qualifier::Magical());
		} else if(flag == "s" || flag == "silvered") {
		    qualifiers.push_back(rules::Qualifier::Silvered());
		} else if(flag == "a" || flag == "adamantine") {
		    qualifiers.push_back(rules::Qualifier::Adamantine());
		}
	    }
	}
	fs::path p = getTruePath(args[0]);
	auto c = utils::instantiate<creature::Creature>(p);
	int amnt = utils::parseInt(args[1]);
	int initHP = c->getHP();
	std::string dmgType = "force";
	if(heal) {
	    c->applyHealing(amnt);
	} else {
	    if(args.size() == 3) {
		dmgType = args[2];
	    }
	    c->applyDamage(amnt, dmgType, qualifiers);
	}
	text << (heal? "Healing " : "Damaging ") << c->getGivenName() << " the " << c->getCreatureName() << " by " << amnt;
	if(! heal) {
	    std::string qualsString;
	    std::vector<std::string> positiveQuals;
	    for(auto qual : qualifiers) {
		positiveQuals.push_back(qual.getPositive());
	    }
	    if(! positiveQuals.empty()) {
		qualsString = " " + utils::join(positiveQuals, ", ");
	    }
	    text << qualsString << " " << dmgType << " damage";
	}
	text << ". HP: " << initHP << " -> " << c->getHP() << "." << std::endl;
	utils::saveJson(*c, p);
        return text.str();
    }

    std::string heal(std::vector<std::string> args) {
        return healOrDamage(true, args, {});
    }

    std::string damage(std::vector<std::string> args, std::vector<std::string> flags) {
        return healOrDamage(false, args, flags);
    }

    std::string reset(std::vector<std::string> args) {
	for(std::string s : args) {
	    fs::path p = getTruePath(s);
	    auto c = utils::instantiate<creature::Creature>(p);
	    c->longRest();
	    utils::saveJson(*c, p);
	}
        return "";
    }

    std::string set(std::vector<std::string> args) {
	if(args.size() < 3) {
	    throw std::runtime_error("Subcommand 'set' requires at least 3 arguments");
	}
	fs::path p = getTruePath(args[0]);
	args.erase(args.begin()); // remove path from args
	auto c = utils::instantiate<creature::Creature>(p);
	if(args[0] == "name") {
	    args.erase(args.begin()); // remove "name" from args
	    c->setGivenName(utils::join(args, " "));
	} else if(args[0] == "proficiency") {
	    c->setProficiency(utils::parseInt(args[1]));
	} else {
	    // Either an ability or a skill. If skill, then it could be multiple words long.
	    std::string toSet = args.back();
	    args.erase(--args.end());
	    std::string abilityOrSkill = utils::join(args, " ");
	    rules::Skill skill = rules::tryGetAbilityOrSkill<rules::Skill>(abilityOrSkill);
	    rules::Ability ability = rules::tryGetAbilityOrSkill<rules::Ability>(abilityOrSkill);
	    if(skill) {
		// ensure lower case
		utils::lower(toSet);
		int level = -1;
		if(toSet == "none") level = 0;
		else if(toSet == "proficient") level = 1;
		else if(toSet == "expert") level = 2;
		if(level == -1) {
		    throw std::runtime_error("Skill levels can be set to none, proficient, or expert, but " + toSet + " was given.");
		}
		c->setProfLevel(skill, level);
	    } else if(ability) {
		c->setScore(ability, utils::parseInt(toSet));
	    } else {
		throw std::runtime_error("Subcommand 'set' expected an ability, skill, proficiency, or name field to set, but was given " + abilityOrSkill);
	    }
	}
	utils::saveJson(*c, p);
        return "";
    }

    std::string add(std::vector<std::string> args) {
        std::stringstream text;
	fs::path p = getTruePath(args[0]);
	args.erase(args.begin()); // remove path from args
	auto c = utils::instantiate<creature::Creature>(p);
	std::string addName = utils::join(args, " ");
	std::shared_ptr<entry::Entry> ent;
	fs::path path = getTruePath(addName);
	if(fs::directory_entry(path).exists()) {
	    ent = utils::instantiate<entry::Entry>(path);
	} else {
	    ent = entry::Entry::create(utils::findByName(addName));
	}
	// Determine if it is an item or a spell
	auto i = std::dynamic_pointer_cast<entry::Item>(ent);
	if(i) {
	    c->addInventoryItem(i);
	} else {
	    auto s = std::dynamic_pointer_cast<entry::Spell>(ent);
	    if(s) {
		c->addSpell(s);
	    } else {
		throw std::runtime_error("Could not add the " + ent->getType() + " " + ent->getName() + " to " + c->getGivenName() + " the " + c->getName() + ": Requires a weapon, armor, or spell, but received object of type " + ent->getType());
	    }
	}
	utils::saveJson(*c, p);
	text << "Added the " << ent->getType() << " " << ent->getName() << " to " << c->getGivenName() << " the " << c->getName() << std::endl;
        return text.str();
    }

    std::string del(std::vector<std::string> args) {
        std::stringstream text;
	fs::path p = getTruePath(args[0]);
	args.erase(args.begin()); // remove path from args
	auto c = utils::instantiate<creature::Creature>(p);
	//Atempt to load the item if it's a path
	std::string itemName = utils::join(args, " ");
	try {
	    auto i = utils::instantiate<entry::Entry>(getTruePath(itemName));
	    if(i) {
		itemName = i->getName();
	    }
	} catch(std::exception& e) {} // eat.
	utils::lower(itemName);
	// Loop through all of c's stuff, searching for itemName
	std::shared_ptr<entry::Entry> removed;
	for(auto item : c->getInventory()) {
	    std::string name = item->getName();
	    if(utils::lower(name) == itemName) {
		c->removeInventoryItem(item);
		removed = item;
		break;
	    }
	}
	if(! removed) {
	    for(auto spell : c->getSpellcasting()->getSpells()) {
		std::string name = spell->getName();
		if(utils::lower(name) == itemName) {
		    c->removeSpell(spell);
		    removed = spell;
		    break;
		}
	    }
	}
	utils::saveJson(*c, p);
	if(removed) {
	    text << "Successfully removed the " << removed->Entry::getType() << " " << removed->getName() << std::endl;
	} else {
	    text << "Could not find any inventory item nor spell by that name" << std::endl;
	}
        return text.str();
    }

    std::string edit(std::vector<std::string> args) {
	auto p = getTruePath(args[0]);
        auto e = utils::instantiate<entry::Entry>(p);
        auto editor = settings::getString("editor");
        // General workflow: copy notes (text) from e to a temp file, edit it, then copy back.
        fs::path tmp("/tmp/dmtool.tmp");
        std::ofstream out(tmp);
        out << e->Entry::getText();
        out.close();
        std::system((editor + " " + tmp.string()).c_str());
        std::ifstream in(tmp);
        std::string newText(std::istreambuf_iterator<char>{in}, {});
        e->setText(newText);
        utils::saveJson(*e, p);
        return "";
    }

    std::string spellcasting(std::vector<std::string> args) {
        std::stringstream text;
        auto p = getTruePath(args[0]);
        auto c = utils::instantiate<creature::Creature>(p);
        auto subcommand = args[1];
        if(subcommand != "init" && subcommand != "ability" && subcommand != "level") {
            throw std::runtime_error("Unknown option \"" + subcommand + "\"");
        }
        if(subcommand == "init") {
            c->addSpellcasting();
        } else {
            auto sc = c->getSpellcasting();
            if(! sc) {
                throw std::runtime_error("Creature " + c->getName() + " has no spellcasting");
            }
            text << "Added spellcasting to " << c->getName() << std::endl;
            if(subcommand == "ability") {
                if(args.size() != 3) {
                    throw std::runtime_error("Subcommand \"spellcasting ability\" requires an additional parameter, but none was given");
                }
                sc->setAbility(args[2]);
                text << "Set " << c->getName() << " spellcasting ability to " << args[2] << std::endl;
            } else { // subcommand == "level"
                if(args.size() != 4) {
                    throw std::runtime_error("Subcommand \"spellcasting level\" requires more parameters");
                }
                int level = utils::parseInt(args[2]);
                int slots = utils::parseInt(args[3]);
                if(level <= 0 || slots < 0) {
                    throw std::runtime_error("Spellcasting target out of range");
                }
                while(sc->getSlotLevels().size() <= (std::size_t) level) {
                    sc->addSlotLevel();
                }
                sc->getSlotLevels()[level]->numSlots = slots;
                text << "Gave " << c->getName() << " " << slots << " " << utils::toOrdinal(level) << " level spell slots" << std::endl;
            }
        }
        utils::saveJson(*c, p);
        return text.str();
    }

    std::string git(std::vector<std::string> args) {
        std::string root = getTruePath("").string();
        std::system(("cd " + root + " && " + utils::join(args, " ")).c_str());
        return "";
    }
}