"""首页入口服务实现。"""

from __future__ import annotations

from datetime import date, datetime
import json
from typing import Any

from sqlalchemy import text

from fastapi_common.fastapi_common_sqlalchemy.database import GetAsyncSession
from fastapi_common.fastapi_common_web.domain.responses import StatusCodeEnum
from fastapi_common.fastapi_common_web.exception.LeauditException import LeauditException

from fastapi_modules.fastapi_leaudit.domian.vo.homeVo import (
    HomeDashboardGrowthVO,
    HomeDashboardStatisticsVO,
    HomeEntryAreaVO,
    HomeEntryDocumentTypeVO,
    HomeEntryModuleVO,
    HomeEntryTenantVO,
)
from fastapi_modules.fastapi_leaudit.services import IDocumentService
from fastapi_modules.fastapi_leaudit.services.homeService import IHomeService
from fastapi_modules.fastapi_leaudit.services.impl.documentServiceImpl import DocumentServiceImpl
from fastapi_modules.fastapi_leaudit.services.impl.rbacServiceImpl import RbacServiceImpl
from fastapi_modules.fastapi_leaudit.services.impl.ssoUserCompat import SsoUserCompat
from fastapi_modules.fastapi_leaudit.services.impl.tenantResolver import TenantResolution, TenantResolver


