from __future__ import annotations

from typing import TYPE_CHECKING, Any, Generic, Optional, TypeVar, cast

from attr import define

if TYPE_CHECKING:
    from ..enums.ClassIDType import ClassIDType
    from ..files.ObjectReader import ObjectReader
    from ..files.SerializedFile import SerializedFile

T = TypeVar("T")


@define(slots=True, kw_only=True)
class PPtr(Generic[T]):
    m_FileID: int
    m_PathID: int
    assetsfile: Optional[SerializedFile] = None

    @property
    def file_id(self) -> int:
        # backwards compatibility
        return self.m_FileID

    @property
    def path_id(self) -> int:
        # backwards compatibility
        return self.m_PathID

    @property
    def type(self) -> ClassIDType:
        return self.deref().type

    # backwards compatibility - to be removed in UnityPy 2
    def read(self):
        return self.deref_parse_as_object()

    # backwards compatibility - to be removed in UnityPy 2
    def read_typetree(self):
        return self.deref_parse_as_dict()

    def deref(self, assetsfile: Optional[SerializedFile] = None) -> ObjectReader[T]:
        assetsfile = assetsfile or self.assetsfile

        if assetsfile is None:
            raise ValueError("PPtr can't deref without an assetsfile!")

        if self.m_PathID == 0:
            raise ValueError("PPtr can't deref with m_PathID == 0!")

        assetsfile_dst = None
        if self.m_FileID == 0:
            assetsfile_dst = assetsfile or self.assetsfile
        else:
            # resolve file id to external name
            external_id = self.m_FileID - 1
            if external_id >= len(assetsfile.externals):
                raise FileNotFoundError("Failed to resolve pointer - invalid m_FileID!")
            external = assetsfile.externals[external_id]

            # resolve external name to assetsfile
            container = assetsfile.parent
            if container is None:
                # TODO - use default fs
                raise FileNotFoundError(f"PPtr points to {external.path} but no container is set!")

            external_clean_path = external.path
            if external_clean_path.startswith("archive:/"):
                external_clean_path = external_clean_path[9:]
            if external_clean_path.startswith("assets/"):
                external_clean_path = external_clean_path[7:]
            external_clean_path = external_clean_path.rsplit("/")[-1].lower()

            for key, file in container.files.items():
                if key.lower() == external_clean_path:
                    assetsfile_dst = file
                    break
            else:
                env = assetsfile.environment
                cab = env.find_file(external_clean_path)
                if cab:
                    assetsfile_dst = cab
                else:
                    raise FileNotFoundError(f"Failed to resolve pointer - {external.path} not found!")

        if assetsfile_dst is None:
            raise FileNotFoundError(f"Failed to resolve pointer - {self.m_FileID} not found!")

        return cast("ObjectReader[T]", assetsfile_dst.objects[self.m_PathID])

    def deref_parse_as_object(self, assetsfile: Optional[SerializedFile] = None) -> T:
        return self.deref(assetsfile).parse_as_object()

    def deref_parse_as_dict(self, assetsfile: Optional[SerializedFile] = None) -> dict[str, Any]:
        return self.deref(assetsfile).parse_as_dict()

    def __bool__(self):
        return self.m_PathID != 0

    def __hash__(self) -> int:
        return hash((self.m_FileID, self.m_PathID))

    def __eq__(self, other: object) -> bool:
        if not isinstance(other, PPtr):
            return False
        return self.m_FileID == other.m_FileID and self.m_PathID == other.m_PathID


__all__ = [
    "PPtr",
]