#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
合同管理服务（异步版本）
"""
import secrets
import uuid
import logging
from datetime import datetime, timedelta
from typing import Any, Dict, List, Optional, Tuple

from sqlalchemy import select, func, and_
from sqlalchemy.ext.asyncio import AsyncSession

from online_dev.contract.model import (
    ContractInstance,
    ContractLog,
    ContractSignature,
    ContractSignToken,
    ContractTemplate,
)

logger = logging.getLogger(__name__)


class ContractTemplateService:
    """合同模板服务"""

    @staticmethod
    async def get_list(
            db: AsyncSession,
            page: int = 1,
            page_size: int = 20,
            name: str = None,
            code: str = None,
            category: str = None,
            status: str = None,
    ) -> Dict[str, Any]:
        """获取模板列表"""
        conditions = [ContractTemplate.is_deleted == False]

        if name:
            conditions.append(ContractTemplate.name.ilike(f"%{name}%"))
        if code:
            conditions.append(ContractTemplate.code.ilike(f"%{code}%"))
        if category:
            conditions.append(ContractTemplate.category == category)
        if status:
            conditions.append(ContractTemplate.status == status)

        # 获取总数
        count_stmt = select(func.count(ContractTemplate.id)).where(and_(*conditions))
        total_result = await db.execute(count_stmt)
        total = total_result.scalar() or 0

        # 获取列表
        offset = (page - 1) * page_size
        stmt = select(ContractTemplate).where(and_(*conditions)).order_by(
            ContractTemplate.sort, ContractTemplate.sys_create_datetime.desc()
        ).offset(offset).limit(page_size)

        result = await db.execute(stmt)
        items = list(result.scalars().all())

        return {
            "items": items,
            "total": total,
            "page": page,
            "pageSize": page_size,
        }

    @staticmethod
    async def get_by_id(db: AsyncSession, template_id: str) -> Optional[ContractTemplate]:
        """根据ID获取模板"""
        stmt = select(ContractTemplate).where(
            ContractTemplate.id == template_id,
            ContractTemplate.is_deleted == False
        )
        result = await db.execute(stmt)
        return result.scalar_one_or_none()

    @staticmethod
    async def get_by_code(db: AsyncSession, code: str) -> Optional[ContractTemplate]:
        """根据编码获取模板"""
        stmt = select(ContractTemplate).where(
            ContractTemplate.code == code,
            ContractTemplate.is_deleted == False
        )
        result = await db.execute(stmt)
        return result.scalar_one_or_none()

    @staticmethod
    async def create(
            db: AsyncSession,
            name: str,
            code: str,
            category: str = "",
            description: str = "",
            template_config: Dict = None,
            creator_id: str = None,
    ) -> ContractTemplate:
        """创建模板"""
        template = ContractTemplate(
            name=name,
            code=code,
            category=category,
            description=description,
            template_config=template_config or {},
            sys_creator_id=creator_id,
            sys_modifier_id=creator_id,
        )
        db.add(template)
        await db.commit()
        await db.refresh(template)
        return template

    @staticmethod
    async def update(
            db: AsyncSession,
            template: ContractTemplate,
            name: str = None,
            category: str = None,
            description: str = None,
            template_config: Dict = None,
            thumbnail: str = None,
    ) -> ContractTemplate:
        """更新模板"""
        if name is not None:
            template.name = name
        if category is not None:
            template.category = category
        if description is not None:
            template.description = description
        if template_config is not None:
            template.template_config = template_config
        if thumbnail is not None:
            template.thumbnail = thumbnail

        await db.commit()
        await db.refresh(template)
        return template

    @staticmethod
    async def delete(db: AsyncSession, template: ContractTemplate):
        """删除模板（软删除）"""
        template.is_deleted = True
        await db.commit()

    @staticmethod
    async def publish(db: AsyncSession, template: ContractTemplate) -> ContractTemplate:
        """发布模板"""
        template.status = "published"
        template.version += 1
        await db.commit()
        await db.refresh(template)
        return template

    @staticmethod
    async def disable(db: AsyncSession, template: ContractTemplate) -> ContractTemplate:
        """停用模板"""
        template.status = "disabled"
        await db.commit()
        await db.refresh(template)
        return template

    @staticmethod
    async def copy(
            db: AsyncSession,
            template: ContractTemplate,
            new_code: str,
            new_name: str = None,
            creator_id: str = None,
    ) -> ContractTemplate:
        """复制模板"""
        new_template = ContractTemplate(
            name=new_name or f"{template.name}_副本",
            code=new_code,
            category=template.category,
            description=template.description,
            template_config=template.template_config,
            thumbnail=template.thumbnail,
            status="draft",
            version=1,
            sys_creator_id=creator_id,
            sys_modifier_id=creator_id,
        )
        db.add(new_template)
        await db.commit()
        await db.refresh(new_template)
        return new_template

    @staticmethod
    async def get_categories(db: AsyncSession) -> List[str]:
        """获取所有分类"""
        stmt = select(ContractTemplate.category).where(
            ContractTemplate.is_deleted == False,
            ContractTemplate.category != ""
        ).distinct()

        result = await db.execute(stmt)
        return [row[0] for row in result.fetchall()]


class ContractInstanceService:
    """合同实例服务"""

    @staticmethod
    def generate_contract_no() -> str:
        """生成合同编号"""
        now = datetime.now()
        prefix = now.strftime("JZ%Y%m%d")
        suffix = uuid.uuid4().hex[:6].upper()
        return f"{prefix}{suffix}"

    @staticmethod
    async def check_contract_no_exists(
            db: AsyncSession,
            contract_no: str,
            exclude_id: str = None
    ) -> bool:
        """检查合同编号是否已存在"""
        conditions = [
            ContractInstance.contract_no == contract_no,
            ContractInstance.is_deleted == False
        ]
        if exclude_id:
            conditions.append(ContractInstance.id != exclude_id)

        stmt = select(func.count(ContractInstance.id)).where(and_(*conditions))
        result = await db.execute(stmt)
        count = result.scalar() or 0
        return count > 0

    @staticmethod
    async def get_list(
            db: AsyncSession,
            page: int = 1,
            page_size: int = 20,
            title: str = None,
            contract_no: str = None,
            status: str = None,
            template_id: str = None,
            creator_id: str = None,
    ) -> Dict[str, Any]:
        """获取合同列表"""
        conditions = [ContractInstance.is_deleted == False]

        if title:
            conditions.append(ContractInstance.title.ilike(f"%{title}%"))
        if contract_no:
            conditions.append(ContractInstance.contract_no.ilike(f"%{contract_no}%"))
        if status:
            conditions.append(ContractInstance.status == status)
        if template_id:
            conditions.append(ContractInstance.template_id == template_id)
        if creator_id:
            conditions.append(ContractInstance.creator_id == creator_id)

        # 获取总数
        count_stmt = select(func.count(ContractInstance.id)).where(and_(*conditions))
        total_result = await db.execute(count_stmt)
        total = total_result.scalar() or 0

        # 获取列表
        offset = (page - 1) * page_size
        stmt = select(ContractInstance).where(and_(*conditions)).order_by(
            ContractInstance.sys_create_datetime.desc()
        ).offset(offset).limit(page_size)

        result = await db.execute(stmt)
        items = list(result.scalars().all())

        return {
            "items": items,
            "total": total,
            "page": page,
            "pageSize": page_size,
        }

    @staticmethod
    async def get_by_id(db: AsyncSession, instance_id: str) -> Optional[ContractInstance]:
        """根据ID获取合同"""
        stmt = select(ContractInstance).where(
            ContractInstance.id == instance_id,
            ContractInstance.is_deleted == False
        )
        result = await db.execute(stmt)
        return result.scalar_one_or_none()

    @staticmethod
    async def create(
            db: AsyncSession,
            template_id: str,
            title: str,
            creator_id: str,
            variable_data: Dict = None,
            contract_no: str = None,
    ) -> ContractInstance:
        """创建合同实例"""
        # 获取模板
        template = await ContractTemplateService.get_by_id(db, template_id)
        if not template:
            raise ValueError(f"模板不存在: {template_id}")

        # 如果没有提供合同编号，自动生成
        if not contract_no:
            contract_no = ContractInstanceService.generate_contract_no()

        # 检查合同编号唯一性
        if await ContractInstanceService.check_contract_no_exists(db, contract_no):
            raise ValueError(f"合同编号 {contract_no} 已存在")

        instance = ContractInstance(
            template_id=template_id,
            contract_no=contract_no,
            title=title,
            creator_id=creator_id,
            contract_config=template.template_config,
            variable_data=variable_data or {},
            created_at=datetime.now(),
            sys_creator_id=creator_id,
            sys_modifier_id=creator_id,
        )
        db.add(instance)
        await db.flush()

        # 记录日志
        log = ContractLog(
            contract_id=instance.id,
            action="create",
            operator_id=creator_id,
            sys_creator_id=creator_id,
        )
        db.add(log)

        await db.commit()
        await db.refresh(instance)
        return instance

    @staticmethod
    async def update(
            db: AsyncSession,
            instance: ContractInstance,
            title: str = None,
            variable_data: Dict = None,
            signature_data: Dict = None,
            operator_id: str = None,
    ) -> ContractInstance:
        """更新合同"""
        if title is not None:
            instance.title = title
        if variable_data is not None:
            instance.variable_data = variable_data
        if signature_data is not None:
            instance.signature_data = signature_data

        instance.sys_modifier_id = operator_id

        # 记录日志
        if operator_id:
            log = ContractLog(
                contract_id=instance.id,
                action="update",
                operator_id=operator_id,
                sys_creator_id=operator_id,
            )
            db.add(log)

        await db.commit()
        await db.refresh(instance)
        return instance

    @staticmethod
    async def submit(
            db: AsyncSession,
            instance: ContractInstance,
            operator_id: str
    ) -> ContractInstance:
        """提交合同（进入待签署状态）"""
        instance.status = "pending"
        instance.sys_modifier_id = operator_id

        log = ContractLog(
            contract_id=instance.id,
            action="submit",
            operator_id=operator_id,
            sys_creator_id=operator_id,
        )
        db.add(log)

        await db.commit()
        await db.refresh(instance)
        return instance

    @staticmethod
    async def complete(
            db: AsyncSession,
            instance: ContractInstance,
            operator_id: str
    ) -> ContractInstance:
        """完成合同"""
        instance.status = "completed"
        instance.completed_at = datetime.now()
        instance.sys_modifier_id = operator_id

        log = ContractLog(
            contract_id=instance.id,
            action="complete",
            operator_id=operator_id,
            sys_creator_id=operator_id,
        )
        db.add(log)

        await db.commit()
        await db.refresh(instance)
        return instance

    @staticmethod
    async def cancel(
            db: AsyncSession,
            instance: ContractInstance,
            operator_id: str,
            comment: str = ""
    ) -> ContractInstance:
        """取消合同"""
        instance.status = "canceled"
        instance.sys_modifier_id = operator_id

        log = ContractLog(
            contract_id=instance.id,
            action="cancel",
            operator_id=operator_id,
            comment=comment,
            sys_creator_id=operator_id,
        )
        db.add(log)

        await db.commit()
        await db.refresh(instance)
        return instance

    @staticmethod
    async def delete(db: AsyncSession, instance: ContractInstance):
        """删除合同（软删除）"""
        instance.is_deleted = True
        await db.commit()

    @staticmethod
    async def get_logs(db: AsyncSession, instance_id: str) -> List[ContractLog]:
        """获取合同日志"""
        stmt = select(ContractLog).where(
            ContractLog.contract_id == instance_id
        ).order_by(ContractLog.sys_create_datetime)

        result = await db.execute(stmt)
        return list(result.scalars().all())


class ContractSignatureService:
    """合同签署服务"""

    @staticmethod
    async def sign(
            db: AsyncSession,
            instance: ContractInstance,
            element_id: str,
            signature_image: str,
            signer_id: str,
            signer_name: str = "",
            sign_ip: str = "",
            sign_device: str = "",
    ) -> ContractSignature:
        """签署合同"""
        # 查找元素信息
        element = None
        for el in instance.contract_config.get("elements", []):
            if el.get("id") == element_id:
                element = el
                break

        if not element:
            raise ValueError("签署区域不存在")

        # 获取签署方信息
        signature_config = element.get("signature", {})
        party_type = signature_config.get("partyType", "party_a")
        party_label = signature_config.get("partyLabel", "")
        sign_type = "seal" if element.get("type") == "seal-zone" else "signature"

        # 查找是否已存在签署记录
        stmt = select(ContractSignature).where(
            ContractSignature.contract_id == instance.id,
            ContractSignature.element_id == element_id
        )
        result = await db.execute(stmt)
        existing = result.scalar_one_or_none()

        if existing:
            # 更新现有记录
            existing.party_type = party_type
            existing.party_label = party_label
            existing.sign_type = sign_type
            existing.signer_id = signer_id
            existing.signer_name = signer_name
            existing.signature_image = signature_image
            existing.status = "signed"
            existing.signed_at = datetime.now()
            existing.sign_ip = sign_ip
            existing.sign_device = sign_device
            signature = existing
        else:
            # 创建新记录
            signature = ContractSignature(
                contract_id=instance.id,
                element_id=element_id,
                party_type=party_type,
                party_label=party_label,
                sign_type=sign_type,
                signer_id=signer_id,
                signer_name=signer_name,
                signature_image=signature_image,
                status="signed",
                signed_at=datetime.now(),
                sign_ip=sign_ip,
                sign_device=sign_device,
                sys_creator_id=signer_id,
            )
            db.add(signature)

        # 更新合同签署数据
        signature_data = instance.signature_data or {}
        signature_data[element_id] = signature_image
        instance.signature_data = signature_data

        # 检查是否所有必须签署区域都已签署
        all_signed = await ContractSignatureService.check_all_signed(instance)
        if all_signed and instance.status == "pending":
            instance.status = "signing"

        # 记录日志
        log = ContractLog(
            contract_id=instance.id,
            action="sign",
            operator_id=signer_id,
            comment=f"{party_label}签署",
            extra_data={"element_id": element_id},
            ip_address=sign_ip,
            sys_creator_id=signer_id,
        )
        db.add(log)

        await db.commit()
        await db.refresh(signature)
        return signature

    @staticmethod
    async def check_all_signed(instance: ContractInstance) -> bool:
        """检查是否所有必须签署区域都已签署"""
        elements = instance.contract_config.get("elements", [])
        signature_data = instance.signature_data or {}

        for element in elements:
            if element.get("type") in ["signature-zone", "seal-zone"]:
                signature_config = element.get("signature", {})
                if signature_config.get("required", True):
                    if element.get("id") not in signature_data:
                        return False

        return True

    @staticmethod
    async def get_signatures(db: AsyncSession, instance_id: str) -> List[ContractSignature]:
        """获取合同签署记录"""
        stmt = select(ContractSignature).where(
            ContractSignature.contract_id == instance_id
        ).order_by(ContractSignature.sys_create_datetime)

        result = await db.execute(stmt)
        return list(result.scalars().all())


class MobileSignService:
    """移动端签署服务"""

    @staticmethod
    async def create_sign_token(
            db: AsyncSession,
            instance: ContractInstance,
            party_type: str = "party_a",
            signer_name: str = "",
            expire_minutes: int = 30,
    ) -> ContractSignToken:
        """创建签署令牌"""
        # 生成随机令牌
        token = secrets.token_urlsafe(32)

        # 计算过期时间
        expired_at = datetime.now() + timedelta(minutes=expire_minutes)

        # 创建令牌记录
        sign_token = ContractSignToken(
            contract_id=instance.id,
            token=token,
            party_type=party_type,
            signer_name=signer_name,
            expired_at=expired_at,
        )
        db.add(sign_token)
        await db.commit()
        await db.refresh(sign_token)

        return sign_token

    @staticmethod
    async def get_by_token(db: AsyncSession, token: str) -> Optional[ContractSignToken]:
        """根据令牌获取签署令牌"""
        stmt = select(ContractSignToken).where(
            ContractSignToken.token == token,
            ContractSignToken.is_used == False
        )
        result = await db.execute(stmt)
        return result.scalar_one_or_none()

    @staticmethod
    def validate_token(sign_token: ContractSignToken) -> Tuple[bool, str]:
        """验证令牌有效性"""
        if sign_token.is_used:
            return False, "该签署链接已被使用"

        if sign_token.expired_at < datetime.now():
            return False, "该签署链接已过期"

        return True, ""

    @staticmethod
    async def mobile_sign(
            db: AsyncSession,
            sign_token: ContractSignToken,
            instance: ContractInstance,
            element_id: str,
            signature_image: str,
            signer_name: str = "",
            sign_ip: str = "",
            sign_device: str = "",
    ) -> ContractSignature:
        """移动端签署"""
        # 查找元素信息
        element = None
        for el in instance.contract_config.get("elements", []):
            if el.get("id") == element_id:
                element = el
                break

        if not element:
            raise ValueError("签署区域不存在")

        # 获取签署方信息
        signature_config = element.get("signature", {})
        party_type = signature_config.get("partyType", "party_a")
        party_label = signature_config.get("partyLabel", "")
        sign_type = "seal" if element.get("type") == "seal-zone" else "signature"

        # 使用令牌中的签署人姓名（如果提供）
        final_signer_name = signer_name or sign_token.signer_name

        # 截断设备信息，避免超出数据库字段长度
        device_info = (sign_device + " (Mobile)")[:200] if sign_device else "Mobile"

        # 查找是否已存在签署记录
        stmt = select(ContractSignature).where(
            ContractSignature.contract_id == instance.id,
            ContractSignature.element_id == element_id
        )
        result = await db.execute(stmt)
        existing = result.scalar_one_or_none()

        if existing:
            # 更新现有记录
            existing.party_type = party_type
            existing.party_label = party_label
            existing.sign_type = sign_type
            existing.signer_id = None
            existing.signer_name = final_signer_name
            existing.signature_image = signature_image
            existing.status = "signed"
            existing.signed_at = datetime.now()
            existing.sign_ip = sign_ip
            existing.sign_device = device_info
            signature = existing
        else:
            # 创建新记录
            signature = ContractSignature(
                contract_id=instance.id,
                element_id=element_id,
                party_type=party_type,
                party_label=party_label,
                sign_type=sign_type,
                signer_id=None,
                signer_name=final_signer_name,
                signature_image=signature_image,
                status="signed",
                signed_at=datetime.now(),
                sign_ip=sign_ip,
                sign_device=device_info,
            )
            db.add(signature)

        # 更新合同签署数据
        signature_data = instance.signature_data or {}
        signature_data[element_id] = signature_image
        instance.signature_data = signature_data

        # 检查是否所有必须签署区域都已签署
        all_signed = await ContractSignatureService.check_all_signed(instance)
        if all_signed and instance.status == "pending":
            instance.status = "signing"

        # 标记令牌已使用
        sign_token.is_used = True
        sign_token.used_at = datetime.now()

        # 记录日志
        log = ContractLog(
            contract_id=instance.id,
            action="sign",
            operator_id=instance.creator_id,
            comment=f"{party_label}通过手机签署 (签署人: {final_signer_name})",
            extra_data={"element_id": element_id, "mobile": True},
            ip_address=sign_ip,
            sys_creator_id=instance.creator_id,
        )
        db.add(log)

        await db.commit()
        await db.refresh(signature)
        return signature