class HomeServiceImpl(IHomeService):
    """首页入口服务实现。"""

    _MINIMAL_ENABLED_TARGETS: tuple[str, ...] = (
        "/home",
        "/files/upload",
        "/documents",
        "/chat-with-llm/chat",
        "/cross-checking",
        "/govdoc",
        "/govdoc/home",
        "/govdoc/audits",
        "/govdoc/upload",
        "/govdoc-audit",
        "/govdoc-audit/home",
        "/govdoc-audit/audits",
        "/govdoc-audit/upload",
    )
    _DOCUMENT_ENTRY_TARGETS: tuple[str, ...] = (
        "/files/upload",
        "/documents",
        "/documents/list",
    )
    _DEFAULT_FEATURES_BY_PROFILE: dict[str, list[str]] = {
        "document_review": ["home", "documents", "upload", "rules", "rule_groups"],
        "contract": ["home", "documents", "upload", "rules", "contract_template_search", "contract_template_list"],
        "govdoc": ["home", "govdoc_audits", "govdoc_upload", "rules"],
        "cross_checking": ["cross_checking", "cross_checking_upload", "cross_checking_list"],
        "custom": ["home", "documents"],
    }

    def __init__(self, DocumentService: IDocumentService | None = None) -> None:
        self.RbacService = RbacServiceImpl()
        self.TenantResolver = TenantResolver()
        self.DocumentService = DocumentService or DocumentServiceImpl()
        self._entry_module_tenant_table_exists_cache: bool | None = None
        self._entry_module_menu_columns_exist_cache: bool | None = None

    async def GetEntryModules(self, UserId: int) -> list[HomeEntryModuleVO]:
        """获取当前用户可见的首页入口模块。"""
        allowed_paths = await self._loadAllowedPaths(UserId=UserId)
        has_tenant_mapping_table = await self._entry_module_tenant_table_exists()

        async with GetAsyncSession() as session:
            sso_user_columns = await SsoUserCompat.get_columns(session)
            tenant_code_select = SsoUserCompat.optional_coalesce_as(
                sso_user_columns,
                alias="u",
                column="tenant_code",
                fallback_sql="''",
            )
            tenant_name_select = SsoUserCompat.optional_coalesce_as(
                sso_user_columns,
                alias="u",
                column="tenant_name",
                fallback_sql="''",
            )
            user_result = await session.execute(
                text(
                    f"""
                    SELECT
                        u.id,
                        COALESCE(u.area, '') AS area,
                        {tenant_code_select},
                        {tenant_name_select},
                        COALESCE(bool_or(r.role_key = 'super_admin'), FALSE) AS bypass_tenant
                    FROM sso_users u
                    LEFT JOIN user_role ur ON ur.user_id = u.id
                    LEFT JOIN roles r ON r.id = ur.role_id
                    WHERE u.id = :user_id
                      AND u.deleted_at IS NULL
                      AND u.status = 0
                    GROUP BY u.id, u.area
                    """
                ),
                {"user_id": UserId},
            )
            user_row = user_result.mappings().first()
            if not user_row:
                raise LeauditException(StatusCodeEnum.HTTP_404_NOT_FOUND, "当前用户不存在或已停用")

            tenant_resolution = await self.TenantResolver.ResolveUserContext(
                Area=str(user_row["area"] or ""),
                TenantCode=str(user_row["tenant_code"] or ""),
                TenantName=str(user_row["tenant_name"] or ""),
                Source="home_entry_user",
            )
            effective_tenant_code = tenant_resolution.tenant_code or ""
            effective_tenant_name = (
                str(tenant_resolution.tenant_name or tenant_resolution.normalized_value or user_row["area"] or "").strip()
            )
            legacy_area_candidates = [
                candidate
                for candidate in {
                    str(user_row["area"] or "").strip(),
                    effective_tenant_name,
                }
                if candidate
            ]
            tenant_select_sql = (
                """
                COALESCE(
                    (
                        SELECT jsonb_agg(
                            jsonb_build_object(
                                'tenant_code', emt.tenant_code,
                                'tenant_name', emt.tenant_name,
                                'enabled', emt.is_enabled,
                                'sort_order', emt.sort_order
                            )
                            ORDER BY emt.sort_order ASC, emt.id ASC
                        )
                        FROM leaudit_entry_module_tenants emt
                        WHERE emt.entry_module_id = em.id
                          AND emt.deleted_at IS NULL
                    ),
                    '[]'::jsonb
                ) AS tenants
                """
                if has_tenant_mapping_table
                else "'[]'::jsonb AS tenants"
            )
            has_menu_columns = await self._entry_module_menu_columns_exist()
            menu_select_sql = self._entry_module_menu_select_sql(has_menu_columns)
            menu_group_by_sql = ",\n                        em.menu_profile,\n                        em.features" if has_menu_columns else ""
            tenant_scope_filter_sql = (
                """
                (
                    :bypass_tenant = TRUE
                    OR EXISTS (
                        SELECT 1
                        FROM leaudit_entry_module_tenants emt
                        WHERE emt.entry_module_id = em.id
                          AND emt.deleted_at IS NULL
                          AND emt.is_enabled = TRUE
                          AND (
                              emt.tenant_code = :user_tenant_code
                              OR emt.tenant_code = 'PUBLIC'
                          )
                    )
                    OR (
                        NOT EXISTS (
                            SELECT 1
                            FROM leaudit_entry_module_tenants emt0
                            WHERE emt0.entry_module_id = em.id
                              AND emt0.deleted_at IS NULL
                        )
                        AND (
                            EXISTS (
                                SELECT 1
                                FROM jsonb_array_elements(COALESCE(em.areas, '[]'::jsonb)) AS area_item
                                WHERE area_item->>'area' = ANY(:legacy_area_candidates)
                                  AND COALESCE((area_item->>'enabled')::boolean, FALSE) = TRUE
                            )
                            OR EXISTS (
                                SELECT 1
                                FROM jsonb_array_elements(COALESCE(em.areas, '[]'::jsonb)) AS area_item
                                WHERE area_item->>'area' IN ('default', '公共')
                                  AND COALESCE((area_item->>'enabled')::boolean, FALSE) = TRUE
                            )
                        )
                    )
                )
                """
                if has_tenant_mapping_table
                else """
                (
                    :bypass_tenant = TRUE
                    OR EXISTS (
                        SELECT 1
                        FROM jsonb_array_elements(COALESCE(em.areas, '[]'::jsonb)) AS area_item
                        WHERE area_item->>'area' = ANY(:legacy_area_candidates)
                          AND COALESCE((area_item->>'enabled')::boolean, FALSE) = TRUE
                    )
                    OR EXISTS (
                        SELECT 1
                        FROM jsonb_array_elements(COALESCE(em.areas, '[]'::jsonb)) AS area_item
                        WHERE area_item->>'area' IN ('default', '公共')
                          AND COALESCE((area_item->>'enabled')::boolean, FALSE) = TRUE
                    )
                )
                """
            )

            result = await session.execute(
                text(
                    f"""
                    SELECT
                        em.id,
                        em.name,
                        em.description,
                        em.path,
                        em.icon_path,
                        em.areas,
                        em.sort_order,
                        {menu_select_sql},
                        {tenant_select_sql},
                        COALESCE(
                            json_agg(
                                json_build_object(
                                    'id', dt.id,
                                    'name', dt.name,
                                    'code', dt.code
                                )
                                ORDER BY dt.sort_order ASC, dt.id ASC
                            ) FILTER (
                                WHERE dt.id IS NOT NULL
                                  AND dt.deleted_at IS NULL
                                  AND dt.is_enabled = TRUE
                            ),
                            '[]'::json
                        ) AS document_types
                    FROM leaudit_entry_modules em
                    LEFT JOIN leaudit_document_types dt
                        ON dt.entry_module_id = em.id
                    WHERE em.deleted_at IS NULL
                      AND em.is_enabled = TRUE
                      AND {tenant_scope_filter_sql}
                    GROUP BY
                        em.id,
                        em.name,
                        em.description,
                        em.path,
                        em.icon_path,
                        em.areas,
                        em.sort_order
                        {menu_group_by_sql}
                    ORDER BY em.sort_order ASC, em.id ASC
                    """
                ),
                {
                    "user_tenant_code": effective_tenant_code,
                    "legacy_area_candidates": legacy_area_candidates,
                    "bypass_tenant": bool(user_row["bypass_tenant"]),
                },
            )

            modules: list[HomeEntryModuleVO] = []
            for row in result.mappings().all():
                tenants: list[HomeEntryTenantVO] = []
                raw_tenants = row["tenants"]
                if isinstance(raw_tenants, list):
                    for item in raw_tenants:
                        if isinstance(item, dict) and item.get("tenant_code"):
                            tenants.append(
                                HomeEntryTenantVO(
                                    tenantCode=str(item["tenant_code"]),
                                    tenantName=item.get("tenant_name"),
                                    enabled=bool(item.get("enabled", False)),
                                    sortOrder=int(item.get("sort_order", 0)),
                                )
                            )
                if not tenants:
                    raw_areas = row["areas"]
                    if isinstance(raw_areas, list):
                        for index, area_item in enumerate(raw_areas, start=1):
                            if not isinstance(area_item, dict) or not area_item.get("area"):
                                continue
                            resolution = await self._resolveLegacyTenantValue(
                                RawValue=str(area_item.get("area") or ""),
                                Source="home_entry_legacy_area",
                            )
                            tenants.append(
                                HomeEntryTenantVO(
                                    tenantCode=resolution.tenant_code,
                                    tenantName=resolution.tenant_name,
                                    enabled=bool(area_item.get("enabled", False)),
                                    sortOrder=int(area_item.get("sort_order", index)),
                                )
                            )
                tenants.sort(key=lambda item: (item.sortOrder, item.tenantCode))

                areas: list[HomeEntryAreaVO] = [
                    HomeEntryAreaVO(
                        area=item.tenantName or item.tenantCode,
                        enabled=item.enabled,
                        sortOrder=item.sortOrder,
                    )
                    for item in tenants
                ]

                document_types: list[HomeEntryDocumentTypeVO] = []
                raw_document_types = row["document_types"]
                if isinstance(raw_document_types, list):
                    for document_type in raw_document_types:
                        if isinstance(document_type, dict) and document_type.get("id") is not None:
                            document_types.append(
                                HomeEntryDocumentTypeVO(
                                    id=int(document_type["id"]),
                                    name=str(document_type["name"]),
                                    code=document_type.get("code"),
                                )
                            )

                target_path = self._normalizeTargetPath(
                    RawPath=str(row["path"] or ""),
                    HasDocumentTypes=len(document_types) > 0,
                )
                if not target_path:
                    continue

                if not self._isAllowedTargetPath(target_path, allowed_paths):
                    continue

                requires_document_types = target_path not in {"/chat-with-llm/chat", "/cross-checking"}

                modules.append(
                    HomeEntryModuleVO(
                        id=int(row["id"]),
                        name=str(row["name"]),
                        description=row["description"],
                        targetPath=target_path,
                        routePath=target_path,
                        menuProfile=self._normalizeMenuProfile(row.get("menu_profile")),
                        features=self._parseFeatures(row.get("features"), row.get("menu_profile")),
                        tenantCode=effective_tenant_code or None,
                        iconPath=row["icon_path"],
                        sortOrder=int(row["sort_order"] or 0),
                        requiresDocumentTypes=requires_document_types,
                        areas=areas,
                        tenants=tenants,
                        documentTypes=document_types,
                    )
                )

            return modules

    async def GetDashboardStatistics(
        self,
        UserId: int,
        Today: str | None = None,
        TypeIds: list[int] | None = None,
        EntryModuleId: int | None = None,
    ) -> HomeDashboardStatisticsVO:
        """获取当前业务入口的首页统计卡片数据。"""
        today = date.fromisoformat(Today) if Today else date.today()
        current_month_start = today.replace(day=1)
        previous_month_end = current_month_start.fromordinal(current_month_start.toordinal() - 1)
        previous_month_start = previous_month_end.replace(day=1)
        normalized_type_ids = [int(typeId) for typeId in (TypeIds or []) if int(typeId) > 0]
        normalized_entry_module_id = int(EntryModuleId) if EntryModuleId and int(EntryModuleId) > 0 else None

        async def load_documents() -> list[Any]:
            page = 1
            documents: list[Any] = []
            while True:
                result = await self.DocumentService.ListDocuments(
                    CurrentUserId=UserId,
                    Page=page,
                    PageSize=100,
                    TypeIds=normalized_type_ids or None,
                    EntryModuleId=normalized_entry_module_id,
                )
                documents.extend(result.documents)
                total_pages = max(1, int(result.totalPages or 1))
                if page >= total_pages:
                    return documents
                page += 1

        def issue_count(Documents: list[Any]) -> int:
            return sum(max(0, int(document.failedCount or 0)) for document in Documents)

        def pass_rate(Documents: list[Any]) -> int:
            if not Documents:
                return 0
            passed_count = len([document for document in Documents if int(document.failedCount or 0) == 0])
            return round((passed_count / len(Documents)) * 100)

        def growth(Current: int, Previous: int) -> HomeDashboardGrowthVO:
            if Previous <= 0:
                return HomeDashboardGrowthVO(value=100 if Current > 0 else 0, isUp=Current >= Previous)
            return HomeDashboardGrowthVO(
                value=round(abs(((Current - Previous) / Previous) * 100)),
                isUp=Current >= Previous,
            )

        def document_date(Document: Any) -> date | None:
            raw_value = str(getattr(Document, "updatedAt", "") or "").strip()
            if not raw_value:
                return None
            normalized = raw_value.replace("Z", "+00:00")
            try:
                return datetime.fromisoformat(normalized).date()
            except ValueError:
                try:
                    return datetime.strptime(raw_value, "%Y-%m-%d %H:%M:%S").date()
                except ValueError:
                    return None

        def normalized_document_status(Document: Any) -> tuple[int, int, int, str, str]:
            audit_status = int(getattr(Document, "auditStatus", 0) or 0)
            passed_count = int(getattr(Document, "passedCount", 0) or 0)
            failed_count = int(getattr(Document, "failedCount", 0) or 0)
            run_status = str(getattr(Document, "runStatus", "") or "").strip().lower()
            result_status = str(getattr(Document, "resultStatus", "") or "").strip().lower()
            return audit_status, passed_count, failed_count, run_status, result_status

        def is_reviewed_document(Document: Any) -> bool:
            audit_status, passed_count, failed_count, run_status, result_status = normalized_document_status(Document)
            if audit_status in {-1, 1}:
                return True
            if passed_count > 0 or failed_count > 0:
                return True
            if result_status in {"pass", "fail", "partial", "review", "error"}:
                return True
            return run_status == "completed"

        def is_pending_document(Document: Any) -> bool:
            return not is_reviewed_document(Document)

        def in_range(Document: Any, DateFrom: date, DateTo: date) -> bool:
            current_date = document_date(Document)
            return current_date is not None and DateFrom <= current_date <= DateTo

        documents = await load_documents()
        today_documents = [document for document in documents if in_range(document, today, today)]
        current_month_documents = [document for document in documents if in_range(document, current_month_start, today)]
        previous_month_documents = [
            document for document in documents if in_range(document, previous_month_start, previous_month_end)
        ]
        current_reviewed_documents = [document for document in current_month_documents if is_reviewed_document(document)]
        previous_reviewed_documents = [document for document in previous_month_documents if is_reviewed_document(document)]
        current_pass_rate = pass_rate(current_reviewed_documents)
        previous_pass_rate = pass_rate(previous_reviewed_documents)
        current_issue_count = issue_count(current_reviewed_documents)
        previous_issue_count = issue_count(previous_reviewed_documents)

        return HomeDashboardStatisticsVO(
            todayPendingFiles=len([document for document in today_documents if is_pending_document(document)]),
            monthlyReviewedFiles=len(current_reviewed_documents),
            monthlyReviewGrowth=growth(len(current_reviewed_documents), len(previous_reviewed_documents)),
            monthlyPassRate=current_pass_rate,
            passRateGrowth=growth(current_pass_rate, previous_pass_rate),
            issuesDetected=current_issue_count,
            issuesGrowth=growth(current_issue_count, previous_issue_count),
        )

    async def _entry_module_tenant_table_exists(self) -> bool:
        if self._entry_module_tenant_table_exists_cache is not None:
            return self._entry_module_tenant_table_exists_cache
        async with GetAsyncSession() as session:
            exists = bool(
                (
                    await session.execute(
                        text(
                            """
                            SELECT EXISTS (
                                SELECT 1
                                FROM information_schema.tables
                                WHERE table_schema = current_schema()
                                  AND table_name = 'leaudit_entry_module_tenants'
                            )
                            """
                        )
                    )
                ).scalar_one()
            )
        self._entry_module_tenant_table_exists_cache = exists
        return exists

    async def _entry_module_menu_columns_exist(self) -> bool:
        if self._entry_module_menu_columns_exist_cache is not None:
            return self._entry_module_menu_columns_exist_cache
        async with GetAsyncSession() as session:
            count = int(
                (
                    await session.execute(
                        text(
                            """
                            SELECT COUNT(*)
                            FROM information_schema.columns
                            WHERE table_schema = current_schema()
                              AND table_name = 'leaudit_entry_modules'
                              AND column_name IN ('menu_profile', 'features')
                            """
                        )
                    )
                ).scalar_one()
            )
        self._entry_module_menu_columns_exist_cache = count == 2
        return self._entry_module_menu_columns_exist_cache

    @staticmethod
    def _entry_module_menu_select_sql(HasMenuColumns: bool) -> str:
        if HasMenuColumns:
            return "em.menu_profile, em.features"
        return "'document_review'::varchar AS menu_profile, '[]'::jsonb AS features"

    @classmethod
    def _normalizeMenuProfile(cls, MenuProfile: str | None) -> str:
        value = str(MenuProfile or "document_review").strip() or "document_review"
        if value not in cls._DEFAULT_FEATURES_BY_PROFILE:
            return "document_review"
        return value

    @classmethod
    def _parseFeatures(cls, RawFeatures: Any, MenuProfile: str | None) -> list[str]:
        menu_profile = cls._normalizeMenuProfile(MenuProfile)
        allowed_features = {
            "home",
            "documents",
            "upload",
            "rules",
            "rule_groups",
            "contract_template_search",
            "contract_template_list",
            "govdoc_audits",
            "govdoc_upload",
            "cross_checking",
            "cross_checking_upload",
            "cross_checking_list",
            "usage_stats",
        }
        if isinstance(RawFeatures, list):
            parsed = RawFeatures
        elif isinstance(RawFeatures, str) and RawFeatures.strip():
            try:
                parsed = json.loads(RawFeatures)
            except json.JSONDecodeError:
                parsed = []
        else:
            parsed = []
        normalized: list[str] = []
        for item in parsed:
            feature = str(item or "").strip()
            if menu_profile == "govdoc" and feature == "rule_groups":
                feature = "rules"
            if feature in allowed_features and feature not in normalized:
                normalized.append(feature)
        return normalized or list(cls._DEFAULT_FEATURES_BY_PROFILE[menu_profile])

    async def _resolveLegacyTenantValue(self, *, RawValue: str, Source: str) -> TenantResolution:
        resolution = await self.TenantResolver.Resolve(
            RawValue=RawValue,
            Source=Source,
        )
        if resolution.tenant_code:
            return resolution

        normalized = str(RawValue or "").strip()
        if normalized in {"", "default", "省级", "公共"}:
            public_resolution = await self.TenantResolver.Resolve(
                RawValue="",
                Source=Source,
            )
            if public_resolution.tenant_code:
                return public_resolution
            return TenantResolution(
                tenant_code="PUBLIC",
                tenant_name="公共",
                tenant_type="PUBLIC",
                raw_value=RawValue,
                normalized_value=normalized,
                source=Source,
                is_public=True,
            )
        if normalized == "省局":
            provincial_resolution = await self.TenantResolver.Resolve(RawValue="省局", Source=Source)
            if provincial_resolution.tenant_code:
                return provincial_resolution
            return TenantResolution(
                tenant_code="PROVINCIAL",
                tenant_name="省局",
                tenant_type="PROVINCIAL",
                raw_value=RawValue,
                normalized_value=normalized,
                source=Source,
                is_public=False,
            )
        return TenantResolution(
            tenant_code=normalized or None,
            tenant_name=normalized or None,
            tenant_type="LEGACY_AREA" if normalized else None,
            raw_value=RawValue,
            normalized_value=normalized,
            source=Source,
            is_public=False,
        )

    async def _loadAllowedPaths(self, UserId: int) -> set[str]:
        """加载当前用户在首页可点击的目标路径集合。"""
        routes_vo = await self.RbacService.GetCurrentUserRoutes(UserId=UserId)
        allowed_paths: set[str] = set()

        def collect(items) -> None:
            for item in items:
                allowed_paths.add(str(item.route_path or ""))
                if item.children:
                    collect(item.children)

        collect(routes_vo.routes)
        return {path for path in allowed_paths if path}

    def _isAllowedTargetPath(self, TargetPath: str, AllowedPaths: set[str]) -> bool:
        """判断首页目标路径是否被当前用户路由树覆盖。"""
        if TargetPath in self._DOCUMENT_ENTRY_TARGETS:
            return True

        if TargetPath in AllowedPaths:
            return True

        return any(TargetPath.startswith(f"{path}/") for path in AllowedPaths)

    def _normalizeTargetPath(self, RawPath: str, HasDocumentTypes: bool) -> str | None:
        """将首页入口跳转归一到当前最小可用路径集合。"""
        if HasDocumentTypes and (not RawPath or RawPath == "/home" or not RawPath.startswith("/")):
            return "/files/upload"

        if RawPath == "/contract-template/search" and HasDocumentTypes:
            return "/files/upload"

        if any(
            RawPath == enabled_path or RawPath.startswith(f"{enabled_path}/")
            for enabled_path in self._MINIMAL_ENABLED_TARGETS
        ):
            return RawPath

        if HasDocumentTypes:
            return "/files/upload"

        return None