package.hpp

#pragma once
 
#include <filesystem>
#include <functional>
#include <memory>
#include <optional>
#include <set>
#include <tuple>
#include <vector>
 
#include "descriptor.hpp"
#include "version.hpp"
 
namespace plugify {
    struct PackageVersion final {
        plg::version version; 
        std::string checksum; 
        std::string download; 
        std::optional<std::vector<std::string>> platforms; 
 
        bool operator <(const PackageVersion& rhs) const noexcept { return version > rhs.version || (version == rhs.version && std::tie(checksum, download, platforms) < std::tie(rhs.checksum, rhs.download, rhs.platforms)); }
    };
 
    using PackageOpt = const PackageVersion*;
 
    struct Package {
        std::string name; 
        std::string type; 
 
        bool operator==(const Package& rhs) const noexcept { return name == rhs.name && type == rhs.type; }
    };
 
    struct RemotePackage : public Package {
        std::string author; 
        std::string description; 
        std::set<PackageVersion> versions; 
 
        PackageOpt LatestVersion() const noexcept {
            if (!versions.empty())
                return &(*versions.begin());
            return {};
        }
 
        PackageOpt Version(plg::version version) const {
            auto it = versions.find(PackageVersion{ version, {}, {}, {} }); // dummy key for lookup
            if (it != versions.end())
                return &(*it);
            return {};
        }
    };
 
    struct LocalPackage : public Package {
        std::filesystem::path path; 
        plg::version version; 
        std::shared_ptr<Descriptor> descriptor; 
 
        explicit operator RemotePackage() const {
            return { name, type, descriptor->createdBy.value_or("unknown"), descriptor->description.value_or(""), { PackageVersion{ descriptor->version, {}, descriptor->downloadURL.value_or(""), descriptor->supportedPlatforms } } };
        }
    };
} // namespace plugify