"""Pinned and marker/registry-bound WeeklyOperations authority root."""
from __future__ import annotations

import os
import stat
from dataclasses import dataclass
from pathlib import Path

from checkin_cli.weekly_operations import CustomerIdentityDigest, WeeklyOperationsCorruption, WeeklyOperationsInputError
from checkin_cli.weekly_operations_canonical_registry_history import REGISTRY_NAME
from checkin_cli.weekly_operations_layout import validate_customer_inventory
from checkin_cli.weekly_operations_parent import WeeklyOperationsAuthorityBinding, WeeklyOperationsParentAuthority, read_authority_marker, validate_authority_binding
from checkin_cli.weekly_operations_repair import WeeklyOperationsRepairBinding, validate_repair_binding

@dataclass(frozen=True, slots=True)
class WeeklyOperationsAuthorityRoot:
    """Duplicate of the pinned dedicated authority-root descriptor."""

    parent: WeeklyOperationsParentAuthority
    descriptor: int
    binding: WeeklyOperationsAuthorityBinding
    repair_binding: WeeklyOperationsRepairBinding | None = None

    @property
    def observed_path(self) -> Path:
        return self.parent.observed_path

    @property
    def repair_target_digest(self) -> str | None:
        return None if self.repair_binding is None else self.repair_binding.customer_storage_digest

    def verify_name_locked(self) -> None:
        self.parent.verify()
        root = os.fstat(self.descriptor)
        if (root.st_dev, root.st_ino) != (self.binding.root_device, self.binding.root_inode):
            raise WeeklyOperationsCorruption("authority root descriptor mismatch")

    def verify_locked(self) -> None:
        self.verify_name_locked()
        verify_authority_descriptor(self.descriptor, self.binding, repair_target_digest=self.repair_target_digest)

    def verify(self) -> None:
        with self.parent.locked():
            self.verify_locked()

    def verify_complete_locked(self) -> None:
        self.verify_name_locked()
        verify_authority_descriptor(self.descriptor, self.binding)

    def verify_for_repair(self, customer_identity: CustomerIdentityDigest) -> None:
        if self.repair_binding is None or self.repair_binding.customer_identity_digest != customer_identity:
            raise WeeklyOperationsInputError("repair authority customer mismatch")
        validate_repair_binding(self.repair_binding)
        self.verify_name_locked()
        verify_authority_descriptor(self.descriptor, self.binding, repair_target_digest=self.repair_binding.customer_storage_digest)

    def close(self) -> None:
        os.close(self.descriptor)


def verify_authority_descriptor(descriptor: int, binding: WeeklyOperationsAuthorityBinding, *, repair_target_digest: str | None = None) -> None:
    validate_authority_binding(binding)
    try:
        root = os.fstat(descriptor)
        observed_root = root.st_dev, root.st_ino, stat.S_IMODE(root.st_mode), root.st_uid, root.st_nlink
        expected_root = binding.root_device, binding.root_inode, binding.root_mode, binding.root_owner, binding.root_links
        if not stat.S_ISDIR(root.st_mode) or observed_root != expected_root:
            raise WeeklyOperationsCorruption("weekly operations authority inode drift")
        marker_value, marker_digest, marker = read_authority_marker(descriptor)
        validate_customer_inventory(descriptor, repair_target_digest=repair_target_digest)
        registry = os.stat(REGISTRY_NAME, dir_fd=descriptor, follow_symlinks=False)
        observed_marker = marker_value.authority_id, marker.st_dev, marker.st_ino, stat.S_IMODE(marker.st_mode), marker.st_uid, marker.st_nlink, marker_digest
        expected_marker = binding.authority_id, binding.marker_device, binding.marker_inode, binding.marker_mode, binding.marker_owner, binding.marker_links, binding.marker_digest
        observed_registry = registry.st_dev, registry.st_ino, stat.S_IMODE(registry.st_mode), registry.st_uid, registry.st_nlink, marker_value.registry_digest
        expected_registry = binding.registry_device, binding.registry_inode, binding.registry_mode, binding.registry_owner, binding.registry_links, binding.registry_digest
        marker_registry = marker_value.registry_device, marker_value.registry_inode, marker_value.registry_mode, marker_value.registry_owner, marker_value.registry_links, marker_value.registry_digest
        if observed_marker != expected_marker or observed_registry != expected_registry or marker_registry != expected_registry:
            raise WeeklyOperationsCorruption("authority bootstrap binding mismatch")
    except OSError as error:
        raise WeeklyOperationsCorruption("authority flat topology is unsafe") from error