#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();
}

// https://github.com/bloomen/transwarp?tab=readme-ov-file#range-functions
void list_servers() {
    auto servers = get_configured_servers();

    tableprint tp("All DropShell Servers");
    tp.add_row({"Name", "User", "Address", "Health", "Ports"});

    transwarp::parallel exec{servers.size()};
    auto task = transwarp::for_each(exec, servers.begin(), servers.end(), [&](const ServerInfo& server) {
        std::map<std::string, ServiceStatus> status = service_runner::get_all_services_status(server.name); 

        std::set<int> ports_used;
        std::string serviceticks = "";
        for (const auto& [service_name, service_status] : status) {
            ports_used.insert(service_status.ports.begin(), service_status.ports.end());
            serviceticks += service_runner::HealthStatus2String(service_status.health) + " ";
        }
        std::string ports_used_str = "";
        for (const auto& port : ports_used) 
            ports_used_str += std::to_string(port) + " ";
        
        tp.add_row({server.name, server.ssh_user, server.ssh_host, serviceticks, ports_used_str});
    });
    task->wait();
    tp.print();
}

void show_server_details(const std::string& server_name) {
    server_env_manager env(server_name);
    if (!env.is_valid()) {
        std::cerr << "Error: Invalid server environment file: " << server_name << std::endl;
        return;
    }

    //---------------------
    // Check if server is reachable via SSH
    std::string ssh_address = env.get_SSH_HOST();
    std::string ssh_user = env.get_SSH_USER();
    std::string ssh_port = env.get_SSH_PORT();
    if (!ssh_address.empty()) {
        std::cout << std::endl << "Server Status:" << std::endl;
        std::cout << std::string(40, '-') << std::endl;
        
        // Try to connect to the server
        std::string cmd = "ssh -o ConnectTimeout=5 " + ssh_user + "@" + ssh_address + " -p " + ssh_port + " 'echo connected' 2>/dev/null";
        int result = system(cmd.c_str());
        if (result == 0) {
            std::cout << "Status: Online" << std::endl;
            
            // // Get uptime if possible
            // cmd = "ssh " + ssh_address + " 'uptime' 2>/dev/null";
            // int rval = system(cmd.c_str());
            // if (rval != 0) {
            //     std::cout << "Error: Failed to get uptime" << std::endl;
            // } 
        } else {
            std::cout << "Status: Offline" << std::endl;
        }
    }
    std::cout << std::endl;

    //---------------------
    {
        std::cout << std::endl;
        tableprint tp("Server Configuration: " + server_name, true);
        tp.add_row({"Key", "Value"});
        for (const auto& [key, value] : env.get_variables()) {
            tp.add_row({key, value});
        }
        tp.print();
    }

    //---------------------
    // list services, and run healthcheck on each
    {
        tableprint tp("Services: " + server_name, false);
        tp.add_row({"Status", "Service", "Ports"});
        

        std::map<std::string, ServiceStatus> status = service_runner::get_all_services_status(server_name); 

        std::set<int> ports_used;
        std::string serviceticks = "";
        for (const auto& [service_name, service_status] : status) {
            std::string healthy = service_runner::HealthStatus2String(service_status.health);
            
            std::string ports_str = "";
            for (const auto& port : service_status.ports) 
                ports_str += std::to_string(port) + " ";
        
            tp.add_row({healthy, service_name, ports_str});
        } // end of for (const auto& service : services)
        tp.print();
    } // end of list services
} // end of show_server_details

void 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;
    }

    // 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 - is DropShell initialised?" << std::endl;
        return;
    }
    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;
}

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