// Copyright (C) 2024 Simon Quigley <tsimonq2@ubuntu.com>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.

#include "archive.h"
#include "utils.h"
#include "launchpad.h"
#include "source_package_publishing_history.h"
#include "archive_permission.h"
#include "binary_package_publishing_history.h"
#include "archive_dependency.h"
#include "build.h"
#include <iostream>
#include <nlohmann/json.hpp>

archive::archive()
    : authorized_size(0),
      build_debug_symbols(false),
      description(""),
      displayname(""),
      distribution_link(""),
      external_dependencies(""),
      metadata_overrides(nlohmann::json::object()),
      name(""),
      owner_link(""),
      permit_obsolete_series_uploads(false),
      is_private(false),
      publish(false),
      publish_debug_symbols(false),
      publishing_method(""),
      relative_build_score(0),
      repository_format(""),
      require_virtualized(false),
      signing_key_fingerprint(""),
      suppress_subscription_notifications(false),
      owner_name(""),
      ppa_name(""),
      lp(nullptr) {}

archive::~archive() {}

std::optional<archive> archive::parse(const std::string& json_data) {
    archive a;
    a.parse_json(json_data);
    return a;
}

void archive::parse_json(const std::string& json_data) {
    if (json_data.empty()) {
        std::cerr << "Error: Empty JSON data for archive::parse_json." << std::endl;
        return;
    }
    try {
        auto data = nlohmann::json::parse(json_data);
        std::map<std::string, std::function<void(const nlohmann::json&)>> json_map = {
            {"authorized_size", [this](const nlohmann::json& val) { authorized_size = val.get<int>(); }},
            {"build_debug_symbols", [this](const nlohmann::json& val) { build_debug_symbols = val.get<bool>(); }},
            {"description", [this](const nlohmann::json& val) { description = val.get<std::string>(); }},
            {"displayname", [this](const nlohmann::json& val) { displayname = val.get<std::string>(); }},
            {"distribution_link", [this](const nlohmann::json& val) { distribution_link = val.get<std::string>(); }},
            {"external_dependencies", [this](const nlohmann::json& val) { external_dependencies = val.get<std::string>(); }},
            {"metadata_overrides", [this](const nlohmann::json& val) { metadata_overrides = val; }},
            {"name", [this](const nlohmann::json& val) { name = val.get<std::string>(); }},
            {"owner_link", [this](const nlohmann::json& val) { owner_link = val.get<std::string>(); }},
            {"permit_obsolete_series_uploads", [this](const nlohmann::json& val) { permit_obsolete_series_uploads = val.get<bool>(); }},
            {"private", [this](const nlohmann::json& val) { is_private = val.get<bool>(); }},
            {"publish", [this](const nlohmann::json& val) { publish = val.get<bool>(); }},
            {"publish_debug_symbols", [this](const nlohmann::json& val) { publish_debug_symbols = val.get<bool>(); }},
            {"publishing_method", [this](const nlohmann::json& val) { publishing_method = val.get<std::string>(); }},
            {"relative_build_score", [this](const nlohmann::json& val) { relative_build_score = val.get<int>(); }},
            {"repository_format", [this](const nlohmann::json& val) { repository_format = val.get<std::string>(); }},
            {"require_virtualized", [this](const nlohmann::json& val) { require_virtualized = val.get<bool>(); }},
            {"signing_key_fingerprint", [this](const nlohmann::json& val) { signing_key_fingerprint = val.get<std::string>(); }},
            {"suppress_subscription_notifications", [this](const nlohmann::json& val) { suppress_subscription_notifications = val.get<bool>(); }}
        };
        std::map<std::string, std::function<void(const nlohmann::json&)>> readonly_map = {
            {"dependencies_collection_link", [this](const nlohmann::json& val) { dependencies_collection_link = val.get<std::string>(); }},
            {"enabled_restricted_processors_collection_link", [this](const nlohmann::json& val) { enabled_restricted_processors_collection_link = val.get<std::string>(); }},
            {"http_etag", [this](const nlohmann::json& val) { http_etag = val.get<std::string>(); }},
            {"processors_collection_link", [this](const nlohmann::json& val) { processors_collection_link = val.get<std::string>(); }},
            {"reference", [this](const nlohmann::json& val) { reference = val.get<std::string>(); }},
            {"resource_type_link", [this](const nlohmann::json& val) { resource_type_link = val.get<std::string>(); }},
            {"self_link", [this](const nlohmann::json& val) { self_link = val.get<std::string>(); }},
            {"status", [this](const nlohmann::json& val) { status = val.get<std::string>(); }},
            {"web_link", [this](const nlohmann::json& val) { web_link = val.get<std::string>(); }}
        };

        for (auto& [key, value] : data.items()) {
            try {
                if (json_map.find(key) != json_map.end()) {
                    json_map[key](value);
                    json_map.erase(key);
                } else if (readonly_map.find(key) != readonly_map.end()) {
                    readonly_map[key](value);
                    readonly_map.erase(key);
                }
            } catch (...) {
                continue;
            }
        }

        std::cout << "!!!!!! " << self_link << std::endl;

        std::string link = owner_link;
        size_t pos = link.find("~");
        if (pos != std::string::npos) {
            owner_name = link.substr(pos + 1);
            if (!owner_name.empty() && owner_name.back() == '/') {
                owner_name.pop_back();
            }
        }
        ppa_name = name;

    } catch (...) {
        // ignore parse errors
    }
}

