import urllib.parse
from typing import Annotated

from fastapi import APIRouter, Body, Depends, File, Path, Query, UploadFile
from fastapi.responses import JSONResponse, StreamingResponse
from sqlalchemy.ext.asyncio import AsyncSession

from app.common.response import ResponseSchema, StreamResponse, SuccessResponse
from app.core.base_schema import AuthSchema, PageResultSchema, PaginationQueryParam, ImportResultSchema
from app.core.dependencies import AuthPermission, db_getter
from app.core.router_class import OperationLogRoute
from app.utils.common_util import bytes2file_response

from .schema import (
    ObservationCreateSchema,
    ObservationOutSchema,
    ObservationQueryParam,
    ObservationUpdateSchema,
)
from .service import ObservationService

ObservationRouter = APIRouter(route_class=OperationLogRoute, prefix="/observation", tags=["通用观测"])


@ObservationRouter.get("/detail/{id}", summary="获取通用观测详情", response_model=ResponseSchema[ObservationOutSchema])
async def get_observation__detail_controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:observation:detail"]))],
    id: Annotated[int, Path(description="观测ID")],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = ObservationService(auth, db)
    result_dict = await service.detail(id=id)
    return SuccessResponse(data=result_dict, msg="获取通用观测详情成功")


@ObservationRouter.get("/list", summary="分页查询通用观测", response_model=ResponseSchema[PageResultSchema[ObservationOutSchema]])
async def get_observation__list_controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:observation:query"]))],
    page: Annotated[PaginationQueryParam, Depends()],
    search: Annotated[ObservationQueryParam, Query()],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = ObservationService(auth, db)
    result_dict = await service.page(
        page_no=page.page_no,
        page_size=page.page_size,
        search=search,
        order_by=page.order_by,
    )
    return SuccessResponse(data=result_dict, msg="查询通用观测列表成功")


@ObservationRouter.get("/options", summary="通用观测下拉选项")
async def get_observation__options_controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:observation:query"]))],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = ObservationService(auth, db)
    options = await service.list_options()
    return SuccessResponse(data=options, msg="获取通用观测选项成功")


@ObservationRouter.post("/create", summary="创建通用观测", response_model=ResponseSchema[ObservationOutSchema])
async def create_observation__controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:observation:create"]))],
    data: Annotated[ObservationCreateSchema, Body(description="创建参数")],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = ObservationService(auth, db)
    result_dict = await service.create(data=data)
    return SuccessResponse(data=result_dict, msg="创建通用观测成功")


@ObservationRouter.put("/update/{id}", summary="修改通用观测", response_model=ResponseSchema[ObservationOutSchema])
async def update_observation__controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:observation:update"]))],
    id: Annotated[int, Path(description="观测ID")],
    data: Annotated[ObservationUpdateSchema, Body(description="修改参数")],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = ObservationService(auth, db)
    result_dict = await service.update(id=id, data=data)
    return SuccessResponse(data=result_dict, msg="修改通用观测成功")


@ObservationRouter.delete("/delete", summary="删除通用观测", response_model=ResponseSchema[None])
async def delete_observation__controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:observation:delete"]))],
    ids: Annotated[list[int], Body(description="ID列表")],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = ObservationService(auth, db)
    await service.delete(ids=ids)
    return SuccessResponse(msg="删除通用观测成功")


@ObservationRouter.post("/export", summary="导出通用观测")
async def export_observation__controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:observation:export"]))],
    search: Annotated[ObservationQueryParam, Query()],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> StreamingResponse:
    service = ObservationService(auth, db)
    result_dict_list = await service.get_list(search=search)
    export_result = ObservationService.batch_export(obj_list=[item.model_dump() for item in result_dict_list])
    return StreamResponse(
        data=bytes2file_response(export_result),
        media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
        headers={"Content-Disposition": f"attachment; filename={urllib.parse.quote('通用观测.xlsx')}"},
    )


@ObservationRouter.post("/import", summary="导入通用观测", response_model=ResponseSchema[ImportResultSchema])
async def import_observation__controller(
    file: Annotated[UploadFile, File(description="导入文件")],
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:observation:import"]))],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = ObservationService(auth, db)
    batch_import_result = await service.batch_import(file=file, update_support=True)
    return SuccessResponse(data=batch_import_result, msg="导入通用观测成功")


@ObservationRouter.post("/download/template", summary="获取通用观测导入模板", dependencies=[Depends(AuthPermission(["module_bre:observation:download"]))])
async def download_observation__template_controller() -> StreamingResponse:
    import_template_result = ObservationService.import_template_download()
    return StreamResponse(
        data=bytes2file_response(import_template_result),
        media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
        headers={
            "Content-Disposition": f"attachment; filename={urllib.parse.quote('通用观测导入模板.xlsx')}",
            "Access-Control-Expose-Headers": "Content-Disposition",
        },
    )