#include "shared_commands.hpp"
#include "utils/assert.hpp"
#include "utils/utils.hpp"
#include "server_env_manager.hpp"
#include "directories.hpp"
#include "services.hpp"
#include "servers.hpp"
#include "utils/output.hpp"

namespace dropshell
{

    namespace shared_commands
    {

        // ------------------------------------------------------------------------------------------------
        // std_autocomplete : SHARED COMMAND
        // ------------------------------------------------------------------------------------------------
        void std_autocomplete(const CommandContext &ctx)
        {
            if (ctx.args.size() == 0)
            { // just the command, no args yet.
                // list servers
                std::vector<ServerInfo> servers = get_configured_servers();
                for (const auto &server : servers)
                {
                    rawout << server.name << std::endl;
                }
            }
            else if (ctx.args.size() == 1)
            {
                // list services
                std::vector<LocalServiceInfo> services = get_server_services_info(ctx.args[0]);
                for (const auto &service : services)
                {
                    rawout << service.service_name << std::endl;
                }
            }
        }

        // ------------------------------------------------------------------------------------------------
        // std_autocomplete_allowall : SHARED COMMAND
        // ------------------------------------------------------------------------------------------------
        void std_autocomplete_allowall(const CommandContext &ctx)
        {
            std_autocomplete(ctx);
            if (ctx.args.size() == 1)
                rawout << "all" << std::endl;
        }

        // ------------------------------------------------------------------------------------------------
        // rsync_tree_to_remote : SHARED COMMAND
        // ------------------------------------------------------------------------------------------------
        bool rsync_tree_to_remote(
            const std::string &local_path,
            const std::string &remote_path,
            server_env_manager &server_env,
            bool silent)
        {
            ASSERT(!local_path.empty() && !remote_path.empty(), "Local or remote path not specified. Can't rsync.");

            std::string rsync_cmd = "rsync --delete --mkpath -zrpc -e 'ssh -p " + server_env.get_SSH_PORT() + "' " +
                                    quote(local_path + "/") + " " +
                                    quote(server_env.get_SSH_UNPRIVILEGED_USER() + "@" + server_env.get_SSH_HOST() + ":" +
                                          remote_path + "/");
            return execute_local_command("", rsync_cmd, {}, nullptr, (silent ? cMode::Silent : cMode::Defaults));
        }

        // ------------------------------------------------------------------------------------------------
        // get_arch : SHARED COMMAND
        // ------------------------------------------------------------------------------------------------
        std::string get_arch()
        {
            // determine the architecture of the system
            std::string arch;
#ifdef __aarch64__
            arch = "arm64";
#elif __x86_64__
            arch = "amd64";
#endif
            return arch;
        }

        // ------------------------------------------------------------------------------------------------
        // cRemoteTempFolder : SHARED CLASS
        // ------------------------------------------------------------------------------------------------
        cRemoteTempFolder::cRemoteTempFolder(const server_env_manager &server_env, std::string user) : 
        mServerEnv(server_env), mUser(user)
        {
            std::string p = remotepath(server_env.get_server_name(),user).temp_files() + "/" + random_alphanumeric_string(10);
            std::string mkdir_cmd = "mkdir -p " + quote(p);
            if (!execute_ssh_command(server_env.get_SSH_INFO(user), sCommand("", mkdir_cmd, {}), cMode::Silent))
                error << "Failed to create temp directory on server" << std::endl;
            else
                mPath = p;
        }

        cRemoteTempFolder::~cRemoteTempFolder()
        {
            std::string rm_cmd = "rm -rf " + quote(mPath);
            execute_ssh_command(mServerEnv.get_SSH_INFO(mUser), sCommand("", rm_cmd, {}), cMode::Silent);
        }

        std::string cRemoteTempFolder::path() const
        {
            return mPath;
        }