std::string archive::build_archive_endpoint() const {
    return "~" + url_encode(owner_name) + "/" + url_encode(ppa_name);
}

void archive::set_lp(launchpad* lp_ptr) {
    lp = lp_ptr;
}

std::generator<archive_permission> archive::getAllPermissions() const {
    std::map<std::string, std::string> params = {{"ws.op", "getAllPermissions"}};
    auto response = lp->api_get(self_link, params);
    if(!response) co_return;
    auto data = nlohmann::json::parse(response.value());
    while (true) {
        if (data.contains("entries") && data["entries"].is_array()) {
            for (auto& entry : data["entries"]) {
                auto s_opt = archive_permission::parse(entry.dump());
                if (!s_opt) continue;
                s_opt->set_lp(lp);
                co_yield s_opt.value();
            }
        }
        if (!data.contains("next_collection_link") || data["next_collection_link"].is_null() || data["next_collection_link"] == "") break;
        response = lp->api_get(data["next_collection_link"].get<std::string>());
        if(!response) break;
        data = nlohmann::json::parse(response.value());
    }
}

std::generator<source_package_publishing_history> archive::getPublishedSources(
    const std::string component_name,
    const std::string created_since_date,
    std::optional<distro_series> ds,
    const bool exact_match,
    const bool order_by_date,
    const std::string pocket,
    const std::string source_name,
    const std::string status,
    const std::string version
) const {
    std::map<std::string, std::string> params = {
        {"exact_match", exact_match ? "true" : ""},
        {"order_by_date", order_by_date ? "true" : ""},
        {"distro_series", ds ? ds.value().self_link : ""},
        {"component_name", !component_name.empty() ? component_name : ""},
        {"created_since_date", !created_since_date.empty() ? created_since_date : ""},
        {"pocket", !pocket.empty() ? pocket : ""},
        {"source_name", !source_name.empty() ? source_name : ""},
        {"status", !status.empty() ? status : ""},
        {"version", !version.empty() ? version : ""}
    };
    params["ws.op"] = "getPublishedSources";

    // Remove empty entries
    for (auto it = params.begin(); it != params.end(); ) {
        if (it->second.empty()) {
            it = params.erase(it);
        } else {
            ++it;
        }
    }

    std::cout << "Running a getPublishedSources() operation with " << self_link << "..." << std::endl;
    auto response = lp->api_get(self_link, params);
    if(!response) co_return;
    auto data = nlohmann::json::parse(response.value());
    while (true) {
        if (data.contains("entries") && data["entries"].is_array()) {
            for (auto& entry : data["entries"]) {
                auto s_opt = source_package_publishing_history::parse(entry.dump());
                if (!s_opt) continue;
                s_opt->set_lp(lp);
                co_yield s_opt.value();
            }
        }
        if (!data.contains("next_collection_link") || data["next_collection_link"].is_null() || data["next_collection_link"] == "") break;
        response = lp->api_get(data["next_collection_link"].get<std::string>());
        if(!response) break;
        data = nlohmann::json::parse(response.value());
    }
}

std::optional<nlohmann::json> archive::checkUpload(const std::string& component,
                                                   const std::string& distroseries,
                                                   const std::string& person,
                                                   const std::string& pocket,
                                                   const std::string& sourcepackagename,
                                                   bool strict_component) const {
    std::map<std::string,std::string> params;
    params["ws.op"] = "checkUpload";
    params["component"] = component;
    params["distroseries"] = distroseries;
    params["person"] = person;
    params["pocket"] = pocket;
    params["sourcepackagename"] = sourcepackagename;
    if(strict_component) params["strict_component"] = "true";

    auto response = lp->api_get(self_link, params);
    if(!response) return std::nullopt;
    return nlohmann::json::parse(response.value());
}

