from datetime import datetime
from typing import Annotated

from fastapi import Path, Query, Request, Response
from sqlalchemy.ext.asyncio import AsyncSession

from common.annotation.log_annotation import Log
from common.aspect.db_seesion import DBSessionDependency
from common.aspect.interface_auth import UserInterfaceAuthDependency
from common.aspect.pre_auth import CurrentUserDependency, PreAuthDependency
from common.enums import BusinessType
from common.router import APIRouterPro
from common.vo import DataResponseModel, PageResponseModel, ResponseBaseModel
from module_admin.entity.vo.user_vo import CurrentUserModel
from module_business.dependency.test_batch_dependency import TestBatchScopeDependency
from module_business.domain.test_batch_scope import TestBatchScope
from module_business.entity.vo.master_vo import (
    BusinessUserOptionModel,
    DeleteSiteModel,
    SiteModel,
    SitePageQueryModel,
    UserAssignModel,
)
from module_business.service.master_service import MasterService
from module_business.service.pallet_service import PalletService
from utils.response_util import ResponseUtil

ASSIGN_LOG = Log
ASSIGN_CURRENT_USER = CurrentUserDependency

site_controller = APIRouterPro(
    prefix='/master/site', tags=['基础资料-客户现场管理'], dependencies=[PreAuthDependency()]
)
site_user_controller = APIRouterPro(
    prefix='/master/site', tags=['基础资料-客户现场用户分配'], dependencies=[PreAuthDependency()]
)


@site_user_controller.get(
    '/{site_id}/users',
    summary='获取客户现场可分配用户接口',
    description='获取启用且未删除的用户及客户现场分配状态',
    response_model=DataResponseModel[list[BusinessUserOptionModel]],
    dependencies=[UserInterfaceAuthDependency('master:site:assign')],
)
async def get_master_site_users(
    request: Request,
    site_id: Annotated[int, Path(gt=0, description='客户现场ID')],
    query_db: Annotated[AsyncSession, DBSessionDependency()],
    scope: Annotated[TestBatchScope, TestBatchScopeDependency()],
) -> Response:
    users = await PalletService.list_site_users(query_db, site_id, scope)
    return ResponseUtil.success(data=users)


@site_user_controller.put(
    '/{site_id}/users',
    summary='分配客户现场用户接口',
    description='完整替换客户现场的用户关联',
    response_model=ResponseBaseModel,
    dependencies=[UserInterfaceAuthDependency('master:site:assign')],
)
@ASSIGN_LOG(title='客户现场用户分配', business_type=BusinessType.GRANT)
async def assign_master_site_users(
    request: Request,
    site_id: Annotated[int, Path(gt=0, description='客户现场ID')],
    assignment: UserAssignModel,
    query_db: Annotated[AsyncSession, DBSessionDependency()],
    current_user: Annotated[CurrentUserModel, ASSIGN_CURRENT_USER()],
    scope: Annotated[TestBatchScope, TestBatchScopeDependency(write=True)],
) -> Response:
    result = await PalletService.assign_site_users(query_db, site_id, assignment, current_user, scope)
    return ResponseUtil.success(msg=result.message)


@site_controller.get(
    '/list',
    summary='获取客户现场分页列表接口',
    description='用于获取客户现场分页列表',
    response_model=PageResponseModel[SiteModel],
    dependencies=[UserInterfaceAuthDependency('master:site:list')],
)
async def get_master_site_list(
    request: Request,
    site_page_query: Annotated[SitePageQueryModel, Query()],
    query_db: Annotated[AsyncSession, DBSessionDependency()],
    scope: Annotated[TestBatchScope, TestBatchScopeDependency()],
) -> Response:
    site_page_query_result = await MasterService.list_site(query_db, site_page_query, scope, is_page=True)

    return ResponseUtil.success(model_content=site_page_query_result)


@site_controller.get(
    '/{site_id}',
    summary='获取客户现场详情接口',
    description='用于获取指定客户现场的详细信息',
    response_model=DataResponseModel[SiteModel],
    dependencies=[UserInterfaceAuthDependency('master:site:query')],
)
async def query_detail_master_site(
    request: Request,
    site_id: Annotated[int, Path(gt=0, description='客户现场ID')],
    query_db: Annotated[AsyncSession, DBSessionDependency()],
    scope: Annotated[TestBatchScope, TestBatchScopeDependency()],
) -> Response:
    site_detail_result = await MasterService.detail_site(query_db, site_id, scope)

    return ResponseUtil.success(data=site_detail_result)


@site_controller.post(
    '',
    summary='新增客户现场接口',
    description='用于新增客户现场',
    response_model=ResponseBaseModel,
    dependencies=[UserInterfaceAuthDependency('master:site:add')],
)
@Log(title='客户现场管理', business_type=BusinessType.INSERT)
async def add_master_site(
    request: Request,
    add_site: SiteModel,
    query_db: Annotated[AsyncSession, DBSessionDependency()],
    current_user: Annotated[CurrentUserModel, CurrentUserDependency()],
    scope: Annotated[TestBatchScope, TestBatchScopeDependency(write=True)],
) -> Response:
    current_time = datetime.now()
    add_site.create_by = current_user.user.user_name
    add_site.create_time = current_time
    add_site.update_by = current_user.user.user_name
    add_site.update_time = current_time
    add_site_result = await MasterService.add_site(query_db, add_site, current_user, scope)

    return ResponseUtil.success(msg=add_site_result.message)


@site_controller.put(
    '',
    summary='编辑客户现场接口',
    description='用于编辑客户现场',
    response_model=ResponseBaseModel,
    dependencies=[UserInterfaceAuthDependency('master:site:edit')],
)
@Log(title='客户现场管理', business_type=BusinessType.UPDATE)
async def edit_master_site(
    request: Request,
    edit_site: SiteModel,
    query_db: Annotated[AsyncSession, DBSessionDependency()],
    current_user: Annotated[CurrentUserModel, CurrentUserDependency()],
    scope: Annotated[TestBatchScope, TestBatchScopeDependency(write=True)],
) -> Response:
    edit_site.update_by = current_user.user.user_name
    edit_site.update_time = datetime.now()
    edit_site_result = await MasterService.edit_site(query_db, edit_site, current_user, scope)

    return ResponseUtil.success(msg=edit_site_result.message)


@site_controller.delete(
    '/{site_ids}',
    summary='删除客户现场接口',
    description='用于删除客户现场',
    response_model=ResponseBaseModel,
    dependencies=[UserInterfaceAuthDependency('master:site:remove')],
)
@Log(title='客户现场管理', business_type=BusinessType.DELETE)
async def delete_master_site(
    request: Request,
    site_ids: Annotated[
        str,
        Path(pattern=r'^[1-9]\d*(,[1-9]\d*)*$', description='需要删除的客户现场ID'),
    ],
    query_db: Annotated[AsyncSession, DBSessionDependency()],
    current_user: Annotated[CurrentUserModel, CurrentUserDependency()],
) -> Response:
    delete_site = DeleteSiteModel(siteIds=[int(site_id) for site_id in site_ids.split(',')])
    delete_site_result = await MasterService.remove_site(query_db, delete_site)

    return ResponseUtil.success(msg=delete_site_result.message)