        // ------------------------------------------------------------------------------------------------
        // get_all_services_status : SHARED COMMAND
        // ------------------------------------------------------------------------------------------------
        std::map<std::string, ServiceStatus> get_all_services_status(std::string server_name)
        {
            std::map<std::string, ServiceStatus> status;

            server_env_manager env(server_name);
            if (!env.is_valid())
            {
                error << "Invalid server environment" << std::endl;
                return status;
            }

            for (const auto& user : env.get_users()) {
                std::string output;
                std::string agentpath = remotepath(server_name,user.user).agent();
                if (!execute_ssh_command(env.get_SSH_INFO(user.user), 
                    sCommand(agentpath, "./_allservicesstatus.sh", {{"HOST_NAME", server_name}, {"SERVER", server_name}, {"AGENT_PATH", agentpath}}),
                    cMode::Silent,
                    &output))
                    return status;

                std::stringstream ss(output);
                std::string line;
                while (std::getline(ss, line))
                {
                    std::string key, value;
                    std::size_t pos = line.find("=");
                    if (pos != std::string::npos)
                    {
                        key = dequote(trim(line.substr(0, pos)));
                        value = dequote(trim(line.substr(pos + 1)));

                        // decode key, it's of format SERVICENAME_[HEALTH|PORTS]
                        std::string service_name = key.substr(0, key.find_last_of("_"));
                        std::string status_type = key.substr(key.find_last_of("_") + 1);

                        if (status_type == "HEALTH")
                        { // healthy|unhealthy|unknown
                            if (value == "healthy")
                                status[service_name].health = HealthStatus::HEALTHY;
                            else if (value == "unhealthy")
                                status[service_name].health = HealthStatus::UNHEALTHY;
                            else if (value == "unknown")
                                status[service_name].health = HealthStatus::UNKNOWN;
                            else
                                status[service_name].health = HealthStatus::ERROR;
                        }
                        else if (status_type == "PORTS")
                        { // port1,port2,port3
                            std::vector<std::string> ports = string2multi(value);
                            for (const auto &port : ports)
                            {
                                if (port != "unknown")
                                    status[service_name].ports.push_back(str2int(port));
                            }
                        }
                    }
                }
            }

            return status;
        }

        // ------------------------------------------------------------------------------------------------
        // healthtick : SHARED COMMAND
        // ------------------------------------------------------------------------------------------------
        std::string healthtick(const std::string &server, const std::string &service)
        {
            std::string green_tick = "\033[32m✓\033[0m";
            std::string red_cross = "\033[31m✗\033[0m";
            std::string yellow_exclamation = "\033[33m!\033[0m";
            std::string unknown = "\033[37m✓\033[0m";

            HealthStatus status = is_healthy(server, service);
            if (status == HealthStatus::HEALTHY)
                return green_tick;
            else if (status == HealthStatus::UNHEALTHY)
                return red_cross;
            else if (status == HealthStatus::UNKNOWN)
                return unknown;
            else
                return yellow_exclamation;
        }

        // ------------------------------------------------------------------------------------------------
        // HealthStatus2String : SHARED COMMAND
        // ------------------------------------------------------------------------------------------------
        std::string HealthStatus2String(HealthStatus status)
        {
            if (status == HealthStatus::HEALTHY)
                return ":tick:";
            else if (status == HealthStatus::UNHEALTHY)
                return ":cross:";
            else if (status == HealthStatus::UNKNOWN)
                return ":greytick:";
            else if (status == HealthStatus::NOTINSTALLED)
                return ":warning:";
            else
                return ":error:";
        }

        // ------------------------------------------------------------------------------------------------
        // is_healthy : SHARED COMMAND
        // ------------------------------------------------------------------------------------------------
        HealthStatus is_healthy(const std::string &server, const std::string &service)
        {
            server_env_manager env(server);
            if (!env.is_valid())
            {
                error << "Server service not initialized" << std::endl;
                return HealthStatus::ERROR;
            }

            std::string user = env.get_user_for_service(server, service);

            if (!env.check_remote_dir_exists(remotepath(server,user).service(service), user))
            {
                return HealthStatus::NOTINSTALLED;
            }

            std::string script_path = remotepath(server,user).service_template(service) + "/status.sh";
            if (!env.check_remote_file_exists(script_path, user))
            {
                return HealthStatus::UNKNOWN;
            }

            // Run status script, does not display output.
            if (!env.run_remote_template_command(service, "status", {}, true, {}))
                return HealthStatus::UNHEALTHY;
            return HealthStatus::HEALTHY;
        }

        // ------------------------------------------------------------------------------------------------
        // healthmark : SHARED COMMAND
        // ------------------------------------------------------------------------------------------------
        std::string healthmark(const std::string &server, const std::string &service)
        {
            HealthStatus status = is_healthy(server, service);
            return HealthStatus2String(status);
        }

