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 (
    RootstockCreateSchema,
    RootstockOutSchema,
    RootstockQueryParam,
    RootstockUpdateSchema,
)
from .service import RootstockService

RootstockRouter = APIRouter(route_class=OperationLogRoute, prefix="/rootstock", tags=["砧木管理"])


@RootstockRouter.get("/detail/{id}", summary="获取砧木详情", response_model=ResponseSchema[RootstockOutSchema])
async def get_rootstock__detail_controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:rootstock:detail"]))],
    id: Annotated[int, Path(description="砧木ID")],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = RootstockService(auth, db)
    result_dict = await service.detail(id=id)
    return SuccessResponse(data=result_dict, msg="获取砧木详情成功")


@RootstockRouter.get("/list", summary="分页查询砧木", response_model=ResponseSchema[PageResultSchema[RootstockOutSchema]])
async def get_rootstock__list_controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:rootstock:query"]))],
    page: Annotated[PaginationQueryParam, Depends()],
    search: Annotated[RootstockQueryParam, Query()],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = RootstockService(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="查询砧木列表成功")


@RootstockRouter.get("/options", summary="砧木下拉选项")
async def get_rootstock__options_controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:rootstock:query"]))],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = RootstockService(auth, db)
    options = await service.list_options()
    return SuccessResponse(data=options, msg="获取砧木选项成功")


@RootstockRouter.post("/create", summary="创建砧木", response_model=ResponseSchema[RootstockOutSchema])
async def create_rootstock__controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:rootstock:create"]))],
    data: Annotated[RootstockCreateSchema, Body(description="创建参数")],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = RootstockService(auth, db)
    result_dict = await service.create(data=data)
    return SuccessResponse(data=result_dict, msg="创建砧木成功")


@RootstockRouter.put("/update/{id}", summary="修改砧木", response_model=ResponseSchema[RootstockOutSchema])
async def update_rootstock__controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:rootstock:update"]))],
    id: Annotated[int, Path(description="砧木ID")],
    data: Annotated[RootstockUpdateSchema, Body(description="修改参数")],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = RootstockService(auth, db)
    result_dict = await service.update(id=id, data=data)
    return SuccessResponse(data=result_dict, msg="修改砧木成功")


@RootstockRouter.delete("/delete", summary="删除砧木", response_model=ResponseSchema[None])
async def delete_rootstock__controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:rootstock:delete"]))],
    ids: Annotated[list[int], Body(description="ID列表")],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = RootstockService(auth, db)
    await service.delete(ids=ids)
    return SuccessResponse(msg="删除砧木成功")


@RootstockRouter.post("/export", summary="导出砧木")
async def export_rootstock__controller(
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:rootstock:export"]))],
    search: Annotated[RootstockQueryParam, Query()],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> StreamingResponse:
    service = RootstockService(auth, db)
    result_dict_list = await service.get_list(search=search)
    export_result = RootstockService.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')}"},
    )


@RootstockRouter.post("/import", summary="导入砧木", response_model=ResponseSchema[ImportResultSchema])
async def import_rootstock__controller(
    file: Annotated[UploadFile, File(description="导入文件")],
    auth: Annotated[AuthSchema, Depends(AuthPermission(["module_bre:rootstock:import"]))],
    db: Annotated[AsyncSession, Depends(db_getter)],
) -> JSONResponse:
    service = RootstockService(auth, db)
    batch_import_result = await service.batch_import(file=file, update_support=True)
    return SuccessResponse(data=batch_import_result, msg="导入砧木成功")


@RootstockRouter.post("/download/template", summary="获取砧木导入模板", dependencies=[Depends(AuthPermission(["module_bre:rootstock:download"]))])
async def download_rootstock__template_controller() -> StreamingResponse:
    import_template_result = RootstockService.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",
        },
    )