#include "Repl.h"

#include <algorithm>
#include <ctime>
#include <iostream>
#include <limits>
#include <optional>
#include <stdexcept>

#include "ExternalEditor.h"
#include "StringUtil.h"
#include "Terminal.h"
#include "Tokenizer.h"

namespace {

const std::size_t kUnlimited = std::numeric_limits<std::size_t>::max();

const char* const kStatusHelp =
    "prompt, limit-reset, testing, wait <time>, uploading, frozen, done "
    "(time: 16:30, 4:30pm, 4pm)";

bool parseVisibility(const std::string& word) {
    const std::string value = StringUtil::lower(word);
    if (value == "show") {
        return true;
    }
    if (value == "hide") {
        return false;
    }
    throw std::runtime_error("Expected 'show' or 'hide', got '" + word + "'.");
}

}  // namespace

Repl::Repl(Database& db, Display& display, Config& config)
    : db_(db), display_(display), config_(config), completer_(db, specs_), quit_(false) {
    registerCommands();
}

void Repl::add(const std::string& key, const std::string& usage, const std::string& help,
               std::size_t minArgs, std::size_t maxArgs, const std::vector<ArgKind>& argKinds,
               Handler handler) {
    CommandSpec spec;
    spec.key = key;
    spec.usage = usage;
    spec.help = help;
    spec.minArgs = minArgs;
    spec.maxArgs = maxArgs;
    spec.argKinds = argKinds;

    Command command;
    command.spec = spec;
    command.handler = handler;
    commands_.push_back(command);
    specs_.push_back(spec);
}

void Repl::registerCommands() {
    add("acc add", "acc add <name>", "create an account", 1, 1, {ArgKind::None}, &Repl::cmdAccAdd);
    add("acc del", "acc del <name>", "delete an account (its tasks become unassigned)", 1, 1,
        {ArgKind::Account}, &Repl::cmdAccDel);
    add("acc rename", "acc rename <name> <new>", "rename an account", 2, 2,
        {ArgKind::Account, ArgKind::None}, &Repl::cmdAccRename);
    add("acc ls", "acc ls", "show the account table", 0, 0, {}, &Repl::cmdAccLs);

    add("tsk add", "tsk add <name> [acc] [status]", "create a task", 1, kUnlimited,
        {ArgKind::None, ArgKind::AccountOrStatus, ArgKind::Status}, &Repl::cmdTskAdd);
    add("tsk del", "tsk del <name>", "delete a task", 1, 1, {ArgKind::Task}, &Repl::cmdTskDel);
    add("tsk ls", "tsk ls", "show the task table", 0, 0, {}, &Repl::cmdTskLs);
    add("tsk rename", "tsk rename <name> <new>", "rename a task", 2, 2,
        {ArgKind::Task, ArgKind::None}, &Repl::cmdTskRename);
    add("tsk reacc", "tsk reacc <name> <new>", "move a task to another account ('-' = none)", 2, 2,
        {ArgKind::Task, ArgKind::AccountOrDash}, &Repl::cmdTskReacc);
    add("tsk restat", "tsk restat <name> <new>", "change a task's status", 2, kUnlimited,
        {ArgKind::Task, ArgKind::Status}, &Repl::cmdTskRestat);
    add("tsk notes", "tsk notes <name>", "edit a task's notes in your editor (see 'editor')", 1, 1,
        {ArgKind::Task}, &Repl::cmdTskNotes);

    add("disp", "disp", "show the current display settings", 0, 0, {}, &Repl::cmdDisp);
    add("disp tsk", "disp tsk (hide|show)", "auto-print the task table after changes", 1, 1,
        {ArgKind::Visibility}, &Repl::cmdDispTsk);
    add("disp tsk level", "disp tsk level (hide|show) (prompt|limit-reset|testing|wait|uploading|frozen|done|all)",
        "hide or show task rows by status", 2, 2,
        {ArgKind::Visibility, ArgKind::TaskLevel}, &Repl::cmdDispTskLevel);
    add("disp acc", "disp acc (hide|show)", "auto-print the account table after changes", 1, 1,
        {ArgKind::Visibility}, &Repl::cmdDispAcc);
    add("disp acc level", "disp acc level (hide|show) (busy|free|all)",
        "hide or show account rows by status", 2, 2,
        {ArgKind::Visibility, ArgKind::AccountLevel}, &Repl::cmdDispAccLevel);

    add("db save", "db save", "write the database to its file", 0, 0, {}, &Repl::cmdDbSave);
    add("db backup", "db backup [file]", "write a copy (timestamped name if no file given)", 0, 1,
        {ArgKind::File}, &Repl::cmdDbBackup);
    add("db restore", "db restore <file>", "replace the current data with a file's contents", 1, 1,
        {ArgKind::File}, &Repl::cmdDbRestore);

    add("editor", "editor [command | default]", "show or set the editor used by 'tsk notes'", 0, kUnlimited,
        {ArgKind::Editor}, &Repl::cmdEditor);
    add("help", "help", "list the commands", 0, 0, {}, &Repl::cmdHelp);
    add("quit", "quit", "exit (also: exit, Ctrl-D)", 0, 0, {}, &Repl::cmdQuit);
    add("exit", "exit", "exit", 0, 0, {}, &Repl::cmdQuit);
}

