using Microsoft.AspNetCore.Mvc;
using ZR.Model.Business.Dto;
using ZR.Model.Business;
using ZR.Service.Business.IBusinessService;
using MiniExcelLibs;
using ZR.Service.Business;
using SqlSugar;

//创建时间：2025-08-05
namespace ZR.Admin.WebApi.Controllers.Business
{
    /// <summary>
    /// 机架列表
    /// </summary>
    [Route("business/OdfRacks")]
    public class OdfRacksController : BaseController
    {
        /// <summary>
        /// 机架列表接口
        /// </summary>
        private readonly IOdfRacksService _OdfRacksService;
        private readonly IOdfRoomsService _odfRooms;
        /// <summary>
        /// 框
        /// </summary>
        private readonly IOdfFramesService _OdfFramesService;
        /// <summary>
        /// 端口
        /// </summary>
        private readonly IOdfPortsService _OdfPortsService;

        public OdfRacksController(IOdfRacksService OdfRacksService, IOdfRoomsService odfRooms,
            IOdfFramesService odfFramesService,
            IOdfPortsService odfPortsService)
        {
            _OdfRacksService = OdfRacksService;
            _odfRooms = odfRooms;
            _OdfFramesService = odfFramesService;
            _OdfPortsService = odfPortsService;
        }

        /// <summary>
        /// 查询机架列表列表
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        [HttpGet("list")]
        [ActionPermissionFilter(Permission = "odfracks:list")]
        public IActionResult QueryOdfRacks([FromQuery] OdfRacksQueryDto parm)
        {
            var response = _OdfRacksService.GetList(parm);
            return SUCCESS(response);
        }


        /// <summary>
        /// 查询机架列表详情
        /// </summary>
        /// <param name="Id"></param>
        /// <returns></returns>
        [HttpGet("{Id}")]
        [ActionPermissionFilter(Permission = "odfracks:query")]
        public IActionResult GetOdfRacks(int Id)
        {
            var response = _OdfRacksService.GetInfo(Id);

            var info = response.Adapt<OdfRacksDto>();
            return SUCCESS(info);
        }

        /// <summary>
        /// 添加机架列表
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        [ActionPermissionFilter(Permission = "odfracks:add")]
        [Log(Title = "机架列表", BusinessType = BusinessType.INSERT)]
        public IActionResult AddOdfRacks([FromBody] OdfRacksDto parm)
        {
            var modal = parm.Adapt<OdfRacks>().ToCreate(HttpContext);
            if (modal.RoomId > 0)
            {
                var rooms = _odfRooms.GetById(modal.RoomId);
                if (rooms == null)
                {
                    return ToResponse(ResultCode.FAIL, "机房不存在");
                }
                modal.DeptId = rooms.DeptId ?? 0;
            }
            var response = _OdfRacksService.AddOdfRacks(modal);

            return SUCCESS(response);
        }


        /// <summary>
        /// 添加机架列表
        /// </summary>
        /// <returns></returns>
        [HttpPost("expert")]
        [ActionPermissionFilter(Permission = "odfracks:add")]
        [Log(Title = "机架列表", BusinessType = BusinessType.INSERT)]
        public async Task<IActionResult> AddOdfRacksExpert([FromBody] OdfRacksExpertDto parm)
        {
            var modal = parm.Adapt<OdfRacks>().ToCreate(HttpContext);

            if (modal.RoomId == 0)
            {
                return ToResponse(ResultCode.FAIL, "机房不存在");

            }
            var rooms = _odfRooms.GetById(modal.RoomId);
            if (rooms == null)
            {
                return ToResponse(ResultCode.FAIL, "机房不存在");
            }
            modal.DeptId = rooms.DeptId ?? 0;
            modal.FrameCount = parm.FramesCount;
            var response = _OdfRacksService.AddOdfRacks(modal);
            var roomId = rooms.Id;
            var roomName = rooms.RoomName;

            if (parm.FramesCount > 0)
            {

                //添加机框
                List<OdfFrames> framesList = new List<OdfFrames>();
                var rack = response;
                for (int i = 0; i < parm.FramesCount; i++)
                {
                    var t = await _OdfFramesService.InsertReturnEntityAsync(new OdfFrames()
                    {
                        CreatedAt = DateTime.Now,
                        UpdateAt = DateTime.Now,
                        PortsCol = parm.PortsCount,
                        PortsCount = parm.PortsCount,
                        DeptId = rack.DeptId,
                        PortsRow = parm.PortsCount,
                        PortsName = $"{(i + 1)}框",
                        RackId = rack.Id,
                        SequenceNumber = i + 1
                    });
                    framesList.Add(t);
                }
                //添加机框结束
                if (parm.RowCount > 0)
                {
                    //添加行
                    if (parm.PortsCount > 0)
                    {
                        int index = 0;
                        //添加端口
                        foreach (var frame in framesList)
                        {
                            var ra = rack;
                            if (ra == null)
                            {
                                continue;
                            }
                            List<OdfPorts> ports = new List<OdfPorts>();
                            for (int row = 0; row < parm.RowCount; row++)
                            {
                                for (int port = 0; port < parm.PortsCount; port++)
                                {
                                    ports.Add(new OdfPorts()
                                    {
                                        CreatedAt = DateTime.Now,
                                        DeptId = rooms.DeptId ?? 0,
                                        DeptName = rooms.DeptName,
                                        RackId = frame.RackId,
                                        RackName = ra.RackName,
                                        RoomId = roomId,
                                        RoomName = roomName,
                                        FrameId = frame.Id,
                                        FrameName = frame.PortsName,
                                        Name = $"{(row + 1)}-{(port + 1)}",
                                        RowNumber = row + 1,
                                        PortNumber = port + 1,
                                        OpticalAttenuation = "",
                                        HistoryRemarks = "",
                                        Remarks = "",
                                        Status = parm.DefaultStatus,
                                        UpdatedAt = DateTime.Now,
                                    });
                                }
                            }
                            await _OdfPortsService.AsInsertable(ports).ExecuteReturnEntityAsync(true);
                            //如果超过100个机框，则休眠一下，防止服务器死机
                            index++;
                            if (index > 100)
                            {
                                Thread.Sleep(50);
                                index = 0;
                            }
                        }

                    }
                }
            }

            return SUCCESS(response);
        }

