"""
Сервисы для модуля закупок и инвентаря.
"""

import re
from typing import Optional
from urllib.parse import urlsplit, urlunsplit

from django.db import transaction
from django.utils import timezone

from procurement.constants import (
    ApprovalStatus,
    ProcurementStatus,
    get_default_approval_step_name,
)

HTTP_LINK_PATTERN = re.compile(r"https?://[^\s<>\"']+", re.IGNORECASE)
TRAILING_LINK_PUNCTUATION = ".,;:!?)]}"


def _normalize_http_link(value: str) -> str | None:
    candidate = str(value or "").strip().rstrip(TRAILING_LINK_PUNCTUATION)
    if not candidate:
        return None

    try:
        parsed = urlsplit(candidate)
        hostname = parsed.hostname
        if parsed.scheme.lower() not in {"http", "https"} or not hostname:
            return None
        return urlunsplit(
            (
                parsed.scheme.lower(),
                parsed.netloc.lower(),
                parsed.path,
                parsed.query,
                parsed.fragment,
            )
        )
    except ValueError:
        return None


def _http_link_identity(value: str) -> str | None:
    candidate = str(value or "").strip()
    if not re.match(r"^https?://", candidate, re.IGNORECASE):
        candidate = f"https://{candidate}"
    normalized = _normalize_http_link(candidate)
    if normalized is None:
        return None
    parsed = urlsplit(normalized)
    path = "" if parsed.path == "/" else parsed.path
    return urlunsplit(
        (parsed.scheme, parsed.netloc, path, parsed.query, parsed.fragment)
    )


def merge_comment_links(
    existing_links, comment_text: str
) -> tuple[list[str], list[str]]:
    """Append unique HTTP links extracted from a position comment."""

    merged = [str(link).strip() for link in (existing_links or []) if str(link).strip()]
    identities = {
        identity
        for link in merged
        if (identity := _http_link_identity(link)) is not None
    }
    added = []
    for match in HTTP_LINK_PATTERN.finditer(comment_text or ""):
        link = _normalize_http_link(match.group(0))
        identity = _http_link_identity(link or "")
        if link is None or identity is None or identity in identities:
            continue
        identities.add(identity)
        merged.append(link)
        added.append(link)
    return merged, added


class InventoryNumberGenerator:
    """Генератор инвентарных номеров."""

    PREFIX = "INV"

    @classmethod
    def generate(cls, year: Optional[int] = None) -> str:
        """
        Генерирует уникальный инвентарный номер.

        Формат: INV-YYYY-NNNN
        Например: INV-2025-0001, INV-2025-0002
        """
        from .models import Equipment

        if year is None:
            year = timezone.now().year

        # Находим последний номер за этот год
        prefix = f"{cls.PREFIX}-{year}-"
        last_equipment = (
            Equipment.objects.filter(inventory_number__startswith=prefix)
            .order_by("-inventory_number")
            .first()
        )

        if last_equipment:
            # Извлекаем номер из последнего инвентарного номера
            try:
                last_num = int(last_equipment.inventory_number.split("-")[-1])
            except (ValueError, IndexError):
                last_num = 0
        else:
            last_num = 0

        new_num = last_num + 1
        return f"{cls.PREFIX}-{year}-{new_num:04d}"

    @classmethod
    def validate(cls, inventory_number: str) -> bool:
        """
        Проверяет формат инвентарного номера.

        Returns:
            True если формат верный, False иначе
        """
        parts = inventory_number.split("-")
        if len(parts) != 3:
            return False

        prefix, year_str, num_str = parts

        if prefix != cls.PREFIX:
            return False

        try:
            year = int(year_str)
            if year < 2000 or year > 2100:
                return False
        except ValueError:
            return False

        try:
            num = int(num_str)
            if num < 1:
                return False
        except ValueError:
            return False

        return True


