"""已安装物理插件的来源身份合同与存量迁移决策。"""

from __future__ import annotations

import re
from dataclasses import dataclass, replace
from datetime import datetime
from enum import StrEnum
from typing import Protocol

_PLUGIN_ID_PATTERN = re.compile(r"^[A-Za-z][A-Za-z0-9]{0,127}$")
_ONLINE_SOURCE_KEY_PATTERN = re.compile(
    r"^github:[a-z0-9](?:[a-z0-9-]{0,38})/"
    r"[a-z0-9._-]{1,100}$"
)
OFFICIAL_PLUGIN_SOURCE_KEY = "github:jxxghp/moviepilot-plugins"


class TrustedPluginSourceType(StrEnum):
    """可被在线自动更新信任的来源类型。"""

    UNKNOWN = "unknown"
    OFFICIAL = "official"
    THIRD_PARTY = "third_party"


class PluginPayloadSourceType(StrEnum):
    """最近一次已提交插件载荷的来源类型。"""

    UNKNOWN = "unknown"
    OFFICIAL = "official"
    THIRD_PARTY = "third_party"
    LOCAL = "local"


class PluginBindingBasis(StrEnum):
    """物理插件来源身份的建立依据。"""

    LEGACY_UNBOUND = "legacy_unbound"
    LOCAL_ONLY = "local_only"
    OFFICIAL_DEFAULT = "official_default"
    TOFU = "tofu"
    EXPLICIT_INSTALL = "explicit_install"
    EXPLICIT_SOURCE_CHANGE = "explicit_source_change"


class PluginMarketAvailability(StrEnum):
    """存量迁移观察市场候选时的可用状态。"""

    AVAILABLE = "available"
    UNAVAILABLE = "unavailable"


class PluginIdentityConflictError(RuntimeError):
    """来源身份的首次创建或 revision 条件更新已失去竞争。"""


def normalize_physical_plugin_id(plugin_id: str) -> str:
    """校验物理插件 ID，并返回大小写无关的数据库身份键。"""
    if plugin_id != plugin_id.strip() or not _PLUGIN_ID_PATTERN.fullmatch(plugin_id):
        raise ValueError("插件 ID 必须以字母开头且只能包含 ASCII 字母或数字")
    return plugin_id.lower()


def validate_online_source_key(source_key: str) -> str:
    """校验由市场边界生成的稳定 GitHub 仓库身份键。"""
    value = source_key.strip().lower()
    if not _ONLINE_SOURCE_KEY_PATTERN.fullmatch(value):
        raise ValueError("在线插件来源必须使用 github:<owner>/<repository> 规范键")
    return value


def _validate_online_source_classification(
    source_key: str,
    source_type: TrustedPluginSourceType | PluginPayloadSourceType,
) -> None:
    """保证官方仓库键与官方来源类型始终双向一致。"""
    is_official_key = source_key == OFFICIAL_PLUGIN_SOURCE_KEY
    is_official_type = source_type.value == TrustedPluginSourceType.OFFICIAL.value
    if is_official_key != is_official_type:
        raise ValueError("官方来源类型只能对应 MoviePilot 官方插件仓库")


def _validate_optional_text(
    value: str | None,
    *,
    field_name: str,
    max_length: int,
) -> None:
    """让应用层字符串合同与跨数据库列长度保持一致。"""
    if value is not None and len(value) > max_length:
        raise ValueError(f"{field_name} 长度不能超过 {max_length}")


def _validate_receipt(receipt: str | None) -> str | None:
    """校验内容收据为带算法前缀的十六进制摘要。"""
    if receipt is None:
        return None
    value = receipt.strip().lower()
    if not re.fullmatch(r"sha256:[0-9a-f]{64}", value):
        raise ValueError("插件载荷收据必须为 sha256:<64 hex>")
    return value


