using Microsoft.AspNetCore.Mvc;
using ZR.Model.Business.Dto;
using ZR.Model.Business;
using ZR.Service.Business.IBusinessService;
using MiniExcelLibs;
using ZR.ServiceCore.Services;
using System.Threading.Tasks;
using ZR.Service.Business;
using SqlSugar;
using static SKIT.FlurlHttpClient.Wechat.Api.Models.WxaBusinessGetLiveInfoResponse.Types;
using Aliyun.OSS;
using Azure;
using ZR.Model.System.Dto;
using SkiaSharp;
using static SKIT.FlurlHttpClient.Wechat.Api.Models.CardMemberCardActivateUserFormSetRequest.Types;
using ZR.Model.System;

//创建时间：2025-08-05
namespace ZR.Admin.WebApi.Controllers.Business
{
    /// <summary>
    /// 机房列表
    /// </summary>
    [Route("business/OdfRooms")]
    public class OdfRoomsController : BaseController
    {
        /// <summary>
        /// 机房列表接口
        /// </summary>
        private readonly IOdfRoomsService _OdfRoomsService;

        /// <summary>
        /// 部门接口
        /// </summary>
        private readonly ISysDeptService sysDeptService;

        /// <summary>
        ///  
        /// </summary>
        private readonly ISysUserService _SysUserService;



        /// <summary>
        ///机架
        /// </summary>
        private readonly IOdfRacksService _OdfRacksService;
        /// <summary>
        /// 框
        /// </summary>
        private readonly IOdfFramesService _OdfFramesService;
        /// <summary>
        /// 端口
        /// </summary>
        private readonly IOdfPortsService _OdfPortsService;

        public OdfRoomsController(IOdfRoomsService OdfRoomsService,
            ISysDeptService sysDeptService,
            ISysUserService sysUserService,
            IOdfPortsService odfPortsService,
            IOdfFramesService odfFramesService,
            IOdfRacksService odfRacksService)
        {
            _OdfRoomsService = OdfRoomsService;
            this.sysDeptService = sysDeptService;
            _SysUserService = sysUserService;
            _OdfPortsService = odfPortsService;
            _OdfFramesService = odfFramesService;
            _OdfRacksService = odfRacksService;
        }

        /// <summary>
        /// 查询机房列表列表
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        [HttpGet("list")]
        [ActionPermissionFilter(Permission = "odfrooms:list")]
        public IActionResult QueryOdfRooms([FromQuery] OdfRoomsQueryDto parm)
        {
            var response = _OdfRoomsService.GetList(parm);
            return SUCCESS(response);
        }


        /// <summary>
        /// 查询机房列表列表
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        [HttpGet("tree")]
        [ActionPermissionFilter(Permission = "odfrooms:list")]
        public IActionResult GetTreeList([FromQuery] OdfRoomsTreeQueryDto parm)
        {
            List<OdfRoomsTreeDto> list = new List<OdfRoomsTreeDto>();
            if (parm.Level == 1)
            {
                var response = _OdfRoomsService.GetList(parm);
                response.ForEach(it =>
                {
                    list.Add(new OdfRoomsTreeDto
                    {
                        Key = it.Id.ToString(),
                        Id = it.Id.ToString(),
                        Name = it.RoomName + $"[{it.DeptName}]",
                        DeptId = it.DeptId ?? 0,
                        Level = 2,
                        Leaf = false,
                        RoomId = it.Id,
                    });
                });
            }
            else if (parm.Level == 2)
            {
                var response = _OdfRacksService.AsQueryable().Where(it => it.RoomId == parm.RoomId).OrderBy(it => it.SequenceNumber).ToList();
                response.ForEach(it =>
                {
                    list.Add(new OdfRoomsTreeDto
                    {
                        Key = parm.RoomId + "_" + it.Id.ToString(),
                        Id = parm.RoomId + "_" + it.Id.ToString(),
                        Name = it.RackName,
                        DeptId = it.DeptId,
                        Level = 3,
                        Leaf = false,
                        RoomId = parm.RoomId,
                        RacksId = it.Id,
                    });
                });
            }
            else if (parm.Level == 3)
            {
                var response = _OdfFramesService.AsQueryable().Where(it => it.RackId == parm.RacksId).OrderBy(it => it.SequenceNumber).ToList();
                response.ForEach(it =>
                {
                    list.Add(new OdfRoomsTreeDto
                    {
                        Key = parm.RoomId + "_" + parm.RacksId + "_" + it.Id.ToString(),
                        Id = parm.RoomId + "_" + parm.RacksId + "_" + it.Id.ToString(),
                        Name = it.PortsName,
                        DeptId = it.DeptId ?? 0,
                        Level = 4,
                        Leaf = true,
                        RoomId = parm.RoomId,
                        RacksId = parm.RacksId,
                        FramesId = it.Id,
                    });
                });
            }


            return SUCCESS(list);
        }






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

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

