#include "command_registry.hpp"
#include "config.hpp"
#include "utils/utils.hpp"
#include "utils/directories.hpp"
#include "templates.hpp"
#include "shared_commands.hpp"
#include "utils/hash.hpp"
#include "autogen/_agent-local.hpp"
#include "autogen/_agent-remote.hpp"
#include "services.hpp"
#include "utils/output.hpp"

#include <fstream>
#include <unistd.h>
#include <cstring>
#include <iostream>
#include <sstream>
#include <filesystem>
#include "utils/assert.hpp"
#include "servers.hpp"

namespace dropshell
{

    int install_handler(const CommandContext &ctx);

    static std::vector<std::string> install_name_list = {"install", "reinstall", "update"};

    // Static registration
    struct InstallCommandRegister
    {
        InstallCommandRegister()
        {
            CommandRegistry::instance().register_command({install_name_list,
                                                          install_handler,
                                                          shared_commands::std_autocomplete_allowall,
                                                          false, // hidden
                                                          false, // requires_config
                                                          false, // requires_install
                                                          0,     // min_args (after command)
                                                          2,     // max_args (after command)
                                                          "install [SERVER] [SERVICE|all]",
                                                          "Install/reinstall host, remote servers, or service(s). Safe/non-destructive way to update.",
                                                          // heredoc
                                                          R"(
            Install components on a server. This is safe to re-run (non-destructive) and used to update
            servers and their services.

            install                      (re)install dropshell components on this computer, and on all servers.
            install SERVER               (re)install dropshell agent on the particular given server.
            install SERVER [SERVICE|all] (re)install the given service (or all services) on the given server.

            Note you need to create the service first with:
                dropshell create-service <server> <template> <service>
            )"});
        }
    } install_command_register;


    namespace shared_commands
    {

        // ------------------------------------------------------------------------------------------------
        // install service over ssh : SHARED COMMAND
        // ------------------------------------------------------------------------------------------------
        bool install_service(const std::string &server, const std::string &service)
        {
            LocalServiceInfo service_info = get_service_info(server, service);
            if (!SIvalid(service_info))
                return false;

            server_env_manager server_env(server);
            if (!server_env.is_valid())
                return false;

            maketitle("Installing " + service + " (" + service_info.template_name + ") on " + server);

            if (!server_env.is_valid())
                return false; // should never hit this.

            // Check if template exists
            template_info tinfo = gTemplateManager().get_template_info(service_info.template_name);
            if (!tinfo.is_set())
                return false;

            if (!tinfo.template_valid())
            {
                std::cerr << "Template is not valid: " << service_info.template_name << std::endl;
                return false;
            }

            // Create service directory
            std::string remote_service_path = remotepath::service(server, service);
            std::string mkdir_cmd = "mkdir -p " + quote(remote_service_path);
            if (!execute_ssh_command(server_env.get_SSH_INFO(), sCommand("", mkdir_cmd, {}), cMode::Silent))
            {
                std::cerr << "Failed to create service directory " << remote_service_path << std::endl;
                return false;
            }

            // Check if rsync is installed on remote host
            std::string check_rsync_cmd = "which rsync";
            if (!execute_ssh_command(server_env.get_SSH_INFO(), sCommand("", check_rsync_cmd, {}), cMode::Silent))
            {
                std::cerr << "rsync is not installed on the remote host" << std::endl;
                return false;
            }

            // Copy template files
            debug << "Copying: [LOCAL] " << tinfo.local_template_path() << std::endl
                  << std::string(8, ' ') << "[REMOTE] " << remotepath::service_template(server, service) << "/" << std::endl;
            if (!shared_commands::rsync_tree_to_remote(tinfo.local_template_path().string(), remotepath::service_template(server, service),
                                                       server_env, false))
            {
                std::cerr << "Failed to copy template files using rsync" << std::endl;
                return false;
            }

            // Copy service files
            debug << "Copying: [LOCAL] " << localpath::service(server, service) << std::endl
                  << std::string(8, ' ') << "[REMOTE] " << remotepath::service_config(server, service) << std::endl;
            if (!shared_commands::rsync_tree_to_remote(localpath::service(server, service), remotepath::service_config(server, service),
                                                       server_env, false))
            {
                std::cerr << "Failed to copy service files using rsync" << std::endl;
                return false;
            }

            // Run install script
            {
                info << "Running " << service_info.template_name << " install script on " << server << "..." << std::endl;
                server_env.run_remote_template_command(service, "install", {}, false, {});
            }

            // print health tick
            info << "Health: " << shared_commands::healthtick(server, service) << std::endl;

           
            return true;
        }

    } // namespace shared_commands

