#include "utils/directories.hpp"
#include "utils/utils.hpp"
#include "servers.hpp"
#include "services.hpp"
#include "templates.hpp"
#include "utils/utils.hpp"
#include "utils/execute.hpp"
#include "output.hpp"
#include <libassert/assert.hpp>
#include "config.hpp"

#include <iostream>
#include <memory>
#include <filesystem>
#include <fstream>
#include <sys/wait.h>
#include <unistd.h>
#include <vector>
#include <string>
#include <iostream>
#include <wordexp.h> // For potential shell-like expansion if needed

namespace dropshell
{

    ServerConfig::ServerConfig(const std::string &server_name) : mValid(false), mServerName(server_name)
    {
        if (server_name.empty())
            return;

        std::string server_json_path = localfile::server_json(server_name);

        // Check if file exists
        if (!std::filesystem::exists(server_json_path))
        {
            std::cerr << "Server environment file not found: " + server_json_path << " for server " << server_name << std::endl;
            return;
        }

        try
        {
            // Use envmanager to handle the environment file
            nlohmann::json server_env_json = nlohmann::json::parse(std::ifstream(server_json_path));
            if (server_env_json.empty())
            {
                error << "Failed to parse server environment file at "<< server_json_path << std::endl;
                info << "The returned json was empty." << std::endl;
                return;
            }

            // get the variables from the json, converting everything to strings.
            for (const auto &var : server_env_json.items())
            {
                std::string value;
                if (var.value().is_string())
                    value = var.value();
                else if (var.value().is_number_integer())
                    value = std::to_string(var.value().get<int>());
                else if (var.value().is_boolean())
                    value = var.value() ? "true" : "false";
                else
                    value = var.value().dump();
                mVariables[var.key()] = replace_with_environment_variables_like_bash(value);
            }

            // Verify required variables exist
            for (const auto &var : {"SSH_HOST", "SSH_PORT", "SSH_USERS"})
            {
                if (mVariables.find(var) == mVariables.end())
                {
                    // Print the variables identified in the file
                    info << "Variables identified in the file:" << std::endl;
                    for (const auto &v : mVariables)
                    {
                        info << "    " << v.first << std::endl;
                    }
                    throw std::runtime_error("Missing required variable: " + std::string(var));
                }
            }

            // Parse users array
            if (!server_env_json.contains("SSH_USERS") || !server_env_json["SSH_USERS"].is_array())
            {
                error << "SSH_USERS array not found or invalid in server configuration" << std::endl;
                return;
            }

            for (const auto &user_json : server_env_json["SSH_USERS"])
            {
                UserConfig user;
                user.user = user_json["USER"].get<std::string>();
                user.dir = user_json["DIR"].get<std::string>();
                mUsers.push_back(user);
            }

            if (mUsers.empty())
            {
                error << "No users defined in server configuration " << server_json_path << std::endl;
                return;
            }

            mValid = true;
        }
        catch (const std::exception &e)
        {
            error << "Failed to parse " << server_json_path << std::endl;
            error << "Exception: " << e.what() << std::endl;

            mValid = false;
        }
    }

    std::string ServerConfig::get_SSH_HOST() const
    {
        return get_variable("SSH_HOST");
    }

    std::string ServerConfig::get_SSH_PORT() const
    {
        return get_variable("SSH_PORT");
    }

    std::vector<UserConfig> ServerConfig::get_users() const
    {
        return mUsers;
    }

    std::string ServerConfig::get_user_dir(const std::string &user) const
    {
        for (const auto &u : mUsers)
        {
            if (u.user == user)
            {
                return u.dir;
            }
        }
        return "";
    }

    std::string ServerConfig::get_server_name() const
    {
        return mServerName;
    }

    std::string ServerConfig::get_user_for_service(const std::string &service) const
    {
        return dropshell::get_user_for_service(mServerName, service);
    }

    std::string get_user_for_service(const std::string &server, const std::string &service)
    {
        if (!legal_service_name(service))
        {
            error << "Service name contains illegal characters: " + service << std::endl;
            return "";
        }

        auto services_info = get_server_services_info(server);
        auto it = std::find_if(services_info.begin(), services_info.end(),
                         [&service](const LocalServiceInfo &si)
                         { return si.service_name == service; });
        if (it != services_info.end() && SIvalid(*it))
            return it->user;

        debug << "Couldn't find user for service \"" << service << "\" on server \"" << server << "\"" << std::endl;
        return "";
    }

    sSSHInfo ServerConfig::get_SSH_INFO(std::string user) const
    {
        ASSERT(!user.empty(), "User is empty, cannot get SSH info.");
        // Find user in mUsers vector
        auto it = std::find_if(mUsers.begin(), mUsers.end(),
                               [&user](const UserConfig &u)
                               { return u.user == user; });
        ASSERT(it != mUsers.end(), ("User " + user + " not found in server environment."));
        return sSSHInfo(get_SSH_HOST(), it->user, get_SSH_PORT(), get_server_name(), it->dir);
    }

