using Dlhis.Basic.Device.Dtos;
using Dlhis.Basic.Device.Request;
using Dlhis.Basic.Device.Response;
using Dlhis.Basic.Device.Services;
using Dlhis.Basic.Organization.Dto;
using Kurisu.AspNetCore.DataAccess.Dto;
using Kurisu.AspNetCore.DataAccess.SqlSugar.Aop;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Dlhis.Basic.Device.Controllers;

[Authorize]
[Route("api/[controller]")]
[ApiController]
public class DevicePermissionsController : ControllerBase
{
    private readonly IDevicePermissionService _devicePermissionService;
    private readonly IDevicePermissionAnalyzeService _devicePermissionAnalyzeService;

    public DevicePermissionsController(IDevicePermissionService devicePermissionService, IDevicePermissionAnalyzeService devicePermissionAnalyzeService)
    {
        _devicePermissionService = devicePermissionService;
        _devicePermissionAnalyzeService = devicePermissionAnalyzeService;
    }

    /// <summary>
    /// 分配权限
    /// </summary>
    /// <param name="request"></param>
    /// <returns></returns>
    [HttpPost("assign")]
    [Transactional]
    [CrossTenant]
    public async Task<DevicePermissionAssignResponse> AssignAsync(DevicePermissionSaveRequest request)
    {
        return await _devicePermissionService.AssignAsync(request);
    }

    /// <summary>
    /// 分配权限到设备
    /// </summary>
    /// <param name="request"></param>
    [HttpPost("assign-unique")]
    [Transactional]
    [CrossTenant]
    public async Task<DevicePermissionAssignResponse> AssignToUniqueAsync(DevicePermissionsAssignToDeviceRequest request)
    {
        return await _devicePermissionService.AssignToUniqueAsync(request);
    }

    // [AllowAnonymous]
    // [HttpPost("assign-unique-import")]
    // [Transactional]
    // [IgnoreTenant]
    // public async Task AssignToUniqueImportAsync(IFormFile file)
    // {
    //     await _devicePermissionService.AssignToUniqueImportAsync(file);
    // }

    /// <summary>
    /// 当前类型的权限分配
    /// </summary>
    /// <param name="request"></param>
    /// <returns></returns>
    [HttpGet("assignments")]
    public async Task<List<Guid>> GetAssignmentsAsync([FromQuery] DeviceGetAssignmentsRequest request)
    {
        return await _devicePermissionAnalyzeService.GetAssignmentsAsync(request);
    }

    /// <summary>
    /// 当前类型的权限分配
    /// </summary>
    /// <param name="request"></param>
    /// <returns></returns>
    [HttpGet("assignments-unique")]
    public async Task<List<GainfoDto>> GetAssignmentUniqueAsync([FromQuery] DeviceGetAssignmentUniquesRequest request)
    {
        return await _devicePermissionAnalyzeService.GetAssignmentUniqueAsync(request);
    }

    /// <summary>
    /// 获取设备下人员分页
    /// </summary>
    /// <param name="request"></param>
    /// <returns></returns>
    [HttpGet("gainfos/page")]
    [CrossTenant]
    public async Task<Pagination<DeviceGainfoResponse>> GetGainfoPageByDeviceAsync([FromQuery] DeviceWithGainfoRequest request)
    {
        return await _devicePermissionService.GetGainfoPageByDeviceAsync(request);
    }

    /// <summary>
    /// 设备人员下发重置
    /// </summary>
    /// <param name="request"></param>
    [HttpPost("gainfos/reset")]
    [CrossTenant]
    public async Task ResetGainfoPageByDeviceAsync(DeviceGainfoReset request)
    {
        await _devicePermissionService.ResetGainfoPageByDeviceAsync(request.Code, request.Search, request.UserType);
    }

    /// <summary>
    /// 获取设备下所有人员
    /// </summary>
    /// <param name="deviceUniqueNo"></param>
    [HttpGet("gainfo-all")]
    [IgnoreTenant]
    public async Task<List<string>> GetDeviceUserCodesAsync(string deviceUniqueNo)
    {
        return await _devicePermissionService.GetDeviceUserCodesAsync(deviceUniqueNo);
    }

    /// <summary>
    /// 设备其他类型人员
    /// </summary>
    /// <param name="deviceUniqueNo"></param>
    /// <returns></returns>
    [HttpGet("gainfo/others")]
    [IgnoreTenant]
    public async Task<DeviceOtherUserCountResponse> ExternalAndManuallyUserNoAsync(string deviceUniqueNo)
    {
        return await _devicePermissionService.ExternalAndManuallyUserNoAsync(deviceUniqueNo);
    }

    [HttpGet("userPermissionCodes")]
    [IgnoreTenant]
    public async Task<List<Guid>> GetAssignDeviceCodesAsync(string userCode)
    {
        return await _devicePermissionService.GetUserDeviceCodesByNoAsync(userCode);
    }


    [HttpGet("temp-userPermissionCodes")]
    [IgnoreTenant]
    public async Task<object> GetAssignDeviceCodesAsync(List<string> userCodes)
    {
        return await _devicePermissionService.GetUserDeviceCodesByNoAsync(userCodes);
    }


    [HttpGet("test-userPermissionCodes")]
    [IgnoreTenant]
    public async Task<Dictionary<string, List<TenantAssignTypeDeviceCode>>> GetTestAssignDeviceCodesAsync(string userNo)
    {
        return await _devicePermissionAnalyzeService.GetUserAssignDeviceCodesWithTypeInTenantAsync(new List<string> { userNo });
    }

    [HttpGet("reset-visitors")]
    [IgnoreTenant]
    public async Task<int> ResetVisitorsByDeviceAsync(string deviceUniqueNo)
    {
        return await _devicePermissionService.ResetVisitorsByDeviceAsync(deviceUniqueNo);
    }

    [HttpGet("exceptUsers")]
    [IgnoreTenant]
    public async Task<List<string>> GetDeviceExceptUsersAsync(string deviceUniqueNo)
    {
        return await _devicePermissionService.GetDeviceExceptUsersAsync(deviceUniqueNo);
    }

    [HttpGet("notInDeviceUsers")]
    [IgnoreTenant]
    public async Task<List<string>> GetDeviceNotInUsersAsync(string deviceUniqueNo)
    {
        return await _devicePermissionService.GetDeviceNotInUsersAsync(deviceUniqueNo);
    }


    [HttpPost("removeExceptUsers")]
    [Transactional]
    [IgnoreTenant]
    public async Task<int> GenerateDeleteDeviceTasksAsync(DeviceRemoveExceptUserRequest request)
    {
        return await _devicePermissionService.GenerateDeleteDeviceTasksAsync(request.DeviceUniqueNo);
    }
}