@dataclass(frozen=True, slots=True)
class PluginIdentity:
    """一份物理插件的可信更新来源与当前载荷审计事实。"""

    plugin_id: str
    normalized_plugin_id: str
    trusted_source_type: TrustedPluginSourceType
    trusted_source_key: str | None
    binding_basis: PluginBindingBasis
    payload_source_type: PluginPayloadSourceType
    payload_source_key: str | None
    declared_version: str | None
    package_generation: str | None
    system_version: str | None
    supports_v3: bool | None
    supports_v3t: bool | None
    payload_receipt: str | None
    revision: int
    created_at: datetime
    updated_at: datetime
    bound_at: datetime | None
    payload_applied_at: datetime | None

    def __post_init__(self) -> None:
        """拒绝不能作为后续来源门禁事实的矛盾状态。"""
        normalized_id = normalize_physical_plugin_id(self.plugin_id)
        if self.normalized_plugin_id != normalized_id:
            raise ValueError("normalized_plugin_id 必须是 plugin_id 的规范化物理身份")
        if self.revision < 1:
            raise ValueError("来源身份 revision 必须从 1 开始")
        if self.created_at.tzinfo is None or self.updated_at.tzinfo is None:
            raise ValueError("来源身份审计时间必须包含时区")
        if self.updated_at < self.created_at:
            raise ValueError("来源身份更新时间不能早于创建时间")
        for audit_time in (self.bound_at, self.payload_applied_at):
            if audit_time is not None and audit_time.tzinfo is None:
                raise ValueError("来源身份审计时间必须包含时区")
            if audit_time is not None and not self.created_at <= audit_time <= self.updated_at:
                raise ValueError("来源身份审计时间必须位于创建与更新时间之间")

        trusted_key = (
            validate_online_source_key(self.trusted_source_key)
            if self.trusted_source_key
            else None
        )
        if self.trusted_source_type is TrustedPluginSourceType.UNKNOWN:
            if trusted_key is not None or self.bound_at is not None:
                raise ValueError("未绑定身份不能携带可信来源或绑定时间")
            if self.binding_basis not in {
                PluginBindingBasis.LEGACY_UNBOUND,
                PluginBindingBasis.LOCAL_ONLY,
            }:
                raise ValueError("未绑定身份只能使用存量迁移或本地插件依据")
        else:
            if trusted_key is None or self.bound_at is None:
                raise ValueError("已绑定身份必须携带规范来源和绑定时间")
            if self.binding_basis in {
                PluginBindingBasis.LEGACY_UNBOUND,
                PluginBindingBasis.LOCAL_ONLY,
            }:
                raise ValueError("已绑定身份不能使用未绑定来源依据")
            _validate_online_source_classification(
                trusted_key,
                self.trusted_source_type,
            )
        if (
            self.binding_basis is PluginBindingBasis.OFFICIAL_DEFAULT
            and self.trusted_source_type is not TrustedPluginSourceType.OFFICIAL
        ):
            raise ValueError("official_default 只能绑定官方来源")
        if (
            self.binding_basis is PluginBindingBasis.TOFU
            and self.trusted_source_type is not TrustedPluginSourceType.THIRD_PARTY
        ):
            raise ValueError("TOFU 只能绑定唯一第三方在线来源")

        payload_key = (
            validate_online_source_key(self.payload_source_key)
            if self.payload_source_key
            else None
        )
        if self.payload_source_type in {
            PluginPayloadSourceType.OFFICIAL,
            PluginPayloadSourceType.THIRD_PARTY,
        }:
            if payload_key is None:
                raise ValueError("在线载荷必须携带规范来源")
            _validate_online_source_classification(
                payload_key,
                self.payload_source_type,
            )
        elif payload_key is not None:
            raise ValueError("未知或本地载荷不能携带在线来源键")
        if self.payload_source_type is PluginPayloadSourceType.UNKNOWN:
            if any((
                self.declared_version,
                self.package_generation,
                self.system_version,
                self.supports_v3 is not None,
                self.supports_v3t is not None,
                self.payload_receipt,
                self.payload_applied_at,
            )):
                raise ValueError("未知载荷不能携带版本、兼容声明、收据或应用时间")
        else:
            if not self.declared_version or not self.package_generation:
                raise ValueError("已知载荷必须携带声明版本和包代际")
            if self.payload_applied_at is None or self.payload_receipt is None:
                raise ValueError("已知载荷必须携带应用时间和内容收据")
            if (
                self.payload_source_type is not PluginPayloadSourceType.LOCAL
                and (
                    payload_key != trusted_key
                    or self.payload_source_type.value
                    != self.trusted_source_type.value
                )
            ):
                raise ValueError("在线载荷来源必须与可信更新来源一致")
        if (
            self.binding_basis is PluginBindingBasis.LOCAL_ONLY
            and self.payload_source_type is not PluginPayloadSourceType.LOCAL
        ):
            raise ValueError("本地插件身份必须携带已提交的本地载荷事实")

        if self.package_generation not in {None, "v1", "v2", "v3"}:
            raise ValueError("插件包代际必须为 v1、v2 或 v3")
        _validate_optional_text(
            self.declared_version,
            field_name="插件声明版本",
            max_length=64,
        )
        _validate_optional_text(
            self.system_version,
            field_name="插件系统版本要求",
            max_length=128,
        )
        object.__setattr__(self, "trusted_source_key", trusted_key)
        object.__setattr__(self, "payload_source_key", payload_key)
        object.__setattr__(self, "payload_receipt", _validate_receipt(self.payload_receipt))


@dataclass(frozen=True, slots=True)
class PluginSourceCandidate:
    """存量迁移可观察到的一个在线候选来源。"""

    source_type: TrustedPluginSourceType
    source_key: str

    def __post_init__(self) -> None:
        """候选只接受可绑定的规范在线来源。"""
        if self.source_type is TrustedPluginSourceType.UNKNOWN:
            raise ValueError("未知来源不能作为在线候选")
        object.__setattr__(self, "source_key", validate_online_source_key(self.source_key))
        _validate_online_source_classification(self.source_key, self.source_type)