        // ------------------------------------------------------------------------------------------------
        // cBackupFileName : SHARED CLASS
        // ------------------------------------------------------------------------------------------------
        cBackupFileName::cBackupFileName(const std::string &server, const std::string &service, const std::string &template_name)
        {
            mServer = server;
            mService = service;
            mTemplateName = template_name;
            // Get current datetime for backup filename
            auto now = std::chrono::system_clock::now();
            auto time = std::chrono::system_clock::to_time_t(now);
            std::stringstream datetime;
            datetime << std::put_time(std::localtime(&time), "%Y-%m-%d_%H-%M-%S");
            mDatetime = datetime.str();
        }

        cBackupFileName::cBackupFileName(const std::string &filename)
        {
            // Parse the filename according to the format:
            // server + magic_string() + template_name + magic_string() + service + magic_string() + datetime + ".tgz"
            std::string name = filename;
            if (name.size() > 4 && name.substr(name.size() - 4) == ".tgz")
                name = name.substr(0, name.size() - 4);
            std::string sep = magic_string();
            size_t first = name.find(sep);
            size_t second = name.find(sep, first + sep.size());
            size_t third = name.find(sep, second + sep.size());
            if (first == std::string::npos || second == std::string::npos || third == std::string::npos)
            {
                mServer = mService = mTemplateName = mDatetime = "";
                return;
            }
            mServer = name.substr(0, first);
            mTemplateName = name.substr(first + sep.size(), second - (first + sep.size()));
            mService = name.substr(second + sep.size(), third - (second + sep.size()));
            mDatetime = name.substr(third + sep.size());
        }

        std::string cBackupFileName::get_filename() const
        {
            return mServer + magic_string() + mTemplateName + magic_string() + mService + magic_string() + mDatetime + ".tgz";
        }

        std::string cBackupFileName::get_server() const { return mServer; }
        std::string cBackupFileName::get_service() const { return mService; }
        std::string cBackupFileName::get_template_name() const { return mTemplateName; }
        std::string cBackupFileName::get_datetime() const { return mDatetime; }

        bool cBackupFileName::is_valid() const
        {
            // All fields must be non-empty, and none may contain the magic string
            return !mServer.empty() && !mService.empty() && !mTemplateName.empty() && !mDatetime.empty() &&
                   !has_magic_string(mServer) && !has_magic_string(mService) && !has_magic_string(mTemplateName);
        }

        // ------------------------------------------------------------------------------------------------
        // scp_file_to_remote : SHARED COMMAND
        // ------------------------------------------------------------------------------------------------
        bool scp_file_to_remote(const server_env_manager &server_env, const std::string &local_path, const std::string &remote_path, bool silent)
        {
            if (!server_env.is_valid())
            {
                error << "Invalid server environment" << std::endl;
                return false;
            }
            ASSERT(!remote_path.empty() && !local_path.empty(), "Remote or local path not specified. Can't scp.");
            std::string scp_cmd = "scp -P " + server_env.get_SSH_PORT() + " " + quote(local_path) + " " + server_env.get_SSH_UNPRIVILEGED_USER() + "@" + server_env.get_SSH_HOST() + ":" + quote(remote_path) + (silent ? " > /dev/null 2>&1" : "");
            return execute_local_command("", scp_cmd, {}, nullptr, (silent ? cMode::Silent : cMode::Defaults));
        }

        // ------------------------------------------------------------------------------------------------
        // scp_file_from_remote : SHARED COMMAND
        // ------------------------------------------------------------------------------------------------
        bool scp_file_from_remote(const server_env_manager &server_env, const std::string &remote_path, const std::string &local_path, bool silent)
        {
            if (!server_env.is_valid())
            {
                error << "Invalid server environment" << std::endl;
                return false;
            }
            ASSERT(!remote_path.empty() && !local_path.empty(), "Remote or local path not specified. Can't scp.");
            std::string scp_cmd = "scp -P " + server_env.get_SSH_PORT() + " " + server_env.get_SSH_UNPRIVILEGED_USER() + "@" + server_env.get_SSH_HOST() + ":" + quote(remote_path) + " " + quote(local_path) + (silent ? " > /dev/null 2>&1" : "");
            return execute_local_command("", scp_cmd, {}, nullptr, (silent ? cMode::Silent : cMode::Defaults));
        }

    } // namespace shared_commands

} // namespace dropshell