package.hpp

#pragma once
 
#include <filesystem>
#include <functional>
#include <memory>
#include <optional>
#include <plugify/descriptor.hpp>
#include <set>
#include <tuple>
 
namespace plugify {
    struct PackageVersion final {
        int32_t version; 
        std::string checksum; 
        std::string download; 
        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 final : 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(int32_t version) const {
            auto it = versions.find(PackageVersion{ version, {}, {}, {} }); // dummy key for lookup
            if (it != versions.end())
                return &(*it);
            return {};
        }
    };
 
    struct LocalPackage final : public Package {
        std::filesystem::path path; 
        int32_t version; 
        std::shared_ptr<Descriptor> descriptor; 
 
        explicit operator RemotePackage() const {
            return { name, type, descriptor->createdBy, descriptor->description, { PackageVersion{ descriptor->version, {}, descriptor->downloadURL, descriptor->supportedPlatforms} }};
        }
    };
} // namespace plugify