class ProcurementApprovalResolver:
    """Определяет согласующих для заявки на закупку.

    Состав этапов и их порядок берутся из таблицы ApprovalRoute.
    Для этапа типа department_head согласующий определяется
    через Department.head.
    """

    WORK_ASSIGNABLE_STATUSES = frozenset(
        {
            ProcurementStatus.WAITING,
            ProcurementStatus.PENDING,
            ProcurementStatus.APPROVED,
            ProcurementStatus.IN_PROGRESS,
        }
    )

    @classmethod
    def user_is_department_participant(cls, user, department_id):
        """Проверяет рабочее участие пользователя в отделе.

        Участником считается физический сотрудник отдела, руководитель отдела
        или сотрудник с активной ролью в этом отделе.
        """
        if not department_id or not user or not user.is_authenticated:
            return False

        from employees.models import (
            Department,
            EmployeeDepartment,
            RoleAssignment,
        )

        return (
            EmployeeDepartment.objects.filter(
                employee_id=user.id,
                department_id=department_id,
                is_active=True,
            ).exists()
            or Department.objects.filter(
                id=department_id,
                head_id=user.id,
            ).exists()
            or RoleAssignment.objects.filter(
                employee_id=user.id,
                role__department_id=department_id,
                is_active=True,
            ).exists()
        )

    @classmethod
    def get_user_department_participant_ids(cls, user):
        """Возвращает отделы, где пользователь участник или role-only участник."""
        if not user or not user.is_authenticated:
            return []

        from employees.models import (
            Department,
            EmployeeDepartment,
            RoleAssignment,
        )

        department_ids = set(
            EmployeeDepartment.objects.filter(
                employee_id=user.id,
                is_active=True,
            ).values_list("department_id", flat=True)
        )
        department_ids.update(
            Department.objects.filter(head_id=user.id).values_list(
                "id",
                flat=True,
            )
        )
        department_ids.update(
            RoleAssignment.objects.filter(
                employee_id=user.id,
                is_active=True,
            ).values_list("role__department_id", flat=True)
        )
        return sorted(department_ids)

    @classmethod
    def user_is_processing_department_member(cls, user, procurement_request):
        return cls.user_is_department_participant(
            user,
            procurement_request.processing_department_id,
        )

    @classmethod
    def get_department_approval_users(cls, procurement_request):
        """Return users who can approve the department-head approval step."""
        if not procurement_request.department_id:
            return []

        from employees.constants import DeptPerm
        from employees.models import Employee, EmployeeDepartment, RoleAssignment

        department = procurement_request.department
        approver_ids = []
        seen = set()

        def add_user_id(user_id):
            if user_id and user_id not in seen:
                seen.add(user_id)
                approver_ids.append(user_id)

        if department.head_id and department.head.is_active:
            add_user_id(department.head_id)

        role_assignment_user_ids = RoleAssignment.objects.filter(
            role__department_id=department.id,
            role__scoped_permissions__code=DeptPerm.APPROVE_PROCUREMENT,
            employee__is_active=True,
            is_active=True,
        ).values_list("employee_id", flat=True)
        for user_id in role_assignment_user_ids:
            add_user_id(user_id)

        legacy_role_user_ids = EmployeeDepartment.objects.filter(
            department_id=department.id,
            role__scoped_permissions__code=DeptPerm.APPROVE_PROCUREMENT,
            employee__is_active=True,
            is_active=True,
        ).values_list("employee_id", flat=True)
        for user_id in legacy_role_user_ids:
            add_user_id(user_id)

        users_by_id = Employee.objects.in_bulk(approver_ids)
        return [
            users_by_id[user_id] for user_id in approver_ids if user_id in users_by_id
        ]

    @classmethod
    def user_can_approve_department_step(cls, user, procurement_request) -> bool:
        if not user or not user.is_authenticated:
            return False
        return any(
            approver.id == user.id
            for approver in cls.get_department_approval_users(
                procurement_request,
            )
        )

    @classmethod
    def user_can_submit_for_approval(cls, user, procurement_request) -> bool:
        if not user or not user.is_authenticated:
            return False

        if (
            procurement_request.status == ProcurementStatus.PENDING
            or procurement_request.approvals.filter(
                status=ApprovalStatus.PENDING,
            ).exists()
            or procurement_request.approvals.filter(
                status=ApprovalStatus.APPROVED,
            ).exists()
        ):
            return False

        if not procurement_request.processing_department_id:
            return False

        if procurement_request.status not in {
            ProcurementStatus.WAITING,
            ProcurementStatus.IN_PROGRESS,
        }:
            return False

        requestor_is_submitting = procurement_request.requestor_id == user.id
        same_customer_and_processing_department = (
            procurement_request.department_id
            and procurement_request.department_id
            == procurement_request.processing_department_id
        )
        if requestor_is_submitting and not same_customer_and_processing_department:
            return False

        return cls.user_is_processing_department_member(
            user,
            procurement_request,
        )

    @classmethod
    def user_can_start_work(cls, user, procurement_request) -> bool:
        if not user or not user.is_authenticated:
            return False

        if (
            procurement_request.request_type == "subscription"
            and procurement_request.status
            not in {ProcurementStatus.APPROVED, ProcurementStatus.IN_PROGRESS}
        ):
            return False

        if procurement_request.status not in cls.WORK_ASSIGNABLE_STATUSES:
            return False

        if procurement_request.executor_id == user.id:
            return False

        has_execute_access = (
            user.is_superuser
            or user.is_staff
            or user.has_perm("procurement.change_procurementrequest")
            or user.has_perm("procurement.execute_procurement")
        )

        if procurement_request.executor_id:
            if has_execute_access:
                return True
            if procurement_request.processing_department_id:
                return cls.user_is_processing_department_member(
                    user,
                    procurement_request,
                )
            return True

        if has_execute_access:
            return True

        if procurement_request.processing_department_id:
            return cls.user_is_processing_department_member(
                user,
                procurement_request,
            )

        return True

    @classmethod
    def user_can_process_items(cls, user, procurement_request) -> bool:
        if not user or not user.is_authenticated:
            return False

        if (
            procurement_request.request_type == "subscription"
            and procurement_request.status
            not in {ProcurementStatus.APPROVED, ProcurementStatus.IN_PROGRESS}
        ):
            return False

        if procurement_request.status not in {
            ProcurementStatus.WAITING,
            ProcurementStatus.IN_PROGRESS,
            ProcurementStatus.COMPLETED,
        }:
            return False

        if procurement_request.executor_id == user.id:
            return True

        if (
            user.is_superuser
            or user.is_staff
            or user.has_perm("procurement.change_procurementrequest")
            or user.has_perm("procurement.execute_procurement")
        ):
            return True

        if procurement_request.processing_department_id:
            return cls.user_is_processing_department_member(
                user,
                procurement_request,
            )

        return False

    @classmethod
    def resolve_approval_step(cls, procurement_request, route):
        from .models import ApprovalRoute

        if route is None:
            return None

        if not isinstance(route, ApprovalRoute):
            route = (
                ApprovalRoute.objects.select_related("employee")
                .filter(
                    priority=route,
                )
                .first()
            )
            if route is None:
                return None

        step_name = route.name or get_default_approval_step_name(
            route.priority,
            resolver_type=route.resolver_type,
        )

        if route.resolver_type == ApprovalRoute.ResolverType.DEPARTMENT_HEAD:
            approvers = cls.get_department_approval_users(procurement_request)
            if approvers:
                return route.priority, approvers[0], step_name
            return None

        if route.employee and route.employee.is_active:
            return route.priority, route.employee, step_name
        return None

    @classmethod
    def resolve_approver(cls, procurement_request, priority: int):
        step = cls.resolve_approval_step(procurement_request, priority)
        if step is None:
            return None
        return step[1]

    @classmethod
    def resolve_required_approvers(cls, procurement_request):
        resolved, missing = [], []
        for route in procurement_request.get_required_approval_routes():
            step = cls.resolve_approval_step(procurement_request, route)
            if step:
                resolved.append(step)
            else:
                missing.append(route.priority)
        resolved.sort(key=lambda item: item[0])
        return resolved, missing

    @classmethod
    def resolve_required_approvers_detailed(cls, procurement_request):
        """Возвращает согласующих и подробности по пропущенным этапам."""
        from .models import ApprovalRoute

        resolved = []
        missing = []

        for route in procurement_request.get_required_approval_routes():
            step = cls.resolve_approval_step(procurement_request, route)
            if step:
                resolved.append(step)
                continue

            step_label = route.name or get_default_approval_step_name(
                route.priority,
                resolver_type=route.resolver_type,
            )
            reason = "unknown"
            if route.resolver_type == ApprovalRoute.ResolverType.DEPARTMENT_HEAD:
                reason = "department_head_missing"
            elif route.resolver_type == ApprovalRoute.ResolverType.FIXED_EMPLOYEE:
                reason = "approver_missing_or_inactive"

            missing.append(
                {
                    "priority": route.priority,
                    "step_name": step_label,
                    "resolver_type": route.resolver_type,
                    "reason": reason,
                }
            )

        resolved.sort(key=lambda item: item[0])
        return resolved, missing

    @classmethod
    def get_available_approval(cls, user, procurement_request):
        if not user or not user.is_authenticated:
            return None

        if procurement_request.status != ProcurementStatus.PENDING:
            return None

        pending = procurement_request.approvals.filter(
            status=ApprovalStatus.PENDING,
        ).order_by("priority", "created_at", "id")
        first_pending = pending.first()
        if first_pending is None:
            return None

        direct_approval = pending.filter(
            approver=user,
            priority__gte=first_pending.priority,
        ).first()
        if direct_approval is not None:
            return direct_approval

        for approval in pending.filter(priority__gte=first_pending.priority):
            if cls.approval_can_be_taken_by_user(approval, user):
                return approval
        return None

    @classmethod
    def approval_can_be_taken_by_user(cls, approval, user) -> bool:
        from .models import ApprovalRoute

        route = ApprovalRoute.objects.filter(
            priority=approval.priority,
            resolver_type=ApprovalRoute.ResolverType.DEPARTMENT_HEAD,
        ).first()
        if not route:
            return False
        return cls.user_can_approve_department_step(user, approval.request)

    @classmethod
    def get_available_higher_route(cls, user, procurement_request):
        if not user or not user.is_authenticated:
            return None

        if procurement_request.status != ProcurementStatus.PENDING:
            return None

        first_pending = (
            procurement_request.approvals.filter(
                status=ApprovalStatus.PENDING,
            )
            .order_by("priority", "created_at", "id")
            .first()
        )
        if first_pending is None:
            return None

        from .models import ApprovalRoute

        existing_priorities = set(
            procurement_request.approvals.values_list("priority", flat=True)
        )
        routes = (
            ApprovalRoute.objects.select_related("employee")
            .filter(priority__gt=first_pending.priority)
            .order_by("priority", "id")
        )
        for route in routes:
            if route.priority in existing_priorities:
                continue
            step = cls.resolve_approval_step(procurement_request, route)
            if step and step[1].id == user.id:
                return step
            if (
                route.resolver_type == ApprovalRoute.ResolverType.DEPARTMENT_HEAD
                and cls.user_can_approve_department_step(
                    user,
                    procurement_request,
                )
            ):
                step_name = (
                    step[2]
                    if step
                    else route.name
                    or get_default_approval_step_name(
                        route.priority,
                        resolver_type=route.resolver_type,
                    )
                )
                return route.priority, user, step_name
        return None

    @classmethod
    def get_or_create_available_approval(cls, user, procurement_request):
        approval = cls.get_available_approval(user, procurement_request)
        if approval is not None:
            return approval

        step = cls.get_available_higher_route(user, procurement_request)
        if step is None:
            return None

        from .models import Approval

        priority, approver, step_name = step
        approval, _ = Approval.objects.get_or_create(
            request=procurement_request,
            priority=priority,
            defaults={
                "approver": approver,
                "step_name": step_name,
                "status": ApprovalStatus.PENDING,
            },
        )
        if approval.approver_id != user.id or approval.status != ApprovalStatus.PENDING:
            return None
        return approval

    @classmethod
    def user_can_approve(cls, user, procurement_request) -> bool:
        if not user or not user.is_authenticated:
            return False
        return (
            cls.get_available_approval(user, procurement_request) is not None
            or cls.get_available_higher_route(user, procurement_request) is not None
        )