        /// <summary>
        /// 添加机房列表
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        [ActionPermissionFilter(Permission = "odfrooms:add")]
        [Log(Title = "机房列表", BusinessType = BusinessType.INSERT)]
        public async Task<IActionResult> AddOdfRooms([FromBody] OdfRoomsDto parm)
        {
            parm.CreatedAt = DateTime.Now;
            parm.UpdatedAt = DateTime.Now;
            if (parm.DeptId == 0)
            {
                parm.DeptName = "未知部门";
            }
            else
            {
                var dept = await sysDeptService.AsQueryable().Where(it => it.DeptId == parm.DeptId).FirstAsync();
                if (dept == null)
                {
                    return ToResponse(ResultCode.CUSTOM_ERROR, "部门不存在，请选择正确的部门！");
                }
                //var dept = _DeptService.GetInfo(parm.DeptId);
                parm.DeptName = dept.DeptName;
            }

            var modal = parm.Adapt<OdfRooms>().ToCreate(HttpContext);
            var response = _OdfRoomsService.AddOdfRooms(modal);

            return SUCCESS(response);
        }
        /// <summary>
        /// 查询公司下的所有区域
        /// </summary>
        /// <returns></returns>
        [HttpGet("getcompany")]
        [ActionPermissionFilter(Permission = "odfrooms:query")]
        public IActionResult GetCompany()
        {
            var dept = sysDeptService.AsQueryable().Where(it => it.ParentId == 0 && it.Status == 0 && it.DelFlag == 0).First();
            if (dept != null)
            {
                var list = sysDeptService.AsQueryable().Where(it => it.ParentId == dept.DeptId).Select(it => new { it.DeptId, it.DeptName }).ToList();
                return SUCCESS(list);
            }
            if (dept == null)
            {
                var list = sysDeptService.AsQueryable().Where(it => it.ParentId == 1).Select(it => new { it.DeptId, it.DeptName }).ToList();
                return SUCCESS(list);
            }
            return SUCCESS(new List<object>());
        }




        /// <summary>
        /// 查询地区列表
        /// </summary>
        /// <param name="deptId"></param>
        /// <returns></returns>
        [HttpGet("getregion")]
        [ActionPermissionFilter(Permission = "odfrooms:query")]
        public IActionResult GetRegion([FromQuery] int deptId)
        {
            var list = sysDeptService.AsQueryable().Where(it => it.ParentId == deptId).Select(it => new { it.DeptId, it.DeptName }).ToList();
            if (list == null || list.Count == 0)
            {
                list = sysDeptService.AsQueryable().Where(it => it.DeptId == deptId).Select(it => new { it.DeptId, it.DeptName }).ToList();
            }
            return SUCCESS(list);
        }