std::optional<archive_dependency> archive::getArchiveDependency(const std::string& dependency_link) const {
    std::map<std::string,std::string> params;
    params["ws.op"] = "getArchiveDependency";
    params["dependency"] = dependency_link;
    auto response = lp->api_get(self_link, params);
    if(!response) return std::nullopt;
    auto ad_opt = archive_dependency::parse(response.value());
    if(ad_opt) ad_opt->set_lp(lp);
    return ad_opt;
}

std::optional<nlohmann::json> archive::getBuildCounters(bool include_needsbuild) const {
    std::map<std::string,std::string> params;
    params["ws.op"] = "getBuildCounters";
    if(include_needsbuild) params["include_needsbuild"]="true";
    auto response = lp->api_get(self_link, params);
    if(!response) return std::nullopt;
    return nlohmann::json::parse(response.value());
}

std::generator<build> archive::getBuildRecords(const std::string build_state,
                                               const std::string pocket,
                                               const std::string source_name) const {
    std::map<std::string,std::string> params;
    params["ws.op"] = "getBuildRecords";
    if(!build_state.empty()) params["build_state"] = build_state;
    if(!pocket.empty()) params["pocket"] = pocket;
    if(!source_name.empty()) params["source_name"] = source_name;
    auto response = lp->api_get(self_link, params);
    if(!response) co_return;
    auto data = nlohmann::json::parse(response.value());
    while (true) {
        if (data.contains("entries") && data["entries"].is_array()) {
            for (auto& e : data["entries"]) {
                auto b_opt = build::parse(e.dump());
                if(!b_opt) continue;
                b_opt->set_lp(lp);
                co_yield b_opt.value();
            }
        }
        if(!data.contains("next_collection_link") || data["next_collection_link"].is_null() || data["next_collection_link"]=="") break;
        response = lp->api_get(data["next_collection_link"].get<std::string>());
        if(!response) break;
        data = nlohmann::json::parse(response.value());
    }
}

std::optional<nlohmann::json> archive::getBuildSummariesForSourceIds(const std::vector<std::string>& source_ids) const {
    std::map<std::string,std::string> params;
    params["ws.op"] = "getBuildSummariesForSourceIds";
    std::string joined;
    for (auto &sid : source_ids) {
        joined += sid + ",";
    }
    if(!joined.empty()) joined.pop_back();
    if(!joined.empty()) params["source_ids"] = joined;
    auto response = lp->api_get(self_link, params);
    if(!response) return std::nullopt;
    return nlohmann::json::parse(response.value());
}

std::generator<archive_permission> archive::getComponentsForQueueAdmin(const std::string& person_link) const {
    std::map<std::string,std::string> params;
    params["ws.op"] = "getComponentsForQueueAdmin";
    params["person"] = person_link;
    auto response = lp->api_get(self_link, params);
    if(!response) co_return;
    auto data = nlohmann::json::parse(response.value());
    if(data.contains("entries") && data["entries"].is_array()){
        for(auto& e : data["entries"]){
            auto ap = archive_permission::parse(e.dump());
            if(ap) {
                ap->set_lp(lp);
                co_yield ap.value();
            }
        }
    }
}

std::optional<nlohmann::json> archive::getNamedAuthToken(const std::string& name) const {
    std::map<std::string,std::string> params;
    params["ws.op"]="getNamedAuthToken";
    params["name"]=name;
    auto response = lp->api_get(self_link, params);
    if(!response) return std::nullopt;
    return nlohmann::json::parse(response.value());
}

std::optional<nlohmann::json> archive::getNamedAuthTokens(const std::vector<std::string>& names) const {
    std::map<std::string,std::string> params;
    params["ws.op"]="getNamedAuthTokens";
    if(!names.empty()){
        std::string joined;
        for(auto& n:names) joined+=n+",";
        if(!joined.empty()) joined.pop_back();
        params["names"]=joined;
    }
    auto response = lp->api_get(self_link, params);
    if(!response) return std::nullopt;
    return nlohmann::json::parse(response.value());
}

std::generator<archive_permission> archive::getPackagesetsForSource(const std::string& sourcepackagename,
                                                                   bool direct_permissions) const {
    std::map<std::string,std::string> params;
    params["ws.op"]="getPackagesetsForSource";
    params["sourcepackagename"]=sourcepackagename;
    if(direct_permissions) params["direct_permissions"]="true";
    auto response=lp->api_get(self_link, params);
    if(!response) co_return;
    auto data=nlohmann::json::parse(response.value());
    if(data.contains("entries") && data["entries"].is_array()){
        for(auto&e: data["entries"]){
            auto ap=archive_permission::parse(e.dump());
            if(ap) {ap->set_lp(lp); co_yield ap.value();}
        }
    }
}