class EquipmentService:
    """Сервис для операций с оборудованием."""

    @classmethod
    @transaction.atomic
    def create_equipment(
        cls,
        name: str,
        category,
        department,
        purchase_date,
        purchase_cost,
        **kwargs,
    ):
        """
        Создаёт новое оборудование с авто-генерацией инвентарного номера.
        """
        from .models import Equipment

        # Генерируем инвентарный номер если не указан
        if "inventory_number" not in kwargs or not kwargs["inventory_number"]:
            kwargs["inventory_number"] = InventoryNumberGenerator.generate()

        equipment = Equipment.objects.create(
            name=name,
            category=category,
            department=department,
            purchase_date=purchase_date,
            purchase_cost=purchase_cost,
            **kwargs,
        )

        return equipment

    @classmethod
    @transaction.atomic
    def assign_to_person(cls, equipment, person, location: Optional[str] = None):
        """
        Назначает оборудование ответственному лицу.
        """
        from .constants import EquipmentStatus
        from .models import EquipmentTransferLog

        old_person = equipment.responsible_person
        old_location = equipment.location

        equipment.responsible_person = person
        equipment.status = EquipmentStatus.IN_USE
        if location:
            equipment.location = location
        equipment.save()

        # Логируем передачу
        EquipmentTransferLog.objects.create(
            equipment=equipment,
            from_person=old_person,
            to_person=person,
            from_location=old_location,
            to_location=location or equipment.location,
            transfer_type="assignment",
        )

        return equipment

    @classmethod
    @transaction.atomic
    def transfer(
        cls,
        equipment,
        to_department,
        to_person=None,
        to_location: Optional[str] = None,
        reason: str = "",
    ):
        """
        Перемещает оборудование в другой отдел.
        """
        from .models import EquipmentTransferLog

        old_department = equipment.department
        old_person = equipment.responsible_person
        old_location = equipment.location

        equipment.department = to_department
        equipment.responsible_person = to_person
        if to_location:
            equipment.location = to_location
        equipment.save()

        # Логируем передачу
        EquipmentTransferLog.objects.create(
            equipment=equipment,
            from_department=old_department,
            to_department=to_department,
            from_person=old_person,
            to_person=to_person,
            from_location=old_location,
            to_location=to_location or "",
            transfer_type="transfer",
            reason=reason,
        )

        return equipment

    @classmethod
    @transaction.atomic
    def write_off(cls, equipment, reason: str):
        """
        Списывает оборудование.
        """
        from .constants import EquipmentStatus

        equipment.status = EquipmentStatus.WRITTEN_OFF
        equipment.notes = (
            f"{equipment.notes}\n\n"
            f"[{timezone.now().strftime('%Y-%m-%d')}] Списано: {reason}"
        ).strip()
        equipment.save()

        return equipment

    @classmethod
    @transaction.atomic
    def add_maintenance_record(
        cls,
        equipment,
        maintenance_type: str,
        description: str,
        performed_by,
        cost=None,
        date=None,
    ):
        """
        Добавляет запись о техническом обслуживании.
        """
        from decimal import Decimal

        from .constants import EquipmentStatus
        from .models import MaintenanceRecord

        if date is None:
            date = timezone.now().date()

        if cost is None:
            cost = Decimal("0.00")

        record = MaintenanceRecord.objects.create(
            equipment=equipment,
            date=date,
            type=maintenance_type,
            description=description,
            cost=cost,
            performed_by=performed_by,
        )

        # Если на ремонте - обновляем статус
        if maintenance_type == "repair":
            equipment.status = EquipmentStatus.IN_REPAIR
            equipment.save()

        return record