        /// <summary>
        /// 更新机架列表
        /// </summary>
        /// <returns></returns>
        [HttpPut]
        [ActionPermissionFilter(Permission = "odfracks:edit")]
        [Log(Title = "机架列表", BusinessType = BusinessType.UPDATE)]
        public async Task<IActionResult> UpdateOdfRacks([FromBody] OdfRacksDto parm)
        {
            var modal = parm.Adapt<OdfRacks>().ToUpdate(HttpContext);
            var oldModel = _OdfRacksService.GetById(parm.Id);
            var response = _OdfRacksService.UpdateOdfRacks(modal);
            if (response > 0)
            {
                var rackName = oldModel.RackName;
                var oldRoomId = modal.RoomId;
                var rackId = modal.Id;

                if (oldModel.RackName != modal.RackName)
                {
                    // 最直接的转换
                    await _OdfPortsService.UpdateAsync(
                        it => it.RoomId == oldRoomId && it.RackId == rackId,  // WHERE条件
                        it => new OdfPorts               // SET部分
                        {
                            RackName = modal.RackName,
                        }
                    );
                }
            }
            return ToResponse(response);
        }

        /// <summary>
        /// 删除机架列表
        /// </summary>
        /// <returns></returns>
        [HttpPost("delete/{ids}")]
        [ActionPermissionFilter(Permission = "odfracks:delete")]
        [Log(Title = "机架列表", BusinessType = BusinessType.DELETE)]
        public async Task<IActionResult> DeleteOdfRacks([FromRoute] string ids)
        {
            var idArr = Tools.SplitAndConvert<int>(ids);
            foreach (var racksId in idArr)
            {
                var racks = _OdfRacksService.GetById(racksId);
                if (racks == null)
                {
                    return ToResponse(ResultCode.FAIL, "删除失败");
                }
                //删除机房下的所有端口
                await _OdfPortsService.AsDeleteable().Where(it => it.RackId == racks.Id).ExecuteCommandAsync();
                //删除机房下所有的框
                var deletedCount = await _OdfFramesService.AsDeleteable().Where(it => it.RackId == racks.Id).ExecuteCommandAsync();
                //删除机架
                _OdfRacksService.Delete(racks);
            }

            return ToResponse(_OdfRacksService.Delete(idArr, "删除机架列表"));
        }

        /// <summary>
        /// 导出机架列表
        /// </summary>
        /// <returns></returns>
        [Log(Title = "机架列表", BusinessType = BusinessType.EXPORT, IsSaveResponseData = false)]
        [HttpGet("export")]
        [ActionPermissionFilter(Permission = "odfracks:export")]
        public IActionResult Export([FromQuery] OdfRacksQueryDto parm)
        {
            var list = _OdfRacksService.ExportList(parm).Result;
            if (list == null || list.Count <= 0)
            {
                return ToResponse(ResultCode.FAIL, "没有要导出的数据");
            }
            var result = ExportExcelMini(list, "机架列表", "机架列表");
            return ExportExcel(result.Item2, result.Item1);
        }

        /// <summary>
        /// 导入
        /// </summary>
        /// <param name="formFile"></param>
        /// <returns></returns>
        [HttpPost("importData")]
        [Log(Title = "机架列表导入", BusinessType = BusinessType.IMPORT, IsSaveRequestData = false)]
        [ActionPermissionFilter(Permission = "odfracks:import")]
        public IActionResult ImportData([FromForm(Name = "file")] IFormFile formFile)
        {
            List<OdfRacksDto> list = new();
            using (var stream = formFile.OpenReadStream())
            {
                list = stream.Query<OdfRacksDto>(startCell: "A1").ToList();
            }

            return SUCCESS(_OdfRacksService.ImportOdfRacks(list.Adapt<List<OdfRacks>>()));
        }

        /// <summary>
        /// 机架列表导入模板下载
        /// </summary>
        /// <returns></returns>
        [HttpGet("importTemplate")]
        [Log(Title = "机架列表模板", BusinessType = BusinessType.EXPORT, IsSaveResponseData = false)]
        [AllowAnonymous]
        public IActionResult ImportTemplateExcel()
        {
            var result = DownloadImportTemplate(new List<OdfRacksDto>() { }, "OdfRacks");
            return ExportExcel(result.Item2, result.Item1);
        }

    }
}