#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
电子签章API接口
"""
from typing import Optional, List

from fastapi import APIRouter, Depends, HTTPException, Query, Request
from sqlalchemy.ext.asyncio import AsyncSession

from app.database import get_db
from app.config import settings
from app.base_schema import PaginatedResponse, ResponseModel

from online_dev.electronic_seal.schema import (
    ElectronicSealCreate, ElectronicSealUpdate, ElectronicSealOut, SealUsageLogOut
)
from online_dev.electronic_seal.service import ElectronicSealService, SealUsageLogService

router = APIRouter(prefix="/electronic-seal", tags=["电子签章"])


@router.get("", response_model=PaginatedResponse[ElectronicSealOut], summary="获取签章列表")
async def get_seal_list(
    page: int = Query(default=1, ge=1),
    page_size: int = Query(default=settings.PAGE_SIZE, ge=1, le=settings.PAGE_MAX_SIZE, alias="pageSize"),
    seal_type: Optional[str] = Query(default=None, alias="sealType"),
    status: Optional[str] = Query(default=None),
    keyword: Optional[str] = Query(default=None),
    db: AsyncSession = Depends(get_db),
):
    """获取签章列表"""
    items, total = await ElectronicSealService.get_list(
        db,
        page=page,
        page_size=page_size,
        seal_type=seal_type,
        status=status,
        keyword=keyword,
    )
    return PaginatedResponse(items=items, total=total)


@router.get("/available", response_model=List[ElectronicSealOut], summary="获取可用签章")
async def get_available_seals(
    template_id: Optional[str] = Query(default=None, alias="templateId"),
    db: AsyncSession = Depends(get_db),
    request: Request = None,
):
    """获取当前用户可用的签章"""
    # 从请求中获取用户信息
    user_id = getattr(request.state, "user_id", "") if request else ""
    dept_id = getattr(request.state, "dept_id", None) if request else None
    role_ids = getattr(request.state, "role_ids", None) if request else None

    seals = await ElectronicSealService.get_available_seals(
        db,
        user_id=user_id,
        dept_id=dept_id,
        role_ids=role_ids,
        template_id=template_id,
    )
    return seals


@router.post("", response_model=ElectronicSealOut, summary="创建签章")
async def create_seal(
    data: ElectronicSealCreate,
    db: AsyncSession = Depends(get_db),
):
    """创建电子签章"""
    seal = await ElectronicSealService.create(db, data)
    return seal


@router.get("/{seal_id}", response_model=ElectronicSealOut, summary="获取签章详情")
async def get_seal(
    seal_id: str,
    db: AsyncSession = Depends(get_db),
):
    """获取签章详情"""
    seal = await ElectronicSealService.get_by_id(db, seal_id)
    if not seal:
        raise HTTPException(status_code=404, detail="签章不存在")
    return seal


@router.put("/{seal_id}", response_model=ElectronicSealOut, summary="更新签章")
async def update_seal(
    seal_id: str,
    data: ElectronicSealUpdate,
    db: AsyncSession = Depends(get_db),
):
    """更新签章"""
    seal = await ElectronicSealService.update(db, seal_id, data)
    if not seal:
        raise HTTPException(status_code=404, detail="签章不存在")
    return seal


@router.delete("/{seal_id}", response_model=ResponseModel, summary="删除签章")
async def delete_seal(
    seal_id: str,
    db: AsyncSession = Depends(get_db),
):
    """删除签章"""
    seal = await ElectronicSealService.get_by_id(db, seal_id)
    if not seal:
        raise HTTPException(status_code=404, detail="签章不存在")

    await ElectronicSealService.delete(db, seal_id)
    return ResponseModel(message="删除成功")


@router.post("/{seal_id}/enable", response_model=ElectronicSealOut, summary="启用签章")
async def enable_seal(
    seal_id: str,
    db: AsyncSession = Depends(get_db),
):
    """启用签章"""
    seal = await ElectronicSealService.get_by_id(db, seal_id)
    if not seal:
        raise HTTPException(status_code=404, detail="签章不存在")

    seal = await ElectronicSealService.update(
        db, seal_id, ElectronicSealUpdate(status="active")
    )
    return seal


@router.post("/{seal_id}/disable", response_model=ElectronicSealOut, summary="禁用签章")
async def disable_seal(
    seal_id: str,
    db: AsyncSession = Depends(get_db),
):
    """禁用签章"""
    seal = await ElectronicSealService.get_by_id(db, seal_id)
    if not seal:
        raise HTTPException(status_code=404, detail="签章不存在")

    seal = await ElectronicSealService.update(
        db, seal_id, ElectronicSealUpdate(status="disabled")
    )
    return seal


@router.get("/{seal_id}/logs", response_model=PaginatedResponse[SealUsageLogOut], summary="获取签章使用记录")
async def get_seal_usage_logs(
    seal_id: str,
    page: int = Query(default=1, ge=1),
    page_size: int = Query(default=settings.PAGE_SIZE, ge=1, le=settings.PAGE_MAX_SIZE, alias="pageSize"),
    db: AsyncSession = Depends(get_db),
):
    """获取签章的使用记录"""
    seal = await ElectronicSealService.get_by_id(db, seal_id)
    if not seal:
        raise HTTPException(status_code=404, detail="签章不存在")

    items, total = await SealUsageLogService.get_logs_by_seal(
        db, seal_id, page=page, page_size=page_size
    )
    return PaginatedResponse(items=items, total=total)