//
// Created by WolverinDEV on 28/04/2020.
//

#include <netinet/in.h>
#include "LocalFileProvider.h"

using namespace ts::server;
using LocalFileServer = file::LocalFileProvider;
using LocalVirtualFileServer = file::LocalVirtualFileServer;

std::shared_ptr<LocalFileServer> server_instance{};
bool file::initialize(std::string &error) {
    server_instance = std::make_shared<LocalFileProvider>();

    if(!server_instance->initialize(error)) {
        server_instance = nullptr;
        return false;
    }
    return true;
}

void file::finalize() {
    auto server = std::exchange(server_instance, nullptr);
    if(!server) return;

    server->finalize();
}

std::shared_ptr<file::AbstractFileServer> file::server() {
    return server_instance;
}

LocalFileServer::LocalFileProvider() : file_system_{}, file_transfer_{this->file_system_} {}
LocalFileServer::~LocalFileProvider() {}

bool LocalFileServer::initialize(std::string &error) {
    if(!this->file_system_.initialize(error, "files/"))
        return false;


    std::deque<std::shared_ptr<transfer::NetworkBinding>> bindings{};
    {
        auto binding = std::make_shared<transfer::NetworkBinding>();

        binding->hostname = "0.0.0.0";

        auto& iaddr = *(sockaddr_in*) &binding->address;
        iaddr.sin_family = AF_INET;
        iaddr.sin_port = htons(1112);
        iaddr.sin_addr.s_addr = INADDR_ANY;

        bindings.push_back(std::move(binding));
    }

    if(!this->file_transfer_.start(bindings)) {
        error = "transfer server startup failed";
        this->file_system_.finalize();
        return false;
    }
    return true;
}

void LocalFileServer::finalize() {
    this->file_transfer_.stop();
    this->file_system_.finalize();
}

file::filesystem::AbstractProvider &LocalFileServer::file_system() {
    return this->file_system_;
}

file::transfer::AbstractProvider &LocalFileServer::file_transfer() {
    return this->file_transfer_;
}

std::string file::LocalFileProvider::file_base_path() const {
    return this->file_system_.root_path();
}

std::shared_ptr<file::VirtualFileServer> LocalFileServer::register_server(ServerId server_id) {
    auto server = this->find_virtual_server(server_id);
    if(server) return server;

    server = std::make_shared<file::LocalVirtualFileServer>(server_id, std::to_string(server_id));
    {
        std::lock_guard slock{this->servers_mutex};
        this->servers_.push_back(server);
    }

    return server;
}

void LocalFileServer::unregister_server(ServerId server_id) {
    auto server_unique_id = std::to_string(server_id);

    std::lock_guard slock{this->servers_mutex};
    auto it = std::find_if(this->servers_.begin(), this->servers_.end(), [&](const std::shared_ptr<VirtualFileServer>& server) {
        return server->unique_id() == server_unique_id;
    });

    if(it == this->servers_.end()) return;
    this->servers_.erase(it);
}

void LocalVirtualFileServer::max_networking_upload_bandwidth(int64_t value) {
    VirtualFileServer::max_networking_upload_bandwidth(value);
    this->upload_throttle.set_max_bandwidth(value);
}

void LocalVirtualFileServer::max_networking_download_bandwidth(int64_t value) {
    VirtualFileServer::max_networking_download_bandwidth(value);
    this->download_throttle.set_max_bandwidth(value);
}