    // ------------------------------------------------------------------------------------------------
    // update_dropshell
    // ------------------------------------------------------------------------------------------------

    std::string _exec(const char *cmd)
    {
        char buffer[128];
        std::string result = "";
        FILE *pipe = popen(cmd, "r");
        if (!pipe)
        {
            throw std::runtime_error("popen() failed!");
        }
        while (!feof(pipe))
        {
            if (fgets(buffer, 128, pipe) != nullptr)
                result += buffer;
        }
        pclose(pipe);
        return trim(result);
    }

    int update_dropshell()
    {
        maketitle("Updating dropshell on this computer...");

        // determine path to this executable
        std::filesystem::path dropshell_path = std::filesystem::canonical("/proc/self/exe");
        std::filesystem::path parent_path = dropshell_path.parent_path();

        // determine the architecture of the system
        std::string arch = shared_commands::get_arch();

        std::string url = "https://gitea.jde.nz/public/dropshell/releases/download/latest/dropshell." + arch;

        // download new version, preserve permissions and ownership
        std::string bash_script;
        bash_script += "docker run --rm -v " + parent_path.string() + ":/target";
        bash_script += " gitea.jde.nz/public/debian-curl:latest";
        bash_script += " sh -c \"";
        bash_script += " curl -fsSL " + url + " -o /target/dropshell_temp &&";
        bash_script += " chmod --reference=/target/dropshell /target/dropshell_temp &&";
        bash_script += " chown --reference=/target/dropshell /target/dropshell_temp";
        bash_script += "\"";

        std::string cmd = "bash -c '" + bash_script + "'";
        int rval = system(cmd.c_str());
        if (rval != 0)
        {
            std::cerr << "Failed to download new version of dropshell." << std::endl;
            return -1;
        }

        // check if the new version is the same as the old version
        uint64_t new_hash = hash_file(parent_path / "dropshell_temp");
        uint64_t old_hash = hash_file(parent_path / "dropshell");
        if (new_hash == old_hash)
        {
            std::cout << "Confirmed dropshell is the latest version." << std::endl;
            return 0;
        }

        std::string runvercmd = (parent_path / "dropshell").string() + " version";
        std::string currentver = _exec(runvercmd.c_str());
        runvercmd = (parent_path / "dropshell_temp").string() + " version";
        std::string newver = _exec(runvercmd.c_str());

        if (currentver >= newver)
        {
            info << "Current dropshell version: " << currentver << ", published version: " << newver << std::endl;
            info << "Release version is not newer, no update needed." << std::endl;
            return 0;
        }

        return 0;

        std::string bash_script_2 = "docker run --rm -v " + parent_path.string() + ":/target gitea.jde.nz/public/debian-curl:latest " +
                                    "sh -c \"mv /target/dropshell_temp /target/dropshell\"";
        rval = system(bash_script_2.c_str());
        if (rval != 0)
        {
            error << "Failed to install new version of dropshell." << std::endl;
            return -1;
        }

        info << "Successfully updated " << dropshell_path << " to the latest " << arch << " version." << std::endl;

        // execute the new version
        execlp("bash", "bash", "-c", (parent_path / "dropshell").c_str(), "install", (char *)nullptr);
        error << "Failed to execute new version of dropshell." << std::endl;
        return -1;
    }