std::generator<archive_permission> archive::getPackagesetsForSourceUploader(const std::string& person_link,
                                                                           const std::string& sourcepackagename) const {
    std::map<std::string,std::string> params;
    params["ws.op"]="getPackagesetsForSourceUploader";
    params["person"]=person_link;
    params["sourcepackagename"]=sourcepackagename;
    auto response=lp->api_get(self_link, params);
    if(!response) co_return;
    auto data=nlohmann::json::parse(response.value());
    if(data.contains("entries")&&data["entries"].is_array()){
        for(auto&e:data["entries"]){
            auto ap=archive_permission::parse(e.dump());
            if(ap){ap->set_lp(lp);co_yield ap.value();}
        }
    }
}

std::generator<archive_permission> archive::getPackagesetsForUploader(const std::string& person_link) const {
    std::map<std::string,std::string> params;
    params["ws.op"]="getPackagesetsForUploader";
    params["person"]=person_link;
    auto response=lp->api_get(self_link,params);
    if(!response) co_return;
    auto data=nlohmann::json::parse(response.value());
    if(data.contains("entries") && data["entries"].is_array()){
        for(auto&e:data["entries"]){
            auto ap=archive_permission::parse(e.dump());
            if(ap){ap->set_lp(lp);co_yield ap.value();}
        }
    }
}

std::generator<archive_permission> archive::getPermissionsForPerson(const std::string& person_link) const {
    std::map<std::string,std::string> params;
    params["ws.op"]="getPermissionsForPerson";
    params["person"]=person_link;
    auto response=lp->api_get(self_link,params);
    if(!response) co_return;
    auto data=nlohmann::json::parse(response.value());
    if(data.contains("entries")){
        for(auto&e:data["entries"]){
            auto ap=archive_permission::parse(e.dump());
            if(ap){ap->set_lp(lp);co_yield ap.value();}
        }
    }
}

std::generator<archive_permission> archive::getPocketsForQueueAdmin(const std::string& person_link) const {
    std::map<std::string,std::string>params;
    params["ws.op"]="getPocketsForQueueAdmin";
    params["person"]=person_link;
    auto response=lp->api_get(self_link,params);
    if(!response) co_return;
    auto data=nlohmann::json::parse(response.value());
    if(data.contains("entries")){
        for(auto&e:data["entries"]){
            auto ap=archive_permission::parse(e.dump());
            if(ap){ap->set_lp(lp);co_yield ap.value();}
        }
    }
}

std::generator<archive_permission> archive::getPocketsForUploader(const std::string& person_link) const {
    std::map<std::string,std::string>params;
    params["ws.op"]="getPocketsForUploader";
    params["person"]=person_link;
    auto response=lp->api_get(self_link,params);
    if(!response) co_return;
    auto data=nlohmann::json::parse(response.value());
    if(data.contains("entries")){
        for(auto&e:data["entries"]){
            auto ap=archive_permission::parse(e.dump());
            if(ap){ap->set_lp(lp);co_yield ap.value();}
        }
    }
}

std::generator<binary_package_publishing_history> archive::getPublishedBinaries(const std::string& binary_name,
                                                                               const std::string& component_name,
                                                                               const std::string& created_since_date,
                                                                               const std::string& distro_arch_series,
                                                                               bool exact_match,
                                                                               bool order_by_date,
                                                                               bool ordered,
                                                                               const std::string& pocket,
                                                                               const std::string& status,
                                                                               const std::string& version) const {
    std::map<std::string,std::string> params;
    params["ws.op"]="getPublishedBinaries";
    if(!binary_name.empty()) params["binary_name"]=binary_name;
    if(!component_name.empty()) params["component_name"]=component_name;
    if(!created_since_date.empty()) params["created_since_date"]=created_since_date;
    if(!distro_arch_series.empty()) params["distro_arch_series"]=distro_arch_series;
    if(exact_match) params["exact_match"]="true";
    if(order_by_date) params["order_by_date"]="true";
    if(!ordered) params["ordered"]="false";
    if(!pocket.empty()) params["pocket"]=pocket;
    if(!status.empty()) params["status"]=status;
    if(!version.empty()) params["version"]=version;

    auto response=lp->api_get(self_link,params);
    if(!response) co_return;
    auto data=nlohmann::json::parse(response.value());
    while(true){
        if(data.contains("entries") && data["entries"].is_array()){
            for(auto&e:data["entries"]){
                auto bpph = binary_package_publishing_history::parse(e.dump());
                if(bpph){bpph->set_lp(lp);co_yield bpph.value();}
            }
        }
        if(!data.contains("next_collection_link")||data["next_collection_link"].is_null()||data["next_collection_link"]=="")break;
        response=lp->api_get(data["next_collection_link"].get<std::string>());
        if(!response)break;
        data=nlohmann::json::parse(response.value());
    }
}

