#include "directories.hpp"
#include "config.hpp"
#include "servers.hpp"
#include "output.hpp"

#include <iostream>
#include <string>
#include <filesystem>


namespace fs = std::filesystem;

namespace dropshell {


namespace localfile {

    std::string dropshell_json() {
        // Try ~/.config/dropshell/dropshell.json
        std::string homedir = localpath::current_user_home();
        if (!homedir.empty()) {
            fs::path user_path = fs::path(homedir) / ".config" / "dropshell" /  "dropshell.json";
            return user_path.string();
        }
        return std::string();
    }

    std::string server_json(const std::string &server_name) {
        std::string serverpath = localpath::server(server_name);
        return (serverpath.empty() ? "" : (fs::path(serverpath) / "server.json").string());
    }

    std::string service_env(const std::string &server_name, const std::string &service_name) {
        std::string servicepath = localpath::service(server_name, service_name);
        return (servicepath.empty() ? "" : (fs::path(servicepath) / "service.env").string());
    }

    std::string template_info_env(const std::string &server_name, const std::string &service_name)
    {
        std::string servicepath = localpath::service(server_name, service_name);
        return (servicepath.empty() ? "" : (fs::path(servicepath) / ".template_info.env").string());
    }

    std::string template_example()
    {
        return localpath::agent_local() + "/template_example";
    }

    std::string bb64()
    {
        return localpath::agent_local() + "/bb64";
    }

} // namespace localfile


// ------------------------------------------------------------------------------------------

namespace localpath {
        std::string server(const std::string &server_name) {
            for (std::filesystem::path dir : gConfig().get_local_server_definition_paths()) 
                if (fs::exists(dir / server_name))
                    return dir / server_name;

            return "";
        }

        std::string service(const std::string &server_name, const std::string &service_name) {
            std::string serverpath = localpath::server(server_name);
            return ((serverpath.empty() || service_name.empty()) ? "" : (serverpath+"/"+service_name));
        }

        std::string remote_versions(const std::string &server_name, const std::string &service_name)
        {
            std::string template_cache_path = localpath::template_cache();
            return ((template_cache_path.empty() || service_name.empty()) ? "" : 
               (template_cache_path+"/remote_versions/"+service_name+".json"));
        }
        std::string agent_local()
        {
            return current_user_home()+"/.local/dropshell_agent/agent-local";
        }
        std::string agent_remote()
        {
            return current_user_home() + "/.local/dropshell_agent/agent-remote";
        }
        std::string current_user_home()
        {
            char * homedir = std::getenv("HOME");
            if (homedir)
            {
                std::filesystem::path homedir_path(homedir);
                return fs::canonical(homedir_path).string();
            }
            warning << "Couldn't determine user directory" << std::endl;
            return std::string();
        }

        std::string dropshell_files()
        {
            return current_user_home() + "/.local/dropshell_files";
            return std::string();
        }

        std::string backups()
        {
            return dropshell_files() + "/backups";
        }

        std::string temp_files()
        {
            return dropshell_files() + "/temp_files";
        }

        std::string template_cache()
        {
            return dropshell_files() + "template_cache";
        }

        bool create_directories()
        {
            std::vector<std::filesystem::path> paths = {
                dropshell_files(),
                agent_local(),
                agent_remote(),
                template_cache(),
                backups(),
                temp_files()
                };
            for (auto &p : gConfig().get_local_server_definition_paths())
                paths.push_back(p);

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

} // namespace localpath

    //------------------------------------------------------------------------------------------------
    // remote paths
    // DROPSHELL_DIR
    //   |-- backups
    //   |-- temp_files
    //   |-- agent
    //   |   |-- bb64
    //   |   |-- (other agent files, including _allservicesstatus.sh)
    //   |-- services
    //       |-- service name
    //           |-- config
    //               |-- service.env (actual service config)
    //           |-- template
    //               |-- _default.env
    //               |-- (script files)
    //               |-- config
    //                   |-- service.env (default service config)
    //                   |-- (other config files for specific server&service)


    remotefile::remotefile(const std::string &server_name, const std::string &user) : 
        mServer_name(server_name), mUser(user) {}

    std::string remotefile::service_env(const std::string &service_name) const
    {
        return remotepath(mServer_name,mUser).service_config(service_name) + "/service.env";
    }


    remotepath::remotepath(const std::string &server_name, const std::string &user) : mServer_name(server_name), mUser(user) {}

    std::string remotepath::DROPSHELL_DIR() const
    {            
        return server_config(mServer_name).get_user_dir(mUser);
    }

    std::string remotepath::services() const
    {
        std::string dsp = DROPSHELL_DIR();
        return (dsp.empty() ? "" : (dsp + "/services"));
    }

    std::string remotepath::service(const std::string &service_name) const
    {
        std::string services_path = services();
        return (services_path.empty() ? "" : (services_path + "/" + service_name));
    }

    std::string remotepath::service_config(const std::string &service_name) const
    {
        std::string service_path = service(service_name);
        return (service_path.empty() ? "" : (service_path + "/config"));
    }

    std::string remotepath::service_template(const std::string &service_name) const
    {
        std::string service_path = service(service_name);
        return (service_path.empty() ? "" : (service_path + "/template"));
    }

    std::string remotepath::backups() const
    {
        std::string dsp = DROPSHELL_DIR();
        return (dsp.empty() ? "" : (dsp + "/backups"));
    }

    std::string remotepath::temp_files() const
    {
        std::string dsp = DROPSHELL_DIR();
        return (dsp.empty() ? "" : (dsp + "/temp_files"));
    }

    std::string remotepath::agent() const
    {
        std::string dsp = DROPSHELL_DIR();
        return (dsp.empty() ? "" : (dsp + "/agent"));
    }

    // std::string remotepath::service_env(const std::string &service_name) const
    // {
    //     std::string service_path = service_config(service_name);
    //     return (service_path.empty() ? "" : (service_path + "/service.env"));
    // }


// ------------------------------------------------------------------------------------------
// Utility functions

std::string get_parent(const std::filesystem::path path)
{
    if (path.empty())
        return std::string();
    return path.parent_path().string();
}

std::string get_child(const std::filesystem::path path)
{
    if (path.empty())
        return std::string();
    return path.filename().string();
}

} // namespace dropshell