    int install_local_agent()
    {
        maketitle("Installing dropshell agent on this computer...");

        std::vector<std::filesystem::path> paths = {
            gConfig().get_local_template_cache_path(),
            gConfig().get_local_backup_path(),
            gConfig().get_local_tempfiles_path(),
            localpath::agent()};
        for (auto &p : gConfig().get_local_server_definition_paths())
            paths.push_back(p);

        for (auto &p : paths)
            if (!std::filesystem::exists(p))
            {
                info << "Creating directory: " << p << std::endl;
                std::filesystem::create_directories(p);
            }

        // create the agent-local directory.
        recreate_agent_local::recreate_tree(localpath::agent());

        // run the local agent installer.
            execute_local_command(localpath::agent(), "agent-install.sh",{}, nullptr, cMode::Defaults | cMode::NoBB64);

        // create the agent-remote directory.
        info << "Creating local files to copy to remote agents..." << std::endl;
        recreate_agent_remote::recreate_tree(localpath::files_for_remote_agent());

        return 0;
    }

    int install_server(const std::string &server)
    {
        // install the dropshell agent on the given server.
        maketitle("Installing dropshell agent on " + server, sColour::INFO);

        std::string agent_path = remotepath::agent(server);
        if (agent_path.empty())
        {
            error << "Failed to get agent path for " << server << std::endl;
            return 1;
        }

        server_env_manager server_env(server);
        if (!server_env.is_valid())
        {
            error << "Invalid server environment for " << server << std::endl;
            return 1;
        }

        // now create the agent.
        // copy across from the local agent files.
        info << "Copying local agent files to remote server... " << std::flush;
        shared_commands::rsync_tree_to_remote(localpath::files_for_remote_agent(), agent_path, server_env, false);
        info << "done." << std::endl;

        // run the agent installer. Can't use BB64 yet, as we're installing it on the remote server.
        
        bool okay = execute_ssh_command(server_env.get_SSH_INFO(), sCommand(agent_path, "agent-install.sh",{}), cMode::Defaults | cMode::NoBB64, nullptr);
        if (!okay)
        {
            error << "ERROR: Failed to install remote agent on " << server << std::endl;
            return 1;
        }

        info << "Installation on " << server << " complete." << std::endl;
        return 0;
    }

    // ------------------------------------------------------------------------------------------------
    // install_host
    // ------------------------------------------------------------------------------------------------
    int install_host()
    {
        // update dropshell.
        // install the local dropshell agent.

        int rval = update_dropshell();
        if (rval != 0)
            return rval;

        rval = install_local_agent();
        if (rval != 0)
            return rval;

        // install the dropshell agent on all servers.
        std::vector<ServerInfo> servers = get_configured_servers();
        for (const auto &server : servers)
        {
            rval = install_server(server.name);
            if (rval != 0)
                return rval;
        }

        std::cout << "Installation complete." << std::endl;
        return 0;
    }

    // ------------------------------------------------------------------------------------------------
    // install command implementation
    // ------------------------------------------------------------------------------------------------
    int install_handler(const CommandContext &ctx)
    {
        if (ctx.args.size() < 1)
        { // install host
            return install_host();
        }

        if (!gConfig().is_config_set())
        {
            error << "Dropshell is not configured. Please run 'dropshell edit' to configure it." << std::endl;
            return 1;
        }

        std::string server = safearg(ctx.args, 0);

        if (ctx.args.size() == 1)
        { // install server
            return install_server(server);
        }

        // install service(s)
        if (safearg(ctx.args, 1) == "all")
        {
            // install all services on the server
            maketitle("Installing all services on " + server);
            bool okay = true;
            std::vector<LocalServiceInfo> services = get_server_services_info(server);
            for (const auto &service : services)
            {
                if (!shared_commands::install_service(server, service.service_name))
                    okay = false;
            }
            return okay ? 0 : 1;
        }
        else
        { // install the specific service.
            std::string service = safearg(ctx.args, 1);
            return shared_commands::install_service(server, service) ? 0 : 1;
        }
    }

} // namespace dropshell