std::generator<archive_permission> archive::getQueueAdminsForComponent(const std::string& component_name) const {
    std::map<std::string,std::string>params;
    params["ws.op"]="getQueueAdminsForComponent";
    params["component_name"]=component_name;
    auto response=lp->api_get(self_link,params);
    if(!response)co_return;
    auto data=nlohmann::json::parse(response.value());
    if(data.contains("entries")){
        for(auto&e:data["entries"]){
            auto ap=archive_permission::parse(e.dump());
            if(ap){ap->set_lp(lp); co_yield ap.value();}
        }
    }
}

std::generator<archive_permission> archive::getQueueAdminsForPocket(const std::string& distroseries,
                                                                    const std::string& pocket) const {
    std::map<std::string,std::string>params;
    params["ws.op"]="getQueueAdminsForPocket";
    params["distroseries"]=distroseries;
    params["pocket"]=pocket;
    auto response=lp->api_get(self_link,params);
    if(!response)co_return;
    auto data=nlohmann::json::parse(response.value());
    if(data.contains("entries")){
        for(auto&e:data["entries"]){
            auto ap=archive_permission::parse(e.dump());
            if(ap){ap->set_lp(lp);co_yield ap.value();}
        }
    }
}

std::optional<std::string> archive::getSigningKeyData() const {
    std::map<std::string,std::string>params;
    params["ws.op"]="getSigningKeyData";
    auto response=lp->api_get(self_link,params);
    if(!response) return std::nullopt;
    auto j=nlohmann::json::parse(response.value());
    if(j.is_string()) return j.get<std::string>();
    return std::nullopt;
}

std::generator<archive_permission> archive::getUploadersForComponent(const std::string& component_name) const {
    std::map<std::string,std::string>params;
    params["ws.op"]="getUploadersForComponent";
    if(!component_name.empty()) params["component_name"]=component_name;
    auto response=lp->api_get(self_link,params);
    if(!response) co_return;
    auto data=nlohmann::json::parse(response.value());
    if(data.contains("entries")){
        for(auto&e:data["entries"]){
            auto ap=archive_permission::parse(e.dump());
            if(ap){ap->set_lp(lp);co_yield ap.value();}
        }
    }
}

std::generator<archive_permission> archive::getUploadersForPackage(const std::string& source_package_name) const {
    std::map<std::string,std::string>params;
    params["ws.op"]="getUploadersForPackage";
    params["source_package_name"]=source_package_name;
    auto response=lp->api_get(self_link,params);
    if(!response)co_return;
    auto data=nlohmann::json::parse(response.value());
    if(data.contains("entries")){
        for(auto&e:data["entries"]){
            auto ap=archive_permission::parse(e.dump());
            if(ap){ap->set_lp(lp);co_yield ap.value();}
        }
    }
}

std::generator<archive_permission> archive::getUploadersForPackageset(const std::string& packageset,
                                                                     bool direct_permissions) const {
    std::map<std::string,std::string>params;
    params["ws.op"]="getUploadersForPackageset";
    params["packageset"]=packageset;
    if(direct_permissions) params["direct_permissions"]="true";
    auto response=lp->api_get(self_link,params);
    if(!response) co_return;
    auto data=nlohmann::json::parse(response.value());
    if(data.contains("entries")){
        for(auto&e:data["entries"]){
            auto ap=archive_permission::parse(e.dump());
            if(ap){ap->set_lp(lp);co_yield ap.value();}
        }
    }
}

std::generator<archive_permission> archive::getUploadersForPocket(const std::string& pocket) const {
    std::map<std::string,std::string>params;
    params["ws.op"]="getUploadersForPocket";
    params["pocket"]=pocket;
    auto response=lp->api_get(self_link,params);
    if(!response)co_return;
    auto data=nlohmann::json::parse(response.value());
    if(data.contains("entries")){
        for(auto&e:data["entries"]){
            auto ap=archive_permission::parse(e.dump());
            if(ap){ap->set_lp(lp);co_yield ap.value();}
        }
    }
}

std::optional<bool> archive::isSourceUploadAllowed(const std::string& distroseries,
                                                   const std::string& person,
                                                   const std::string& sourcepackagename) const {
    std::map<std::string,std::string> params;
    params["ws.op"]="isSourceUploadAllowed";
    params["distroseries"]=distroseries;
    params["person"]=person;
    params["sourcepackagename"]=sourcepackagename;
    auto response=lp->api_get(self_link,params);
    if(!response)return std::nullopt;
    auto j=nlohmann::json::parse(response.value());
    if(j.is_boolean()) return j.get<bool>();
    return std::nullopt;
}