    bool ServerConfig::hasRootUser() const
    {
        auto it = std::find_if(mUsers.begin(), mUsers.end(),[](const UserConfig &u)
                               { return u.user == "root"; });
        return it != mUsers.end();
    }

    bool ServerConfig::hasDocker() const
    {
        return get_variable("HAS_DOCKER") == "true";
    }

    bool ServerConfig::hasRootDocker() const
    {
        return get_variable("DOCKER_ROOTLESS") == "false";
    }

    bool ServerConfig::hasUser(const std::string &user) const
    {
        auto it = std::find_if(mUsers.begin(), mUsers.end(),
                               [&user](const UserConfig &u)
                               { return u.user == user; });
        return it != mUsers.end();
    }

    bool ServerConfig::check_remote_dir_exists(const std::string &dir_path, std::string user) const
    {
        if (user.empty())
        {
            debug << "Can't check remote directory exists for " << dir_path << " as user is empty" << std::endl;
            return false;
        }

        sCommand scommand("", "test -d " + quote(dir_path), {});
        return execute_ssh_command(get_SSH_INFO(user), scommand, cMode::Silent);
    }

    bool ServerConfig::check_remote_file_exists(const std::string &file_path, std::string user) const
    {
        if (user.empty())
        {
            debug << "Can't check remote file exists for " << file_path << " as user is empty" << std::endl;
            return false;
        }

        sCommand scommand("", "test -f " + quote(file_path), {});
        return execute_ssh_command(get_SSH_INFO(user), scommand, cMode::Silent);
    }

    bool ServerConfig::check_remote_items_exist(const std::vector<std::string> &file_paths, std::string user) const
    {
        if (user.empty())
        {
            debug << "Can't check remote items exist as user is empty" << std::endl;
            return false;
        }

        // convert file_paths to a single string, separated by spaces
        std::string file_paths_str;
        std::string file_names_str;
        for (const auto &file_path : file_paths)
        {
            file_paths_str += quote(file_path) + " ";
            file_names_str += std::filesystem::path(file_path).filename().string() + " ";
        }
        // check if all items in the vector exist on the remote server, in a single command.
        sCommand scommand("", "for item in " + file_paths_str + "; do test -f $item; done", {});

        sSSHInfo sshinfo = get_SSH_INFO(user);
        bool okay = execute_ssh_command(sshinfo, scommand, cMode::Silent);
        if (!okay)
        {
            error << "Required items not found on remote server: " << file_names_str << std::endl;
            return false;
        }
        return true;
    }

    bool ServerConfig::remove_remote_dir(
        const std::string &dir_path, bool silent, std::string user) const
    {
        std::filesystem::path path(dir_path);
        std::filesystem::path parent_path = path.parent_path();
        std::string target_dir = path.filename().string();

        if (parent_path.empty())
            parent_path = "/";

        if (target_dir.empty())
            return false;

        if (!silent)
            std::cout << "Removing remote directory " << target_dir << " in " << parent_path << " on " << mServerName << std::endl;
        std::string remote_cmd =
            "docker run --rm -v " + quote(parent_path.string()) + ":/parent " +
            " alpine rm -rf \"/parent/" + target_dir + "\"";

        // if (!silent)
        //     std::cout << "Running command: " << remote_cmd << std::endl;

        sCommand scommand("", remote_cmd, {});
        cMode mode = (silent ? cMode::Silent : cMode::Defaults);

        sSSHInfo sshinfo = get_SSH_INFO(user);
        return execute_ssh_command(sshinfo, scommand, mode);
    }

    bool ServerConfig::run_remote_template_command(
        const std::string &service_name,
        const std::string &command,
        std::vector<std::string> args,
        bool silent,
        std::map<std::string, std::string> extra_env_vars) const
    {
        std::string user = get_user_for_service(service_name);
        auto scommand = construct_standard_template_run_cmd(service_name, command, args, silent);
        if (!scommand.has_value())
            return false;

        // add the extra env vars to the command
        for (const auto &[key, value] : extra_env_vars)
            scommand->add_env_var(key, value);

        if (scommand->get_command_to_run().empty())
            return false;
        cMode mode = (command == "ssh") ? (cMode::Interactive) : (silent ? cMode::Silent : cMode::Defaults);
        return execute_ssh_command(get_SSH_INFO(user), scommand.value(), mode);
    }

    bool ServerConfig::run_remote_template_command_and_capture_output(
        const std::string &service_name,
        const std::string &command,
        std::vector<std::string> args,
        std::string &output,
        bool silent,
        std::map<std::string, std::string> extra_env_vars) const
    {
        std::string user = get_user_for_service(service_name);
        auto scommand = construct_standard_template_run_cmd(service_name, command, args, false);
        if (!scommand.has_value())
            return false;

        // add the extra env vars to the command
        for (const auto &[key, value] : extra_env_vars)
            scommand->add_env_var(key, value);

        return execute_ssh_command(get_SSH_INFO(user), scommand.value(), cMode::Defaults, &output);
    }

