using Microsoft.AspNetCore.Mvc;
using WIDESEA_Core;
using WIDESEA_Core.BaseController;
using WIDESEA_DTO.Outbound;
using WIDESEA_IOutboundService;
using WIDESEA_Model.Models;
using static WIDESEA_OutboundService.OutboundBatchPickingService;

namespace WIDESEA_WMSServer.Controllers.Outbound
{
 
    [Route("api/OutboundBatchPicking")]
    [ApiController]
    public class OutboundBatchPickingController : ApiBaseController<IOutboundBatchPickingService, Dt_PickingRecord>
    {
        private readonly ISplitPackageService _splitPackageService;
        private readonly IOutStockLockInfoService _outStockLockInfoService;
        private readonly IOutboundBatchPickingService _outboundBatchPickingService;

        private readonly ILogger<OutboundBatchPickingController> _logger;
        public OutboundBatchPickingController(IOutboundBatchPickingService service, ISplitPackageService splitPackageService, IOutStockLockInfoService outStockLockInfoService, IOutboundBatchPickingService outboundBatchPickingService, ILogger<OutboundBatchPickingController> logger) : base(service)
        {
            _splitPackageService = splitPackageService;
            _outStockLockInfoService = outStockLockInfoService;
            _outboundBatchPickingService = outboundBatchPickingService;
            _logger = logger;
        }

        /// <summary>
        /// 分拣确认
        /// </summary>
        [HttpPost("confirm-picking")]
        public async Task<WebResponseContent> ConfirmPicking([FromBody] ConfirmPickingDto dto)
        {
            return await _outboundBatchPickingService.ConfirmBatchPicking(dto.OrderNo, dto.PalletCode, dto.Barcode);
        }

        /// <summary>
        /// 取消分拣
        /// </summary>
        [HttpPost("cancel-picking")]
        public async Task<WebResponseContent> CancelPicking([FromBody] CancelPickingDto dto)
        {
            return await _outboundBatchPickingService.CancelPicking(dto.OrderNo, dto.PalletCode, dto.Barcode);
        }
        /// <summary>
        /// 取消拆包链
        /// </summary>
        [HttpPost("cancel-split-chain")]
        public async Task<WebResponseContent> CancelSplitChain([FromBody] CancelSplitChainDto dto)
        {
            return await _outboundBatchPickingService.CancelSplitPackageChain(dto.OrderNo, dto.PalletCode, dto.StartBarcode);
        }

        /// <summary>
        /// 获取拆包链信息
        /// </summary>
        [HttpPost("split-package-chain-info")]
        public async Task<WebResponseContent> GetSplitPackageChainInfo([FromBody] SplitPackageChainInfoRequestDto dto)
        {
            return await _outboundBatchPickingService.GetSplitPackageChainInfo(dto.OrderNo, dto.Barcode);
        }
        /// <summary>
        /// 查找完整拆包链（从根条码开始）
        /// </summary>
        [HttpPost("find-root-split-chain")]
        public async Task<WebResponseContent> FindRootSplitChain([FromBody] SplitPackageChainInfoRequestDto dto)
        {
            try
            {
                // 查找根条码
                var rootBarcode = await _outboundBatchPickingService. FindRootBarcode(dto.OrderNo, dto.Barcode);

                // 获取完整拆包链
                var splitChain = await _outboundBatchPickingService.GetSplitPackageChain(dto.OrderNo, rootBarcode);

                var chainInfo = new SplitPackageChainInfoDto
                {
                    OriginalBarcode = rootBarcode,
                    RootBarcode = rootBarcode,
                    TotalSplitTimes = splitChain.Count,
                    ChainType = "root",
                    SplitChain = splitChain.Select(x => new SplitChainItemDto
                    {
                        SplitTime = x.SplitTime,
                        OriginalBarcode = x.OriginalBarcode,
                        NewBarcode = x.NewBarcode,
                        SplitQuantity = x.SplitQty,
                        Operator = x.Operator,
                        IsReverted = x.IsReverted
                    }).ToList()
                };

                return WebResponseContent.Instance.OK("获取成功", chainInfo);
            }
            catch (Exception ex)
            {
                _logger.LogError($"查找完整拆包链失败 - OrderNo: {dto.OrderNo}, Barcode: {dto.Barcode}, Error: {ex.Message}");
                return WebResponseContent.Instance.Error("查找完整拆包链失败");
            }
        }
        /// <summary>
        /// 手动拆包
        /// </summary>
        [HttpPost("split-package")]
        public async Task<WebResponseContent> SplitPackage([FromBody] SplitPackageDto dto)
        {
            return await _outboundBatchPickingService.ManualSplitPackage(dto.OrderNo, dto.PalletCode, dto.OriginalBarcode, dto.SplitQuantity);
        }
        /// <summary>
        /// 取消拆包
        /// </summary>
        [HttpPost("cancel-split")]
        public async Task<WebResponseContent> CancelSplit([FromBody] CancelSplitDto dto)
        {
            return await _outboundBatchPickingService.CancelSplitPackage(dto.OrderNo, dto.PalletCode, dto.NewBarcode);
        }