std::optional<archive_dependency> archive::addArchiveDependency(const std::string& dependency_link,
                                                                const std::string& component,
                                                                const std::string& pocket) const {
    std::map<std::string,std::string>params;
    params["ws.op"]="addArchiveDependency";
    params["dependency"]=dependency_link;
    if(!component.empty()) params["component"]=component;
    params["pocket"]=pocket;
    auto response=lp->api_post(self_link,params);
    if(!response) return std::nullopt;
    auto ad=archive_dependency::parse(response.value());
    if(ad) ad->set_lp(lp);
    return ad;
}

bool archive::copyPackage(const std::string& from_archive,
                          const std::string& from_pocket,
                          const std::string& from_series,
                          bool include_binaries,
                          bool move,
                          std::optional<int> phased_update_percentage,
                          bool silent,
                          const std::string& source_name,
                          const std::string& sponsored,
                          const std::string& to_pocket,
                          const std::string& to_series,
                          bool unembargo,
                          const std::string& version,
                          bool auto_approve) const {
    std::map<std::string,std::string>params;
    params["ws.op"]="copyPackage";
    params["from_archive"]=from_archive;
    if(!from_pocket.empty())params["from_pocket"]=from_pocket;
    if(!from_series.empty())params["from_series"]=from_series;
    if(include_binaries)params["include_binaries"]="true";
    if(move)params["move"]="true";
    if(phased_update_percentage.has_value())params["phased_update_percentage"]=std::to_string(phased_update_percentage.value());
    if(silent)params["silent"]="true";
    params["source_name"]=source_name;
    if(!sponsored.empty()) params["sponsored"]=sponsored;
    params["to_pocket"]=to_pocket;
    if(!to_series.empty())params["to_series"]=to_series;
    if(unembargo)params["unembargo"]="true";
    params["version"]=version;
    if(auto_approve)params["auto_approve"]="true";
    auto resp=lp->api_post(self_link,params);
    return resp.has_value();
}

bool archive::copyPackages(const std::string& from_archive,
                           const std::string& from_series,
                           bool include_binaries,
                           bool silent,
                           const std::vector<std::string>& source_names,
                           const std::string& sponsored,
                           const std::string& to_pocket,
                           const std::string& to_series,
                           bool unembargo,
                           bool auto_approve) const {
    std::map<std::string,std::string> params;
    params["ws.op"]="copyPackages";
    params["from_archive"]=from_archive;
    if(!from_series.empty()) params["from_series"]=from_series;
    if(include_binaries) params["include_binaries"]="true";
    if(silent) params["silent"]="true";
    {
        std::string joined;
        for(auto&s:source_names)joined+=s+",";
        if(!joined.empty())joined.pop_back();
        if(!joined.empty()) params["source_names"]=joined;
    }
    if(!sponsored.empty()) params["sponsored"]=sponsored;
    params["to_pocket"]=to_pocket;
    if(!to_series.empty()) params["to_series"]=to_series;
    if(unembargo)params["unembargo"]="true";
    if(auto_approve)params["auto_approve"]="true";
    auto resp=lp->api_post(self_link,params);
    return resp.has_value();
}

bool archive::deleteComponentUploader(const std::string& component_name,
                                      const std::string& person) const {
    std::map<std::string,std::string>params;
    params["ws.op"]="deleteComponentUploader";
    params["component_name"]=component_name;
    params["person"]=person;
    auto resp=lp->api_post(self_link,params);
    return resp.has_value();
}

bool archive::deletePackageUploader(const std::string& person,
                                    const std::string& source_package_name) const {
    std::map<std::string,std::string>params;
    params["ws.op"]="deletePackageUploader";
    params["person"]=person;
    params["source_package_name"]=source_package_name;
    auto resp=lp->api_post(self_link,params);
    return resp.has_value();
}

bool archive::deletePackagesetUploader(const std::string& packageset,
                                       const std::string& person,
                                       bool explicit_) const {
    std::map<std::string,std::string> params;
    params["ws.op"]="deletePackagesetUploader";
    params["packageset"]=packageset;
    if(explicit_)params["explicit"]="true";
    params["person"]=person;
    auto resp=lp->api_post(self_link,params);
    return resp.has_value();
}

bool archive::deletePocketQueueAdmin(const std::string& distroseries,
                                     const std::string& person,
                                     const std::string& pocket) const {
    std::map<std::string,std::string>params;
    params["ws.op"]="deletePocketQueueAdmin";
    if(!distroseries.empty())params["distroseries"]=distroseries;
    params["person"]=person;
    params["pocket"]=pocket;
    auto resp=lp->api_post(self_link,params);
    return resp.has_value();
}

bool archive::deletePocketUploader(const std::string& person,
                                   const std::string& pocket) const {
    std::map<std::string,std::string>params;
    params["ws.op"]="deletePocketUploader";
    params["person"]=person;
    params["pocket"]=pocket;
    auto resp=lp->api_post(self_link,params);
    return resp.has_value();
}