    std::string ServerConfig::get_variable(const std::string &name) const
    {
        auto it = mVariables.find(name);
        if (it == mVariables.end())
        {
            return "";
        }
        return it->second;
    }

    std::optional<sCommand> ServerConfig::construct_standard_template_run_cmd(const std::string &service_name, const std::string &command, const std::vector<std::string> args, const bool silent) const
    {
        if (command.empty())
            return std::nullopt;

        std::string user = get_user_for_service(service_name);

        std::string remote_service_template_path = remotepath(mServerName, user).service_template(service_name);
        std::string script_path = remote_service_template_path + "/" + command + ".sh";

        std::map<std::string, std::string> env_vars;
        if (!get_all_service_env_vars(mServerName, service_name, env_vars))
        {
            error << "Failed to get all service env vars for " << service_name << std::endl;
            return std::nullopt;
        }

        env_vars["HOST_NAME"] = get_SSH_HOST();

        std::string argstr = "";
        for (const auto &arg : args)
        {
            argstr += " " + quote(dequote(trim(arg)));
        }

        sCommand sc(
            remote_service_template_path,
            quote(script_path) + argstr + (silent ? " > /dev/null 2>&1" : ""),
            env_vars);

        if (sc.empty())
        {
            error << "Failed to construct command for " << service_name << " " << command << std::endl;
            return std::nullopt;
        }
        return sc;
    }

    std::vector<ServerConfig> get_configured_servers()
    {
        std::vector<ServerConfig> servers;

        std::vector<std::string> lsdp = gConfig().get_local_server_definition_paths();
        if (lsdp.empty())
            return servers;

        for (auto servers_dir : lsdp)
        {
            if (!servers_dir.empty() && std::filesystem::exists(servers_dir))
            {
                for (const auto &entry : std::filesystem::directory_iterator(servers_dir))
                {
                    if (std::filesystem::is_directory(entry))
                    {
                        std::string server_name = entry.path().filename().string();

                        if (server_name.empty() || server_name[0] == '.' || server_name[0] == '_')
                            continue;

                        ServerConfig env(server_name);
                        if (!env.is_valid())
                        {
                            error << "Invalid server environment file: " << entry.path().string() << std::endl;
                            continue;
                        }
                        servers.push_back(env);
                    }
                }
            }
        }

        return servers;
    }

    bool create_server(const std::string &server_name)
    {
        // 1. check if server name already exists
        std::string server_existing_dir = localpath::server(server_name);
        if (!server_existing_dir.empty())
        {
            error << "Server name already exists: " << server_name << std::endl;
            info << "Current server path: " << server_existing_dir << std::endl;
            return false;
        }

        // 2. create a new directory in the user config directory
        auto lsdp = gConfig().get_local_server_definition_paths();
        if (lsdp.empty() || lsdp[0].empty())
        {
            error << "Local server definition path not found" << std::endl;
            info << "Run 'dropshell edit' to configure DropShell" << std::endl;
            return false;
        }
        std::string server_dir = lsdp[0] + "/" + server_name;
        std::filesystem::create_directory(server_dir);

        // 3. create a template server.env file in the server directory
        std::string user = getenv("USER");
        std::string server_env_path = server_dir + "/" + filenames::server_json;
        std::ofstream server_env_file(server_env_path);
        server_env_file << "{" << std::endl;
        server_env_file << "    \"SSH_HOST\": \"" << server_name << "\"," << std::endl;
        server_env_file << "    \"SSH_PORT\": " << 22 << "," << std::endl;
        server_env_file << "    \"SSH_USERS\": [" << std::endl;
        server_env_file << "        {" << std::endl;
        server_env_file << "            \"USER\": \"" << user << "\"," << std::endl;
        server_env_file << "            \"DIR\": \"" << "/home/" + user << "/.dropshell\"" << std::endl;
        server_env_file << "        }" << std::endl;
        server_env_file << "    ]," << std::endl;
        server_env_file << "    \"HAS_DOCKER\": \"true\"," << std::endl;
        server_env_file << "    \"DOCKER_ROOTLESS\": \"false\"" << std::endl;
        server_env_file << "}" << std::endl;
        server_env_file.close();

        std::cout << "Server created successfully: " << server_name << std::endl;
        std::cout << "Please complete the installation:" << std::endl;
        std::cout << "1) edit the server configuration: dropshell edit " << server_name << std::endl;
        std::cout << "2) install the server:            dropshell install " << server_name << std::endl;
        std::cout << std::endl;
        return true;
    }

    void get_all_used_commands(std::set<std::string> &commands)
    {
        std::vector<ServerConfig> servers = get_configured_servers();
        for (const auto &server : servers)
        {
            auto services = get_server_services_info(server.get_server_name());
            for (const auto &service : services)
                commands.merge(get_used_commands(server.get_server_name(), service.service_name));
        }
    }

    bool server_exists(const std::string &server_name)
    {
        std::string server_existing_dir = localpath::server(server_name);
        if (server_existing_dir.empty())
            return false;

        if (std::filesystem::exists(server_existing_dir));
            return true;
        return false;
    }

} // namespace dropshell