# Copyright 2025 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

from typing import Dict, List, Union
import metadata_dictionary
import constants
from license_type import LicenseType


def get_most_restrictive_type(licenses_names: List[str]) -> LicenseType:
    """Returns the most restrictive license according to the values of LicenseType."""
    most_restrictive = LicenseType.UNKNOWN
    for license_name in licenses_names:
        if constants.RAW_LICENSE_TO_FORMATTED_DETAILS[license_name][
                1].value > most_restrictive.value:
            most_restrictive = constants.RAW_LICENSE_TO_FORMATTED_DETAILS[
                license_name][1]
    return most_restrictive


class Metadata:

    def __init__(self, metadata_dict: Dict[str, Union[str, List[str]]]):
        self.metadata = metadata_dict

    def get_name(self) -> str:
        return self.metadata["Name"]

    def get_url(self) -> str:
        return self.metadata["URL"]

    def get_version(self):
        if not self._get_version() or self._get_version() in [
                "0", "unknown", "N/A"
        ]:
            # This is a heuristic try to avoid putting a version when the version
            # in the README.chromium does not make any sense.
            return self._get_revision()
        return self._get_version()

    def _get_version_control(self):
        """Returns the VCS of the URL provided if possible,
    otherwise None is returned."""
        if "git" in self.get_url() or "googlesource" in self.get_url():
            return "Git"
        if "hg" in self.get_url():
            return "Hg"
        return None

    def _create_identifier_block(
            self) -> metadata_dictionary.MetadataDictionary:
        identifier_dictionary = metadata_dictionary.MetadataDictionary(
            "identifier")
        identifier_dictionary["value"] = f"\"{self.get_url()}\""
        identifier_dictionary["type"] = f"\"{self._get_version_control()}\""
        if self.get_version():
            identifier_dictionary["version"] = f"\"{self.get_version()}\""
        return identifier_dictionary

    def _get_version(self) -> str:
        return self.metadata.get("Version", None)

    def _get_revision(self) -> str:
        return self.metadata.get("Revision", None)

    def get_licenses(self) -> List[str]:
        return self.metadata["License"]

    def get_license_file_path(self) -> str:
        return self.metadata.get("License File", [None])[0]

    def get_license_type(self) -> LicenseType:
        return get_most_restrictive_type(self.get_licenses())

    def to_android_metadata(self):
        third_party_dict = metadata_dictionary.MetadataDictionary(
            "third_party")
        third_party_dict["license_type"] = self.get_license_type().name
        if self.get_version():
            third_party_dict["version"] = f"\"{self.get_version()}\""

        if self._get_version_control():
            third_party_dict[
                "identifier_primary"] = self._create_identifier_block()
        else:
            third_party_dict["homepage"] = f"\"{self.get_url()}\""

        return "\n".join(
            [f"name: \"{self.get_name()}\"", f"{third_party_dict}"])