data_structures

@dataclass
class AddonInfo:
    """Object matching json payload from Server"""
    name: str
    title: str
    versions: dict[str, AddonVersionInfo]
    description: Union[str, None] = None
    license: Union[str, None] = None
    authors: Union[str, None] = None

    @classmethod
    def from_dict(cls, data: dict[str, Any]) -> "AddonInfo":
        """Addon info by available versions.

        Args:
            data (dict[str, Any]): Addon information from server. Should
                contain information about every version under 'versions'.

        Returns:
            AddonInfo: Addon info with available versions.

        """
        # server payload contains info about all versions
        addon_name = data["name"]
        title = data.get("title") or addon_name

        src_versions = data.get("versions") or {}
        dst_versions = {
            addon_version: AddonVersionInfo.from_dict(
                addon_name, title, addon_version, version_data
            )
            for addon_version, version_data in src_versions.items()
        }
        return cls(
            name=addon_name,
            title=title,
            versions=dst_versions,
            description=data.get("description"),
            license=data.get("license"),
            authors=data.get("authors")
        )

@dataclass
class AddonVersionInfo:
    version: str
    full_name: str
    title: str = None
    require_distribution: bool = False
    sources: list[SourceInfo] = field(default_factory=list)
    unknown_sources: list[dict[str, Any]] = field(default_factory=list)
    checksum: Union[str, None] = None
    checksum_algorithm: Union[str, None] = None

    @classmethod
    def from_dict(
        cls,
        addon_name: str,
        addon_title: str,
        addon_version: str,
        version_data: dict[str, Any],
    ) -> "AddonVersionInfo":
        """Addon version info.

        Args:
            addon_name (str): Name of addon.
            addon_title (str): Title of addon.
            addon_version (str): Version of addon.
            version_data (dict[str, Any]): Addon version information from
                server.

        Returns:
            AddonVersionInfo: Addon version info.

        """
        full_name = f"{addon_name}_{addon_version}"
        title = f"{addon_title} {addon_version}"

        source_info = version_data.get("clientSourceInfo")
        require_distribution = source_info is not None
        sources, unknown_sources = prepare_sources(
            source_info, f"Addon: '{title}'")
        checksum = version_data.get("checksum")
        if checksum is None:
            checksum = version_data.get("hash")

        return cls(
            version=addon_version,
            full_name=full_name,
            require_distribution=require_distribution,
            sources=sources,
            unknown_sources=unknown_sources,
            checksum=checksum,
            checksum_algorithm=version_data.get("checksumAlgorithm", "sha256"),
            title=title,
        )

@dataclass
class Bundle:
    """Class representing bundle information."""

    name: str
    installer_version: Union[str, None]
    addon_versions: dict[str, str]
    dependency_packages: dict[PlatformName, Union[str, None]]
    is_production: bool
    is_staging: bool
    is_dev: bool
    active_dev_user: Union[str, None]
    addons_dev_info: dict[str, AddonDevInfo]
    is_project_bundle: Union[bool, None] = None

    @classmethod
    def from_dict(cls, data):
        addons_dev_info = {
            addon_name: AddonDevInfo(info["enabled"], info["path"])
            for addon_name, info in data.get("addonDevelopment", {}).items()
        }
        return cls(
            name=data["name"],
            installer_version=data.get("installerVersion"),
            addon_versions=data.get("addons", {}),
            dependency_packages=data.get("dependencyPackages", {}),
            is_production=data["isProduction"],
            is_staging=data["isStaging"],
            is_dev=data.get("isDev", False),
            is_project_bundle=data.get("isProject"),
            active_dev_user=data.get("activeUser"),
            addons_dev_info=addons_dev_info,
        )

@dataclass
class DependencyItem:
    """Object matching payload from Server about single dependency package"""
    filename: str
    platform_name: str
    checksum: str
    checksum_algorithm: str
    sources: list[SourceInfo]
    unknown_sources: list[dict[str, Any]]
    source_addons: dict[str, str]
    python_modules: dict[str, str]

    @classmethod
    def from_dict(cls, package: dict[str, Any]) -> "DependencyItem":
        filename = package["filename"]
        src_sources = package.get("sources") or []
        for source in src_sources:
            if source.get("type") == "server" and not source.get("filename"):
                source["filename"] = filename

        sources, unknown_sources = prepare_sources(
            src_sources, f"Dependency package '{filename}'")

        return cls(
            filename=filename,
            platform_name=package["platform"],
            sources=sources,
            unknown_sources=unknown_sources,
            checksum=package["checksum"],
            # Backwards compatibility
            checksum_algorithm=package.get("checksumAlgorithm", "sha256"),
            source_addons=package["sourceAddons"],
            python_modules=package["pythonModules"]
        )