        /// <summary>
        /// 添加机房列表
        /// </summary>
        /// <returns></returns>
        [HttpPost("expert")]
        [ActionPermissionFilter(Permission = "odfrooms:add")]
        [Log(Title = "机房列表", BusinessType = BusinessType.INSERT)]
        public async Task<IActionResult> AddExpertOdfRooms([FromBody] OdfRoomsExpertDto parm)
        {
            parm.CreatedAt = DateTime.Now;
            parm.UpdatedAt = DateTime.Now;
            if (parm.DeptId == 0)
            {
                parm.DeptName = "未知部门";
            }
            else
            {
                var dept = await sysDeptService.AsQueryable().Where(it => it.DeptId == parm.DeptId).FirstAsync();
                if (dept == null)
                {
                    return ToResponse(ResultCode.CUSTOM_ERROR, "部门不存在，请选择正确的部门！");
                }
                //var dept = _DeptService.GetInfo(parm.DeptId);
                parm.DeptName = dept.DeptName;
            }

            var modal = parm.Adapt<OdfRooms>().ToCreate(HttpContext);
            modal.DeptId = parm.DeptId;
            modal.DeptName = parm.DeptName;
            var response = _OdfRoomsService.AddOdfRooms(modal);
            if (parm.RacksCount > 0)
            {
                var roomId = response.Id;
                var roomName = response.RoomName;
                List<OdfRacks> racksList = new List<OdfRacks>();
                //添加机架
                for (int i = 0; i < parm.RacksCount; i++)
                {
                    var t = await _OdfRacksService.InsertReturnEntityAsync(new OdfRacks
                    {
                        CreatedAt = DateTime.Now,
                        FrameCount = parm.FramesCount,
                        DeptId = response.DeptId ?? 0,
                        RackName = $"odf-{(i + 1)}",
                        RoomId = roomId,
                        SequenceNumber = i + 1,
                        UpdatedAt = DateTime.Now,
                    }); // 直接插入机架
                    racksList.Add(t);

                }

                //机架添加完成
                //return Insertable(model).ExecuteReturnEntity();
                if (parm.FramesCount > 0)
                {

                    //添加机框
                    List<OdfFrames> framesList = new List<OdfFrames>();

                    foreach (var rack in racksList)
                    {
                        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 = racksList.Find(it => it.Id == frame.RackId);
                                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 = frame.DeptId ?? 0,
                                            DeptName = modal.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 = "",
                                            OpticalCableOffRemarks = "",
                                            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 = "odfrooms:edit")]
        [Log(Title = "机房列表", BusinessType = BusinessType.UPDATE)]
        public async Task<IActionResult> UpdateOdfRooms([FromBody] OdfRoomsDto parm)
        {
            parm.UpdatedAt = DateTime.Now;
            if (parm.DeptId == 0)
            {
                parm.DeptName = "未知部门";
            }
            else
            {
                var dept = await sysDeptService.AsQueryable().Where(it => it.DeptId == parm.DeptId).FirstAsync();
                if (dept == null)
                {
                    return ToResponse(ResultCode.CUSTOM_ERROR, "部门不存在，请选择正确的部门！");
                }
                //var dept = _DeptService.GetInfo(parm.DeptId);
                parm.DeptName = dept.DeptName;
            }
            var oldModel = _OdfRoomsService.GetById(parm.Id);
            var modal = parm.Adapt<OdfRooms>().ToUpdate(HttpContext);
            var response = _OdfRoomsService.UpdateOdfRooms(modal);
            if (response > 0)
            {
                var deptId = modal.DeptId ?? 0;
                var deptName = modal.DeptName;
                var roomName = modal.RoomName;
                var oldRoomId = oldModel.Id;

                if (oldModel.DeptId != modal.DeptId)
                {

                    // 最直接的转换
                    await _OdfPortsService.UpdateAsync(
                        it => it.RoomId == oldRoomId,  // WHERE条件
                        it => new OdfPorts               // SET部分
                        {
                            DeptId = deptId,
                            DeptName = deptName
                        }
                    );
                    // 1. 更新 odf_racks
                    var racksUpdated = await _OdfRacksService.UpdateAsync(
                        r => r.RoomId == oldRoomId,
                        r => new OdfRacks { DeptId = deptId }
                    );

                    // 2. 更新 odf_frames（方法1：子查询）
                    var framesUpdated = await _OdfFramesService.UpdateAsync(
                        f => SqlFunc.Subqueryable<OdfRacks>()
                             .Where(r => r.RoomId == oldRoomId && r.Id == f.RackId)
                             .Any(),
                        f => new OdfFrames { DeptId = deptId }
                    );
                    // update odf_frames f set DeptId=0 where RackId exists (  select  id from odf_racks where roomid=1 and id=f.RackId )
                    // update odf_racks set DeptId=0 where roomid=1
                    //_OdfFramesService
                    //_OdfRacksService
                }
                if (oldModel.RoomName != modal.RoomName)
                {
                    // 最直接的转换
                    await _OdfPortsService.UpdateAsync(
                        it => it.RoomId == oldRoomId,  // WHERE条件
                        it => new OdfPorts               // SET部分
                        {
                            RoomName = roomName,
                            UpdatedAt = DateTime.Now
                        }
                    );
                }
            }
            return ToResponse(response);
        }

        /// <summary>
        /// 删除机房列表
        /// </summary>
        /// <returns></returns>
        [HttpPost("delete/{ids}")]
        [ActionPermissionFilter(Permission = "odfrooms:delete")]
        [Log(Title = "机房列表", BusinessType = BusinessType.DELETE)]
        public async Task<IActionResult> DeleteOdfRooms([FromRoute] string ids)
        {
            var idArr = Tools.SplitAndConvert<int>(ids);
            foreach (var roomId in idArr)
            {
                var room = _OdfRoomsService.GetById(roomId);
                if (room == null)
                {
                    return ToResponse(ResultCode.FAIL, "删除失败，未找到机房数据");
                }
                //删除机房下的所有端口
                await _OdfPortsService.AsDeleteable().Where(it => it.RoomId == room.Id).ExecuteCommandAsync();
                // delete odf_frames where   exists (  select  id from odf_racks where roomid=1 and id=odf_frames.RackId )
                //删除机房下所有的框
                var deletedCount = await _OdfFramesService.AsDeleteable()
                    .Where(f => SqlFunc.Subqueryable<OdfRacks>()
                                .Where(r => r.RoomId == room.Id && r.Id == f.RackId)
                                .Any())
                    .ExecuteCommandAsync();

                //删除机房下所有的机架
                await _OdfRacksService.AsDeleteable().Where(it => it.RoomId == room.Id).ExecuteCommandAsync();

                _OdfRoomsService.Delete(room.Id, "删除机房");
            }
            return ToResponse(ids.Length);
        }

        /// <summary>
        /// 导出机房列表
        /// </summary>
        /// <returns></returns>
        [Log(Title = "机房列表", BusinessType = BusinessType.EXPORT, IsSaveResponseData = false)]
        [HttpGet("export")]
        [ActionPermissionFilter(Permission = "odfrooms:export")]
        public IActionResult Export([FromQuery] OdfRoomsQueryDto parm)
        {
            var list = _OdfRoomsService.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 = "odfrooms:import")]
        public async Task<IActionResult> ImportData([FromForm(Name = "file")] IFormFile formFile)
        {
            List<OdfRoomsImDto> list = new();
            using (var stream = formFile.OpenReadStream())
            {
                list = stream.Query<OdfRoomsImDto>(startCell: "A1").ToList();
            }
            int errorCount = 0;
            int successCount = 0;
            int addRoomCount = 0;
            int addRackCount = 0;
            int addFrameCount = 0;
            int addPortCount = 0;
            if (list.Count > 0)
            {
                List<OdfPorts> odfPorts = new List<OdfPorts>();
                var deptName = list.Select(it => it.DeptName.Trim()).Distinct().ToList();
                var deptInfo = sysDeptService.AsQueryable().Where(it => deptName.Contains(it.DeptName)).Select(it => new { it.DeptId, it.DeptName }).ToList();

                var roomNameList = list.Select(it => it.RoomName).Select(it => it.Trim()).Distinct().ToList();
                var roomList = _OdfRoomsService.AsQueryable().Where(it => roomNameList.Contains(it.RoomName)).ToList();
                foreach (var excelItem in list)
                {
                    try
                    {
                        var dept = deptInfo.Find(it => it.DeptName == excelItem.DeptName);
                        if (dept == null)
                        {
                            //没有部门，下一个数据
                            errorCount++;
                            continue;
                        }
                        var room = roomList.Find(it => it.RoomName == excelItem.RoomName);
                        if (room == null)
                        {
                            //添加机房
                            var roomItem = new OdfRooms()
                            {
                                CreatedAt = DateTime.Now,
                                RoomAddress = excelItem.RoomAddress,
                                UpdatedAt = DateTime.Now,
                                DeptId = dept.DeptId,
                                DeptName = dept.DeptName,
                                RacksCount = excelItem.RacksCount,
                                Remarks = excelItem.Remarks,
                                RoomName = excelItem.RoomName
                            };
                            await _OdfRoomsService.InsertReturnEntityAsync(roomItem);
                            addRoomCount++;
                            roomList.Add(roomItem);
                            room = roomItem;
                        }
                        else
                        {
                            room.RoomAddress = excelItem.RoomAddress?.Trim();
                            room.Remarks = excelItem.Remarks?.Trim();
                            room.RacksCount = excelItem.RacksCount ?? 0;
                            room.UpdatedAt = DateTime.Now;
                            await _OdfRoomsService.UpdateAsync(room);
                            successCount++;
                            continue;
                        }
                        if (excelItem.CreateRoomInfo == 0)
                        {
                            continue;
                        }
                        if (excelItem.RacksCount > 0)
                        {
                            var roomId = room.Id;
                            var roomName = room.RoomName;
                            List<OdfRacks> racksList = new List<OdfRacks>();
                            //添加机架
                            for (int i = 0; i < excelItem.RacksCount; i++)
                            {
                                var t = await _OdfRacksService.InsertReturnEntityAsync(new OdfRacks
                                {
                                    CreatedAt = DateTime.Now,
                                    FrameCount = excelItem.FrameCount,
                                    DeptId = room.DeptId ?? 0,
                                    RackName = $"odf-{(i + 1)}",
                                    RoomId = roomId,
                                    SequenceNumber = i + 1,
                                    UpdatedAt = DateTime.Now,
                                }); // 直接插入机架
                                racksList.Add(t);

                            }

                            //机架添加完成
                            //return Insertable(model).ExecuteReturnEntity();
                            if (excelItem.FrameCount > 0)
                            {

                                //添加机框
                                List<OdfFrames> framesList = new List<OdfFrames>();

                                foreach (var rack in racksList)
                                {
                                    for (int i = 0; i < excelItem.FrameCount; i++)
                                    {
                                        var t = await _OdfFramesService.InsertReturnEntityAsync(new OdfFrames()
                                        {
                                            CreatedAt = DateTime.Now,
                                            UpdateAt = DateTime.Now,
                                            PortsCol = 12,
                                            PortsRow = 6,
                                            PortsCount = 6 * 12,
                                            DeptId = rack.DeptId,
                                            PortsName = $"{(i + 1)}框",
                                            RackId = rack.Id,
                                            SequenceNumber = i + 1
                                        });
                                        framesList.Add(t);
                                    }
                                }
                                int index = 0;
                                //添加端口
                                foreach (var frame in framesList)
                                {
                                    var ra = racksList.Find(it => it.Id == frame.RackId);
                                    if (ra == null)
                                    {
                                        continue;
                                    }
                                    List<OdfPorts> ports = new List<OdfPorts>();
                                    for (int row = 0; row < 6; row++)
                                    {
                                        for (int port = 0; port < 12; port++)
                                        {
                                            ports.Add(new OdfPorts()
                                            {
                                                CreatedAt = DateTime.Now,
                                                DeptId = frame.DeptId ?? 0,
                                                DeptName = room.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 = "",
                                                OpticalCableOffRemarks = "",
                                                HistoryRemarks = "",
                                                Remarks = "",
                                                Status = excelItem.PortsStatus ?? 1,
                                                UpdatedAt = DateTime.Now,
                                            });
                                        }
                                    }
                                    await _OdfPortsService.AsInsertable(ports).ExecuteReturnEntityAsync(true);
                                    //如果超过100个机框，则休眠一下，防止服务器死机
                                    index++;
                                    if (index > 100)
                                    {
                                        Thread.Sleep(50);
                                        index = 0;
                                    }
                                }



                            }

                        }


                        successCount++;
                    }
                    catch (Exception)
                    {
                        errorCount++;
                    }
                }

            }
            return SUCCESS($"导入成功{successCount}条数据，失败{errorCount}");
        }

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

    }
}