def plan_legacy_plugin_identity(
    *,
    plugin_id: str,
    market_availability: PluginMarketAvailability,
    online_candidates: tuple[PluginSourceCandidate, ...],
    is_virtual_instance: bool,
    now: datetime,
) -> PluginIdentity | None:
    """为存量物理插件建立更新绑定，不冒充当前载荷来源。"""
    if is_virtual_instance:
        return None
    normalized_id = normalize_physical_plugin_id(plugin_id)
    candidates = {
        (candidate.source_type, candidate.source_key): candidate
        for candidate in online_candidates
    }
    official = sorted(
        (
            candidate
            for candidate in candidates.values()
            if candidate.source_type is TrustedPluginSourceType.OFFICIAL
        ),
        key=lambda candidate: candidate.source_key,
    )
    third_party = sorted(
        (
            candidate
            for candidate in candidates.values()
            if candidate.source_type is TrustedPluginSourceType.THIRD_PARTY
        ),
        key=lambda candidate: candidate.source_key,
    )

    trusted_type = TrustedPluginSourceType.UNKNOWN
    trusted_key = None
    basis = PluginBindingBasis.LEGACY_UNBOUND
    bound_at = None
    if market_availability is PluginMarketAvailability.AVAILABLE and official:
        trusted_type = TrustedPluginSourceType.OFFICIAL
        trusted_key = official[0].source_key
        basis = PluginBindingBasis.OFFICIAL_DEFAULT
        bound_at = now
    elif (
        market_availability is PluginMarketAvailability.AVAILABLE
        and len(third_party) == 1
    ):
        trusted_type = TrustedPluginSourceType.THIRD_PARTY
        trusted_key = third_party[0].source_key
        basis = PluginBindingBasis.TOFU
        bound_at = now

    return PluginIdentity(
        plugin_id=plugin_id,
        normalized_plugin_id=normalized_id,
        trusted_source_type=trusted_type,
        trusted_source_key=trusted_key,
        binding_basis=basis,
        payload_source_type=PluginPayloadSourceType.UNKNOWN,
        payload_source_key=None,
        declared_version=None,
        package_generation=None,
        system_version=None,
        supports_v3=None,
        supports_v3t=None,
        payload_receipt=None,
        revision=1,
        created_at=now,
        updated_at=now,
        bound_at=bound_at,
        payload_applied_at=None,
    )


class PluginIdentityRepository(Protocol):
    """来源身份条件写命令使用的无提交仓储端口。"""

    def get(self, plugin_id: str) -> PluginIdentity | None:
        """按规范化物理插件 ID 读取身份。"""

    def stage_create(self, identity: PluginIdentity) -> None:
        """暂存首次身份；唯一键竞争时抛出冲突错误。"""

    def stage_replace(
        self,
        identity: PluginIdentity,
        *,
        expected_revision: int,
    ) -> bool:
        """按 revision 条件暂存替换，并返回是否赢得竞争。"""


class PluginIdentityUnitOfWork(Protocol):
    """来源身份条件写使用的事务端口。"""

    def commit(self) -> None:
        """提交当前条件写。"""

    def rollback(self) -> None:
        """回滚当前条件写。"""


class WritePluginIdentityCommand:
    """以数据库 revision 原子创建或替换一份插件来源身份。"""

    def __init__(
        self,
        repository: PluginIdentityRepository,
        unit_of_work: PluginIdentityUnitOfWork,
    ) -> None:
        """保存仓储与事务所有者。"""
        self._repository = repository
        self._unit_of_work = unit_of_work

    def execute(
        self,
        identity: PluginIdentity,
        *,
        expected_revision: int | None,
    ) -> PluginIdentity:
        """首次写要求记录不存在，后续写要求 revision 精确匹配。"""
        candidate = replace(
            identity,
            normalized_plugin_id=normalize_physical_plugin_id(identity.plugin_id),
            revision=1 if expected_revision is None else expected_revision + 1,
        )
        try:
            if expected_revision is None:
                if (
                    candidate.binding_basis
                    is PluginBindingBasis.EXPLICIT_SOURCE_CHANGE
                ):
                    raise PluginIdentityConflictError(
                        "首次插件身份不能伪装成已确认的来源变更"
                    )
                self._repository.stage_create(candidate)
            else:
                current = self._repository.get(candidate.normalized_plugin_id)
                if current is None or current.revision != expected_revision:
                    raise PluginIdentityConflictError(
                        f"插件 {candidate.plugin_id} 的来源身份已被其他任务更新"
                    )
                immutable_binding = (
                    "plugin_id",
                    "normalized_plugin_id",
                    "trusted_source_type",
                    "trusted_source_key",
                    "binding_basis",
                    "created_at",
                    "bound_at",
                )
                if any(
                    getattr(candidate, field_name) != getattr(current, field_name)
                    for field_name in immutable_binding
                ):
                    raise PluginIdentityConflictError(
                        "普通插件身份更新不能改变物理 ID 或可信来源绑定"
                    )
                if candidate.updated_at < current.updated_at:
                    raise PluginIdentityConflictError(
                        "插件身份更新时间不能早于已提交记录"
                    )
                if not self._repository.stage_replace(
                    candidate,
                    expected_revision=expected_revision,
                ):
                    raise PluginIdentityConflictError(
                        f"插件 {candidate.plugin_id} 的来源身份已被其他任务更新"
                    )
            self._unit_of_work.commit()
            return candidate
        except Exception:
            self._unit_of_work.rollback()
            raise