const Repl::Command* Repl::find(const Args& tokens, std::size_t& consumed) const {
    // Longest match wins: "disp tsk level" before "disp tsk" before "disp".
    for (std::size_t words = std::min<std::size_t>(3, tokens.size()); words >= 1; --words) {
        std::string key;
        for (std::size_t i = 0; i < words; ++i) {
            if (i > 0) {
                key += " ";
            }
            key += StringUtil::lower(tokens[i]);
        }
        for (const Command& command : commands_) {
            if (command.spec.key == key) {
                consumed = words;
                return &command;
            }
        }
    }
    return nullptr;
}

int Repl::run() {
    lineEditor_.setCompleter([this](const std::string& before) { return completer_.complete(before); });
    lineEditor_.setHistoryFile(config_.historyPath());

    refresh();
    std::cout << "Task tracker - database: " << db_.path()
              << "   ('help' for commands, Tab completes, Enter on an empty line refreshes)\n";

    std::string line;
    while (!quit_) {
        if (!lineEditor_.readLine("> ", line)) {
            endOfInput();
            return 0;
        }
        execute(line);
    }
    return 0;
}

void Repl::endOfInput() {
    if (!db_.dirty()) {
        return;
    }
    if (Terminal::stdinIsInteractive()) {
        if (confirm("Save changes before exiting?")) {
            db_.save();
            std::cout << "Saved to " << db_.path() << ".\n";
        }
    } else {
        db_.save();
        std::cout << "Input closed - changes saved to " << db_.path() << ".\n";
    }
}

void Repl::say(const std::string& message) {
    messages_.push_back(message);
}

void Repl::flushMessages() {
    for (const std::string& message : messages_) {
        std::cout << message << "\n";
    }
    messages_.clear();
}

void Repl::execute(const std::string& line) {
    messages_.clear();
    try {
        Args tokens = Tokenizer::split(line);
        if (tokens.empty()) {
            refresh();
            return;
        }

        std::size_t consumed = 0;
        const Command* command = find(tokens, consumed);
        if (!command) {
            std::cout << "Unknown command. Type 'help' for the list.\n";
            return;
        }

        Args args(tokens.begin() + static_cast<std::ptrdiff_t>(consumed), tokens.end());
        if (args.size() < command->spec.minArgs || args.size() > command->spec.maxArgs) {
            std::cout << "Usage: " << command->spec.usage << "\n"
                      << "(wrap names containing spaces in double quotes)\n";
            return;
        }

        if ((this->*command->handler)(args)) {
            refresh();
        }
        flushMessages();
    } catch (const std::exception& error) {
        messages_.clear();
        std::cout << "Error: " << error.what() << "\n";
    }
}