        /// <summary>
        /// 分批回库
        /// </summary>
        [HttpPost("return-stock")]
        public async Task<WebResponseContent> ReturnStock([FromBody] ReturnStockDto dto)
        {
            return await _outboundBatchPickingService.BatchReturnStock(dto.OrderNo, dto.PalletCode);
        }

        /// <summary>
        /// 获取托盘的锁定信息
        /// </summary>
        [HttpPost("pallet-locks")]
        public async Task<WebResponseContent> GetPalletLocks([FromBody] PalletLocksDto dto)
        {
            try
            {
                var locks = await _outboundBatchPickingService.GetPalletLockInfos(dto.OrderNo, dto.PalletCode);
                return WebResponseContent.Instance.OK("获取成功", locks);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, $"获取托盘锁定信息异常 - OrderNo: {dto.OrderNo}, PalletCode: {dto.PalletCode}");
                return WebResponseContent.Instance.Error("系统异常，请稍后重试" + ex.Message);
            }
        }
        /// <summary>
        /// 获取已拣选列表
        /// </summary>
        [HttpPost("pallet-picked-list")]
        public async Task<WebResponseContent> GetPalletPickedList([FromBody] PalletLocksDto dto)
        {
            try
            {
                var pickedList = await _outboundBatchPickingService.GetPalletPickedList(dto.OrderNo, dto.PalletCode);
                return WebResponseContent.Instance.OK("获取成功", pickedList);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, $"获取已拣选列表异常 - OrderNo: {dto.OrderNo}, PalletCode: {dto.PalletCode}");
                return WebResponseContent.Instance.Error("系统异常，请稍后重试" + ex.Message);
            }
        }

        /// <summary>
        /// 获取托盘状态
        /// </summary>
        [HttpPost("pallet-status")]
        public async Task<WebResponseContent> GetPalletStatus([FromBody] PalletLocksDto dto)
        {
            try
            {
                var status = await _outboundBatchPickingService.GetPalletStatus(dto.OrderNo, dto.PalletCode);
                return WebResponseContent.Instance.OK("获取成功", status);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, $"获取托盘状态异常 - OrderNo: {dto.OrderNo}, PalletCode: {dto.PalletCode}");
                return WebResponseContent.Instance.Error("系统异常，请稍后重试" + ex.Message);
            }
        }

        /// <summary>
        /// 获取拆包信息
        /// </summary>
        [HttpPost("split-package-info")]
        public async Task<WebResponseContent> GetSplitPackageInfo([FromBody] SplitPackageInfoDto dto)
        {
            try
            {
                var info = await _outboundBatchPickingService.GetSplitPackageInfo(dto.OrderNo, dto.PalletCode, dto.Barcode);
                return WebResponseContent.Instance.OK("获取成功", info);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, $"获取拆包信息异常 - OrderNo: {dto.OrderNo}, PalletCode: {dto.PalletCode}, Barcode: {dto.Barcode}");
                return WebResponseContent.Instance.Error("系统异常，请稍后重试" +ex.Message);
            }
        }

        /// <summary>
        /// 取走空箱
        /// </summary>
        [HttpPost("remove-empty-pallet")]
        public async Task<WebResponseContent> RemoveEmptyPallet([FromBody] RemoveEmptyPalletDto dto)
        {
            try
            {
                var result = await _outboundBatchPickingService.RemoveEmptyPallet(dto.OrderNo, dto.PalletCode);
                return result;
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, $"取走空箱异常 - OrderNo: {dto.OrderNo}, PalletCode: {dto.PalletCode}");
                return WebResponseContent.Instance.Error("系统异常，请稍后重试" +ex.Message);
            }
        }

    }

}