bool archive::deleteQueueAdmin(const std::string& component_name,
                               const std::string& person) const {
    std::map<std::string,std::string>params;
    params["ws.op"]="deleteQueueAdmin";
    params["component_name"]=component_name;
    params["person"]=person;
    auto resp=lp->api_post(self_link,params);
    return resp.has_value();
}

bool archive::enableRestrictedProcessor(const std::string& processor) const {
    std::map<std::string,std::string>params;
    params["ws.op"]="enableRestrictedProcessor";
    params["processor"]=processor;
    auto resp=lp->api_post(self_link,params);
    return resp.has_value();
}

bool archive::markSuiteDirty(const std::string& distroseries,
                             const std::string& pocket) const {
    std::map<std::string,std::string>params;
    params["ws.op"]="markSuiteDirty";
    params["distroseries"]=distroseries;
    params["pocket"]=pocket;
    auto resp=lp->api_post(self_link,params);
    return resp.has_value();
}

std::optional<archive_permission> archive::newComponentUploader(const std::string& component_name,
                                                               const std::string& person) const {
    std::map<std::string,std::string>params;
    params["ws.op"]="newComponentUploader";
    params["component_name"]=component_name;
    params["person"]=person;
    auto resp=lp->api_post(self_link,params);
    if(!resp)return std::nullopt;
    auto ap=archive_permission::parse(resp.value());
    if(ap)ap->set_lp(lp);
    return ap;
}

std::optional<nlohmann::json> archive::newNamedAuthToken(const std::string& name,
                                                         const std::optional<std::string>& token) const {
    std::map<std::string,std::string>params;
    params["ws.op"]="newNamedAuthToken";
    params["name"]=name;
    if(token.has_value())params["token"]=token.value();
    auto resp=lp->api_post(self_link,params);
    if(!resp)return std::nullopt;
    return nlohmann::json::parse(resp.value());
}

std::optional<nlohmann::json> archive::newNamedAuthTokens(const std::vector<std::string>& names) const {
    std::map<std::string,std::string>params;
    params["ws.op"]="newNamedAuthTokens";
    if(!names.empty()){
        std::string joined;
        for(auto&n:names)joined+=n+",";
        if(!joined.empty())joined.pop_back();
        params["names"]=joined;
    }
    auto resp=lp->api_post(self_link,params);
    if(!resp)return std::nullopt;
    return nlohmann::json::parse(resp.value());
}

std::optional<archive_permission> archive::newPackageUploader(const std::string& person,
                                                             const std::string& source_package_name) const {
    std::map<std::string,std::string>params;
    params["ws.op"]="newPackageUploader";
    params["person"]=person;
    params["source_package_name"]=source_package_name;
    auto resp=lp->api_post(self_link,params);
    if(!resp)return std::nullopt;
    auto ap=archive_permission::parse(resp.value());
    if(ap)ap->set_lp(lp);
    return ap;
}

std::optional<archive_permission> archive::newPackagesetUploader(const std::string& packageset,
                                                                 const std::string& person,
                                                                 bool explicit_) const {
    std::map<std::string,std::string>params;
    params["ws.op"]="newPackagesetUploader";
    params["packageset"]=packageset;
    if(explicit_)params["explicit"]="true";
    params["person"]=person;
    auto resp=lp->api_post(self_link,params);
    if(!resp)return std::nullopt;
    auto ap=archive_permission::parse(resp.value());
    if(ap)ap->set_lp(lp);
    return ap;
}

std::optional<archive_permission> archive::newPocketQueueAdmin(const std::string& distroseries,
                                                              const std::string& person,
                                                              const std::string& pocket) const {
    std::map<std::string,std::string>params;
    params["ws.op"]="newPocketQueueAdmin";
    if(!distroseries.empty())params["distroseries"]=distroseries;
    params["person"]=person;
    params["pocket"]=pocket;
    auto resp=lp->api_post(self_link,params);
    if(!resp)return std::nullopt;
    auto ap=archive_permission::parse(resp.value());
    if(ap)ap->set_lp(lp);
    return ap;
}

std::optional<archive_permission> archive::newPocketUploader(const std::string& person,
                                                            const std::string& pocket) const {
    std::map<std::string,std::string>params;
    params["ws.op"]="newPocketUploader";
    params["person"]=person;
    params["pocket"]=pocket;
    auto resp=lp->api_post(self_link,params);
    if(!resp)return std::nullopt;
    auto ap=archive_permission::parse(resp.value());
    if(ap)ap->set_lp(lp);
    return ap;
}