void Repl::refresh() const {
    const DisplaySettings& settings = display_.settings();
    if (!settings.showTasks && !settings.showAccounts) {
        return;
    }

    const std::time_t now = std::time(nullptr);
    Terminal::clearScreen();
    if (settings.showTasks) {
        std::cout << display_.renderTasks(now) << "\n";
    }
    if (settings.showAccounts) {
        std::cout << display_.renderAccounts(now) << "\n";
    }
}

bool Repl::confirm(const std::string& question) const {
    std::cout << question << " (y/n): " << std::flush;
    std::string answer;
    if (!std::getline(std::cin, answer)) {
        return false;
    }
    answer = StringUtil::lower(StringUtil::trim(answer));
    return answer == "y" || answer == "yes";
}

void Repl::requireName(const std::string& name) {
    if (name.empty() || name == "-") {
        throw std::runtime_error("'" + name + "' is not a valid name.");
    }
}

Status Repl::parseStatusFrom(const Args& args, std::size_t from) {
    const std::string text = StringUtil::join(args, from, " ");
    std::optional<Status> status = StatusUtil::parse(text, std::time(nullptr));
    if (!status) {
        throw std::runtime_error("Invalid status '" + text + "'. Use: " + kStatusHelp);
    }
    return *status;
}

// ---- Accounts ---------------------------------------------------------------

bool Repl::cmdAccAdd(const Args& args) {
    requireName(args[0]);
    if (db_.findAccount(args[0])) {
        throw std::runtime_error("Account '" + args[0] + "' already exists.");
    }
    db_.addAccount(args[0]);
    say("Account '" + args[0] + "' added.");
    return true;
}

bool Repl::cmdAccDel(const Args& args) {
    std::optional<std::string> name = db_.findAccount(args[0]);
    if (!name) {
        throw std::runtime_error("No account named '" + args[0] + "'.");
    }
    db_.removeAccount(*name);
    say("Account '" + *name + "' deleted.");
    return true;
}

bool Repl::cmdAccRename(const Args& args) {
    std::optional<std::string> name = db_.findAccount(args[0]);
    if (!name) {
        throw std::runtime_error("No account named '" + args[0] + "'.");
    }
    requireName(args[1]);
    if (!StringUtil::equalsIgnoreCase(*name, args[1]) && db_.findAccount(args[1])) {
        throw std::runtime_error("Account '" + args[1] + "' already exists.");
    }
    db_.renameAccount(*name, args[1]);
    say("Account '" + *name + "' renamed to '" + args[1] + "'.");
    return true;
}

bool Repl::cmdAccLs(const Args&) {
    Terminal::clearScreen();
    std::cout << display_.renderAccounts(std::time(nullptr)) << "\n";
    return false;
}

// ---- Tasks ------------------------------------------------------------------

bool Repl::cmdTskAdd(const Args& args) {
    const std::string& name = args[0];
    requireName(name);
    if (db_.findTask(name)) {
        throw std::runtime_error("Task '" + name + "' already exists.");
    }

    std::size_t next = 1;
    std::optional<std::string> account;
    if (next < args.size()) {
        if (std::optional<std::string> found = db_.findAccount(args[next])) {
            account = found;
            ++next;
        } else if (args[next] == "-") {
            ++next;
        } else if (!StatusUtil::parse(StringUtil::join(args, next, " "), std::time(nullptr))) {
            throw std::runtime_error("'" + args[next] + "' is neither an existing account nor a valid status (" +
                                     kStatusHelp + ").");
        }
    }

    Status status = StatusUtil::make(StatusKind::Prompt);
    if (next < args.size()) {
        status = parseStatusFrom(args, next);
    }

    db_.addTask(name, account, StatusUtil::serialize(status));
    say("Task '" + name + "' added.");
    return true;
}

bool Repl::cmdTskDel(const Args& args) {
    std::optional<std::string> name = db_.findTask(args[0]);
    if (!name) {
        throw std::runtime_error("No task named '" + args[0] + "'.");
    }
    db_.removeTask(*name);
    say("Task '" + *name + "' deleted.");
    return true;
}

