"""
费控制度成员联动同步工具

部门停用/员工解约时自动移除相关制度中的成员引用。
员工调部门/部门新增员工时自动创建本地额度记录。
"""

from app.api.v1.module_system.auth.schema import AuthSchema
from app.core.alipay import AlipayClient
from app.core.logger import log
from app.plugin.module_payment.expense.institution.crud import InstitutionCRUD


async def _sync_employee_quota(
    auth: AuthSchema, enterprise_id: str, employee_id: str, department_ids: list[str], is_add: bool
) -> None:
    """根据员工所属部门，同步本地额度记录

    扫描所有按部门模式的制度：
    - 匹配的部门 → 确保员工有额度记录（创建缺失的）
    - 不匹配的部门 → 删除该员工的额度记录（处理离部门场景）
    """
    if not employee_id:
        return

    from app.plugin.module_payment.expense.quota.model import QuotaModel
    from app.plugin.module_payment.expense.quota.enums import QuotaStatusEnum
    from sqlalchemy import insert, delete as sa_delete, select

    try:
        crud = InstitutionCRUD(auth)
        institutions = await crud.list(
            search={
                "enterprise_id": enterprise_id,
                "status__ne": "INSTITUTION_DELETE",
                "applicable_scope": "department",
            },
            order_by=[{"id": "desc"}],
        )
        if not institutions:
            return

        tenant_id = auth.user.tenant_id if auth.user else 1
        dept_id_set = set(department_ids)

        for inst in institutions:
            inst_id = inst.institution_id
            scope_owner_ids_str = getattr(inst, "scope_owner_id_list", None) or getattr(inst, "department_id", None)
            if not inst_id or not scope_owner_ids_str:
                continue

            # 解析制度的部门ID列表
            import json
            try:
                scope_ids = json.loads(scope_owner_ids_str) if isinstance(scope_owner_ids_str, str) else scope_owner_ids_str
            except (json.JSONDecodeError, TypeError):
                scope_ids = [str(scope_owner_ids_str)] if scope_owner_ids_str else []
            scope_ids = [str(s) for s in scope_ids]

            # 判断是否匹配
            matched = bool(scope_ids and dept_id_set.intersection(scope_ids))

            if matched:
                # 匹配 → 确保有额度记录
                check = select(QuotaModel).where(
                    QuotaModel.employee_id == employee_id,
                    QuotaModel.institution_id == inst_id,
                )
                existing = await auth.db.execute(check)
                if not existing.scalar_one_or_none():
                    stmt = insert(QuotaModel).values(
                        employee_id=employee_id,
                        institution_id=inst_id,
                        out_biz_no=f"scope_{inst_id}_{employee_id}",
                        total_amount=0,
                        available_amount=0,
                        status=QuotaStatusEnum.QUOTA_PENDING.value,
                        enterprise_id=enterprise_id,
                        tenant_id=tenant_id,
                    )
                    await auth.db.execute(stmt)
                    log.info(f"部门联动 - 新增员工额度: employee_id={employee_id}, institution_id={inst_id}")
            else:
                # 不匹配 → 删除该员工的额度记录
                if not is_add:
                    continue
                del_stmt = sa_delete(QuotaModel).where(
                    QuotaModel.employee_id == employee_id,
                    QuotaModel.institution_id == inst_id,
                )
                await auth.db.execute(del_stmt)
                log.info(f"部门联动 - 删除员工额度: employee_id={employee_id}, institution_id={inst_id}")

        await auth.db.flush()
    except Exception as e:
        log.error(f"部门联动同步额度失败（不影响主体操作）: {e}")


async def sync_employee_add_to_department_institutions(
    auth: AuthSchema,
    enterprise_id: str,
    employee_id: str,
    department_ids: list[str],
) -> None:
    """员工加入部门时，为引用该部门的制度创建本地额度记录"""
    await _sync_employee_quota(auth, enterprise_id, employee_id, department_ids, is_add=True)


async def sync_employee_remove_from_department_institutions(
    auth: AuthSchema,
    enterprise_id: str,
    employee_id: str,
    department_ids: list[str],
) -> None:
    """员工离开部门时，从引用该部门的制度中删除本地额度记录"""
    await _sync_employee_quota(auth, enterprise_id, employee_id, department_ids, is_add=False)


async def remove_department_from_institution_scopes(
    auth: AuthSchema,
    enterprise_id: str,
    department_id: str,
) -> None:
    """
    当部门被停用时，扫描所有引用该部门的制度，移除该部门

    此方法被 department/service.py 的停用方法调用
    """
    try:
        crud = InstitutionCRUD(auth)
        institutions = await crud.list(
            search={"enterprise_id": enterprise_id, "status__ne": "INSTITUTION_DELETE"},
            order_by=[{"id": "desc"}],
        )
        if not institutions:
            return

        for inst in institutions:
            inst_id = inst.institution_id
            if not inst_id:
                continue

            from .service import InstitutionScopeService

            await InstitutionScopeService.scope_modify_service(
                auth=auth,
                institution_id=inst_id,
                data={
                    "enterprise_id": enterprise_id,
                    "adapter_type": "EMPLOYEE_DEPARTMENT",
                    "delete_owner_id_list": [department_id],
                },
            )
            log.info(f"已从制度 {inst_id} 中移除停用部门 {department_id}")
    except Exception as e:
        log.error(f"移除部门失败（不影响主体操作）: {e}")


async def remove_employee_from_institution_scopes(
    auth: AuthSchema,
    enterprise_id: str,
    employee_id: str,
) -> None:
    """
    当员工被解约时，扫描所有按员工模式引用该员工的制度，移除该员工

    此方法被 employee/service.py 的删除方法调用
    """
    try:
        crud = InstitutionCRUD(auth)
        institutions = await crud.list(
            search={"enterprise_id": enterprise_id, "status__ne": "INSTITUTION_DELETE"},
            order_by=[{"id": "desc"}],
        )
        if not institutions:
            return

        for inst in institutions:
            inst_id = inst.institution_id
            if not inst_id:
                continue

            from .service import InstitutionScopeService

            await InstitutionScopeService.scope_modify_service(
                auth=auth,
                institution_id=inst_id,
                data={
                    "enterprise_id": enterprise_id,
                    "adapter_type": "EMPLOYEE_SELECT",
                    "delete_owner_id_list": [employee_id],
                },
            )
            log.info(f"已从制度 {inst_id} 中移除解约员工 {employee_id}")
    except Exception as e:
        log.error(f"移除员工失败（不影响主体操作）: {e}")