import functools
import pathlib
import typing

from pillarsdk.resource import List, Find, Create


class Manager(List, Find):
    """Manager class wrapping the REST nodes endpoint"""

    path = "flamenco/managers"
    PurePlatformPath = pathlib.PurePath

    @functools.lru_cache(maxsize=1)
    def _path_replacements(self) -> list:
        """Defer to _path_replacements_vN() to get path replacement vars.

        Returns a list of tuples (variable name, variable value).
        """
        settings_version = self.settings_version or 1
        try:
            settings_func = getattr(self, "_path_replacements_v%d" % settings_version)
        except AttributeError:
            raise RuntimeError(
                "This manager has unsupported settings version %d; "
                "upgrade Blender Cloud add-on"
            )

        def longest_value_first(item):
            var_name, var_value = item
            return -len(var_value), var_value, var_name

        replacements = settings_func()
        replacements.sort(key=longest_value_first)
        return replacements

    def _path_replacements_v1(self) -> typing.List[typing.Tuple[str, str]]:
        import platform

        if self.path_replacement is None:
            return []

        items = self.path_replacement.to_dict().items()

        this_platform = platform.system().lower()
        return [
            (varname, platform_replacements[this_platform])
            for varname, platform_replacements in items
            if this_platform in platform_replacements
        ]

    def _path_replacements_v2(self) -> typing.List[typing.Tuple[str, str]]:
        import platform

        if not self.variables:
            return []

        this_platform = platform.system().lower()
        audiences = {"users", "all"}

        replacements = []
        for var_name, variable in self.variables.to_dict().items():
            # Path replacement requires bidirectional variables.
            if variable.get("direction") != "twoway":
                continue

            for var_value in variable.get("values", []):
                if var_value.get("audience") not in audiences:
                    continue
                if var_value.get("platform", "").lower() != this_platform:
                    continue

                replacements.append((var_name, var_value.get("value")))
        return replacements

    def replace_path(self, some_path: pathlib.PurePath) -> str:
        """Performs path variable replacement.

        Tries to find platform-specific path prefixes, and replaces them with
        variables.
        """
        assert isinstance(some_path, pathlib.PurePath), (
            "some_path should be a PurePath, not %r" % some_path
        )

        for varname, path in self._path_replacements():
            replacement = self.PurePlatformPath(path)
            try:
                relpath = some_path.relative_to(replacement)
            except ValueError:
                # Not relative to each other, so no replacement possible
                continue

            replacement_root = self.PurePlatformPath("{%s}" % varname)
            return (replacement_root / relpath).as_posix()

        return some_path.as_posix()


class Job(List, Find, Create):
    """Job class wrapping the REST nodes endpoint"""

    path = "flamenco/jobs"
    ensure_query_projections = {"project": 1}

    def patch(self, payload: dict, api=None):
        import pillarsdk.utils

        api = api or self.api

        url = pillarsdk.utils.join_url(self.path, str(self["_id"]))
        headers = pillarsdk.utils.merge_dict(
            self.http_headers(), {"Content-Type": "application/json"}
        )
        response = api.patch(url, payload, headers=headers)
        return response