#include "servers.hpp"
#include "server_env_manager.hpp"
#include "service_runner.hpp"
#include "utils/tableprint.hpp"
#include "utils/envmanager.hpp"
#include "utils/directories.hpp"
#include "services.hpp"
#include "config.hpp"
#include "templates.hpp"
#include "contrib/transwarp.hpp"

#include <iostream>
#include <fstream>
#include <iomanip>
#include <filesystem>

namespace dropshell {

std::vector<ServerInfo> get_configured_servers() {
    std::vector<ServerInfo> 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;

                    server_env_manager env(server_name);
                    if (!env.is_valid()) {
                        std::cerr << "Error: Invalid server environment file: " << entry.path().string() << std::endl;
                        continue;
                    }
                    servers.push_back({
                        server_name,
                        env.get_SSH_HOST(),
                        env.get_SSH_USER(),
                        env.get_SSH_PORT()
                    });
                }
            }
        }
    }

    return servers;
}

ServerInfo get_server_info(const std::string &server_name)
{
    std::vector<std::string> lsdp = gConfig().get_local_server_definition_paths();
    if (lsdp.empty())
        return ServerInfo();

    for (auto &config_dir : lsdp) {
        std::string server_dir = config_dir + "/" + server_name;
        if (std::filesystem::exists(server_dir)) {
            server_env_manager env(server_name);
            if (!env.is_valid()) {
                std::cerr << "Error: Invalid server environment file: " << server_dir << std::endl;
                continue;
            }
            return ServerInfo({server_name, env.get_SSH_HOST(), env.get_SSH_USER(), env.get_SSH_PORT()});
        }
    }
    return ServerInfo();
}


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()) {
        std::cerr << "Error: Server name already exists: " << server_name << std::endl;
        std::cerr << "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()) {
        std::cerr << "Error: Local server definition path not found" << std::endl;
        std::cerr << "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 + "/server.env";
    std::ofstream server_env_file(server_env_path);
    server_env_file << "SSH_HOST=" << server_name << std::endl;
    server_env_file << "SSH_USER=" << user << std::endl;
    server_env_file << "SSH_PORT=" << 22 << std::endl;
    server_env_file << std::endl;
    server_env_file << "DROPSHELL_DIR=/home/"+user+"/.dropshell" << std::endl;
    server_env_file.close();

    // 4. add dropshell-agent service to server
    create_service(server_name, "dropshell-agent", "dropshell-agent", true); // silently create service.

    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) test ssh is working:           dropshell ssh " << server_name << std::endl;
    std::cout << "3) install dropshell-agent:       dropshell install " << server_name << " dropshell-agent" << std::endl;
    std::cout << std::endl;
    return true;
}

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

} // namespace dropshell