bool Repl::cmdTskLs(const Args&) {
    Terminal::clearScreen();
    std::cout << display_.renderTasks(std::time(nullptr)) << "\n";
    return false;
}

bool Repl::cmdTskRename(const Args& args) {
    std::optional<std::string> name = db_.findTask(args[0]);
    if (!name) {
        throw std::runtime_error("No task named '" + args[0] + "'.");
    }
    requireName(args[1]);
    if (!StringUtil::equalsIgnoreCase(*name, args[1]) && db_.findTask(args[1])) {
        throw std::runtime_error("Task '" + args[1] + "' already exists.");
    }
    db_.renameTask(*name, args[1]);
    say("Task '" + *name + "' renamed to '" + args[1] + "'.");
    return true;
}

bool Repl::cmdTskReacc(const Args& args) {
    std::optional<std::string> name = db_.findTask(args[0]);
    if (!name) {
        throw std::runtime_error("No task named '" + args[0] + "'.");
    }

    std::optional<std::string> account;
    if (args[1] != "-") {
        account = db_.findAccount(args[1]);
        if (!account) {
            throw std::runtime_error("No account named '" + args[1] + "'.");
        }
    }
    db_.setTaskAccount(*name, account);
    say("Task '" + *name + "' now on account " + (account ? "'" + *account + "'" : std::string("(none)")) + ".");
    return true;
}

bool Repl::cmdTskRestat(const Args& args) {
    std::optional<std::string> name = db_.findTask(args[0]);
    if (!name) {
        throw std::runtime_error("No task named '" + args[0] + "'.");
    }
    Status status = parseStatusFrom(args, 1);
    db_.setTaskStatus(*name, StatusUtil::serialize(status));
    say("Task '" + *name + "' set to " + StatusUtil::label(status) + ".");
    return true;
}

bool Repl::cmdTskNotes(const Args& args) {
    std::optional<TaskRow> task = db_.getTask(args[0]);
    if (!task) {
        throw std::runtime_error("No task named '" + args[0] + "'.");
    }

    std::string command = config_.editor();
    if (command.empty()) {
        command = ExternalEditor::defaultCommand();
    }
    if (command.empty()) {
        throw std::runtime_error("No editor found. Set one with: editor <command>  (e.g. editor nano)");
    }

    const std::string initial = task->notes.empty() ? "" : task->notes + "\n";
    const std::string edited = StringUtil::trim(ExternalEditor::edit(command, initial));

    if (edited == StringUtil::trim(task->notes)) {
        say("Notes unchanged.");
        return false;
    }
    db_.setTaskNotes(task->id, edited);
    say(edited.empty() ? "Notes cleared." : "Notes updated.");
    return true;
}

// ---- Display ----------------------------------------------------------------

bool Repl::cmdDisp(const Args&) {
    const DisplaySettings& settings = display_.settings();
    std::cout << "Task table:    " << (settings.showTasks ? "shown" : "hidden") << " after changes\n";
    std::cout << "Account table: " << (settings.showAccounts ? "shown" : "hidden") << " after changes\n";

    std::cout << "Hidden task levels:";
    if (settings.hiddenTaskLevels.empty()) {
        std::cout << " none";
    }
    for (StatusKind kind : settings.hiddenTaskLevels) {
        std::cout << " " << StatusUtil::kindName(kind);
    }

    std::cout << "\nHidden account levels:";
    if (settings.hiddenAccountLevels.empty()) {
        std::cout << " none";
    }
    for (AccountLevel level : settings.hiddenAccountLevels) {
        std::cout << (level == AccountLevel::Busy ? " busy" : " free");
    }
    std::cout << "\n";
    return false;
}

bool Repl::cmdDispTsk(const Args& args) {
    display_.settings().showTasks = parseVisibility(args[0]);
    return true;
}