std::optional<archive_permission> archive::newQueueAdmin(const std::string& component_name,
                                                        const std::string& person) const {
    std::map<std::string,std::string>params;
    params["ws.op"]="newQueueAdmin";
    params["component_name"]=component_name;
    params["person"]=person;
    auto resp=lp->api_post(self_link,params);
    if(!resp)return std::nullopt;
    auto ap=archive_permission::parse(resp.value());
    if(ap)ap->set_lp(lp);
    return ap;
}

std::optional<nlohmann::json> archive::newSubscription(const std::string& subscriber,
                                                       const std::optional<std::string>& date_expires,
                                                       const std::optional<std::string>& description) const {
    std::map<std::string,std::string>params;
    params["ws.op"]="newSubscription";
    params["subscriber"]=subscriber;
    if(date_expires.has_value()) params["date_expires"]=date_expires.value();
    if(description.has_value()) params["description"]=description.value();
    auto resp=lp->api_post(self_link,params);
    if(!resp)return std::nullopt;
    return nlohmann::json::parse(resp.value());
}

bool archive::removeArchiveDependency(const std::string& dependency_link) const {
    std::map<std::string,std::string>params;
    params["ws.op"]="removeArchiveDependency";
    params["dependency"]=dependency_link;
    auto resp=lp->api_post(self_link,params);
    return resp.has_value();
}

bool archive::removeCopyNotification(const std::string& job_id) const {
    std::map<std::string,std::string>params;
    params["ws.op"]="removeCopyNotification";
    params["job_id"]=job_id;
    auto resp=lp->api_post(self_link,params);
    return resp.has_value();
}

bool archive::revokeNamedAuthToken(const std::string& name) const {
    std::map<std::string,std::string>params;
    params["ws.op"]="revokeNamedAuthToken";
    params["name"]=name;
    auto resp=lp->api_post(self_link,params);
    return resp.has_value();
}

bool archive::revokeNamedAuthTokens(const std::vector<std::string>& names) const {
    std::map<std::string,std::string>params;
    params["ws.op"]="revokeNamedAuthTokens";
    if(!names.empty()){
        std::string joined;
        for(auto&n:names)joined+=n+",";
        if(!joined.empty())joined.pop_back();
        params["names"]=joined;
    }
    auto resp=lp->api_post(self_link,params);
    return resp.has_value();
}

bool archive::setProcessors(const std::vector<std::string>& processors) const {
    std::map<std::string,std::string>params;
    params["ws.op"]="setProcessors";
    {
        std::string joined;
        for(auto&p:processors)joined+=p+",";
        if(!joined.empty())joined.pop_back();
        params["processors"]=joined;
    }
    auto resp=lp->api_post(self_link,params);
    return resp.has_value();
}

bool archive::syncSource(const std::string& from_archive,
                         bool include_binaries,
                         const std::string& source_name,
                         const std::string& to_pocket,
                         const std::string& to_series,
                         const std::string& version) const {
    std::map<std::string,std::string>params;
    params["ws.op"]="syncSource";
    params["from_archive"]=from_archive;
    if(include_binaries)params["include_binaries"]="true";
    params["source_name"]=source_name;
    params["to_pocket"]=to_pocket;
    if(!to_series.empty())params["to_series"]=to_series;
    params["version"]=version;
    auto resp=lp->api_post(self_link,params);
    return resp.has_value();
}

bool archive::syncSources(const std::string& from_archive,
                          const std::string& from_series,
                          bool include_binaries,
                          const std::vector<std::string>& source_names,
                          const std::string& to_pocket,
                          const std::string& to_series) const {
    std::map<std::string,std::string>params;
    params["ws.op"]="syncSources";
    params["from_archive"]=from_archive;
    if(!from_series.empty())params["from_series"]=from_series;
    if(include_binaries)params["include_binaries"]="true";
    {
        std::string joined;
        for(auto&s:source_names)joined+=s+",";
        if(!joined.empty())joined.pop_back();
        if(!joined.empty()) params["source_names"]=joined;
    }
    params["to_pocket"]=to_pocket;
    if(!to_series.empty())params["to_series"]=to_series;
    auto resp=lp->api_post(self_link,params);
    return resp.has_value();
}

bool archive::uploadCIBuild(const std::string& ci_build,
                            const std::string& to_channel,
                            const std::string& to_pocket,
                            const std::string& to_series) const {
    std::map<std::string,std::string>params;
    params["ws.op"]="uploadCIBuild";
    params["ci_build"]=ci_build;
    if(!to_channel.empty())params["to_channel"]=to_channel;
    params["to_pocket"]=to_pocket;
    params["to_series"]=to_series;
    auto resp=lp->api_post(self_link,params);
    return resp.has_value();
}