bool Repl::cmdDispTskLevel(const Args& args) {
    const bool visible = parseVisibility(args[0]);
    const std::string level = StringUtil::lower(args[1]);

    std::set<StatusKind>& hidden = display_.settings().hiddenTaskLevels;
    std::vector<StatusKind> targets;
    if (level == "all") {
        targets = StatusUtil::allKinds();
    } else {
        std::optional<StatusKind> kind = StatusUtil::kindFromName(level);
        if (!kind) {
            throw std::runtime_error("Unknown level '" + args[1] +
                                     "'. Use: prompt, limit-reset, testing, wait, uploading, frozen, done, all");
        }
        targets = {*kind};
    }

    for (StatusKind target : targets) {
        if (visible) {
            hidden.erase(target);
        } else {
            hidden.insert(target);
        }
    }
    return true;
}

bool Repl::cmdDispAcc(const Args& args) {
    display_.settings().showAccounts = parseVisibility(args[0]);
    return true;
}

bool Repl::cmdDispAccLevel(const Args& args) {
    const bool visible = parseVisibility(args[0]);
    const std::string level = StringUtil::lower(args[1]);

    std::set<AccountLevel>& hidden = display_.settings().hiddenAccountLevels;
    std::vector<AccountLevel> targets;
    if (level == "all") {
        targets = {AccountLevel::Busy, AccountLevel::Free};
    } else if (level == "busy") {
        targets = {AccountLevel::Busy};
    } else if (level == "free") {
        targets = {AccountLevel::Free};
    } else {
        throw std::runtime_error("Unknown level '" + args[1] + "'. Use: busy, free, all");
    }

    for (AccountLevel target : targets) {
        if (visible) {
            hidden.erase(target);
        } else {
            hidden.insert(target);
        }
    }
    return true;
}

// ---- Database ---------------------------------------------------------------

bool Repl::cmdDbSave(const Args&) {
    db_.save();
    say("Saved to " + db_.path() + ".");
    return false;
}

bool Repl::cmdDbBackup(const Args& args) {
    const std::string target = db_.backup(args.empty() ? "" : args[0]);
    say("Backup written to " + target + ".");
    return false;
}

bool Repl::cmdDbRestore(const Args& args) {
    if (db_.dirty() && !confirm("Unsaved changes will be replaced. Continue?")) {
        say("Restore cancelled.");
        return false;
    }
    db_.restore(args[0]);
    say("Restored from " + args[0] + ". Use 'db save' to keep it as the current database.");
    return true;
}

// ---- Misc -------------------------------------------------------------------

bool Repl::cmdEditor(const Args& args) {
    if (args.empty()) {
        if (!config_.editor().empty()) {
            say("Editor: " + config_.editor());
        } else {
            const std::string fallback = ExternalEditor::defaultCommand();
            say(fallback.empty()
                    ? "No editor configured and none found. Set one with: editor <command>"
                    : "Editor: " + fallback + " (default, from $VISUAL / $EDITOR / PATH)");
        }
        return false;
    }

    const std::string command = StringUtil::join(args, 0, " ");
    if (StringUtil::lower(command) == "default") {
        config_.setEditor("");
        config_.save();
        say("Editor reset to the default.");
        return false;
    }

    if (!ExternalEditor::commandExists(command)) {
        throw std::runtime_error("'" + args[0] + "' was not found on your PATH.");
    }
    config_.setEditor(command);
    config_.save();
    say("Editor set to: " + command);
    return false;
}

bool Repl::cmdHelp(const Args&) {
    std::cout << "\nCommands (wrap names with spaces in double quotes):\n";
    for (const Command& command : commands_) {
        if (command.spec.key == "exit") {
            continue;
        }
        std::cout << "  " << command.spec.usage << "\n      " << command.spec.help << "\n";
    }
    std::cout << "\nStatuses: " << kStatusHelp << "\n"
              << "Keys: Up/Down history, Left/Right edit, Tab completes, Ctrl-A/E start/end, "
                 "Ctrl-U/K/W delete, Ctrl-L clear\n\n";
    return false;
}

bool Repl::cmdQuit(const Args&) {
    if (db_.dirty() && confirm("Save changes before exiting?")) {
        db_.save();
        say("Saved to " + db_.path() + ".");
    }
    quit_ = true;
    return false;
}