using JSMachine.WMS.App.Dto;
using JSMachine.WMS.App.Dto.Enum;
using JSMachine.WMS.App.IService;
using JSMachine.WMS.Application.Dto;
using JSMachine.WMS.Application.IService;
using JSMachine.WMS.Business.StockIn.IService;
using JSMachine.WMS.Business.StockOut.IService;
using JSMachine.WMS.Domain.Entity;
using JSMachine.WMS.Domain.Entity.Enums;
using JSMachine.WMS.Infrastructure;
using JSMachine.WMS.Infrastructure.Helper;
using JSMachine.WMS.RPC.ErpRPC.Dto.In.XRBusinessResult;
using JSMachine.WMS.RPC.ErpRPC.Dto.Out;
using JSMachine.WMS.RPC.ErpRPC.Dto.Out.XRBusinessResult;
using JSMachine.WMS.RPC.ErpRPC.IService;
using JSMachine.WMS.WebHost.Models;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using NPOI.SS.Formula.Functions;

namespace JSMachine.WMS.WebHost.Controllers
{
    [Route("api/[controller]/[action]")]
    public class ErpController : ControllerBase
    {
        private IStockInService _stockInByPdaService;
        private IStockOutService _stockOutService;
        private IERPTaskService _erpTaskService;
        private IStorageRackService _storageRackService;
        private IPaperStorageService _paperStorageService;
        private IOperationLogService _operationLogService;


        public ErpController(
            IStockInService stockInByPdaService,
            IStockOutService stockOutService,
            IERPTaskService erpTaskService,
            IStorageRackService storageRackService,
            IPaperStorageService paperStorageService,
            IOperationLogService operationLogService
            )
        {
            _stockInByPdaService = stockInByPdaService;
            _stockOutService = stockOutService;
            _erpTaskService = erpTaskService;
            _storageRackService = storageRackService;
            _paperStorageService = paperStorageService;
            _operationLogService = operationLogService;
        }

        [HttpGet]
        public async Task<ApiResult<List<ERPTaskDto>>> GetLatestErpTasks(TaskTypeEnum taskType)
        {
            List<ERPTaskDto> erpTasks = await _erpTaskService
                .GetListByExpression(p =>
                    p.LastModifiedTime >= DateTime.Now.Date &&
                    p.TaskType == taskType
                );

            erpTasks = erpTasks?.OrderByDescending(p => p.CreationTime).ToList();

            return new ApiResult<List<ERPTaskDto>>
            {
                ResultCode = "200",
                Data = erpTasks
            };
        }

        /// <summary>
        /// 条件查询erp任务
        /// </summary>
        /// <param name="startTime"></param>
        /// <param name="endTime"></param>
        /// <param name="taskType"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<ApiResult<List<ERPTaskDto>>> GetErpTasks([FromBody]ErpTaskQueryParam erpTaskQueryParam)
        {
            List<ERPTaskDto> erpTasks = await _erpTaskService.GetListByExpression(p =>
                p.CreationTime >= erpTaskQueryParam.StartTime &&
                p.CreationTime <= erpTaskQueryParam.EndTime &&
                (erpTaskQueryParam.TaskType == 0 ? true : p.TaskType == erpTaskQueryParam.TaskType),
                               "CreationTime", SqlSugar.OrderByType.Desc);

            return new ApiResult<List<ERPTaskDto>>
            {
                ResultCode = "200",
                Data = erpTasks
            };
        }

        /// <summary>
        /// 合格证号是否已存在
        /// </summary>
        /// <param name="barCode"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<ApiResult<bool>> IsBarCodeExist(string barCode, TaskTypeEnum taskType)
        {
            bool exist = false;
            if (taskType == TaskTypeEnum.PdaIn)
            {
                exist = await _erpTaskService.Exist(p =>
                p.BarCode == barCode &&
               (p.TaskStatus == TaskStatusEnum.Initial || p.TaskStatus == TaskStatusEnum.InExecution || p.TaskStatus == TaskStatusEnum.Completed) &&
               p.TaskType == TaskTypeEnum.PdaIn
               );
            }
            else if (taskType == TaskTypeEnum.TailIn)
            {
                exist = await _erpTaskService.Exist(p =>
                p.CreationTime >= DateTime.Now.AddHours(-1) &&
                p.BarCode == barCode &&
               (p.TaskStatus == TaskStatusEnum.Initial || p.TaskStatus == TaskStatusEnum.InExecution || p.TaskStatus == TaskStatusEnum.Completed) &&
               p.TaskType == TaskTypeEnum.TailIn
               );
            }

            return new ApiResult<bool>
            {
                ResultCode = "200",
                Data = exist
            };
        }

        /// <summary>
        /// 从erp获取物料信息
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        public async Task<ApiResult<StorageRackDto>> GetMaterialInfoFromErp(string barCode)
        {
            XRResultDto erpResult = await _paperStorageService.GetMateriaInfo(barCode);

            StorageRackDto storageRack = new();

            if (erpResult != null && erpResult.data != null)
            {
                storageRack.BarCode = erpResult.data.BarCode;
                storageRack.OrderNo = erpResult.data.OrderNo;
                storageRack.MateriaName = erpResult.data.MateriaName;
                storageRack.MateriaType = erpResult.data.MateriaType;
                storageRack.MateriaNum = int.Parse(erpResult.data.MateriaNum);
                storageRack.MateriaBatch = erpResult.data.MateriaBatch;
                storageRack.MateriaCode = erpResult.data.MateriaCode;
            }

            return new ApiResult<StorageRackDto>
            {
                ResultCode = "200",
                Data = storageRack
            };
        }

        /// <summary>
        /// 更新单个任务状态
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<ApiResult<bool>> UpdateTaskStatus(Guid id, TaskStatusEnum taskStatus)
        {
            LogHelper.Info($"收到pda更新erp任务请求，任务id {id} 更新后的状态 {taskStatus}");

            ERPTaskDto erpTask = await _erpTaskService.GetSingalByExpression(p => p.Id == id);

            if (erpTask.TaskStatus != TaskStatusEnum.Initial)
            {
                LogHelper.Warn($"任务 {id} 当前状态已不是待下发状态，无法取消");
                return new ApiResult<bool>
                {
                    Data = false,
                    ResultCode = "500",
                    ErrorMsg = "所选择的任务当前已不是待下发状态，无法取消"
                };
            }

            erpTask.TaskStatus = taskStatus;

            bool bRet = await _erpTaskService.EditSingal(erpTask);

            return new ApiResult<bool>
            {
                Data = bRet,
                ResultCode = bRet ? "200" : "500"
            };
        }

        /// <summary>
        /// 任务操作
        /// </summary>
        /// <param name="id"></param>
        /// <param name="taskStatus"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<ApiResult<bool>> OperateTask(Guid id, TaskStatusEnum taskStatus)
        {
            LogHelper.Info($"收到网站更新erp任务请求，任务id {id} 更新后的状态 {taskStatus}");

            HttpContext.Request.Headers.TryGetValue("UserId", out var userIdValues);
            _ = _operationLogService.Add(new OperationLogDto
            {
                OperationSource = OperationSource.WEB,
                OperationType = OperationType.UpdateErpTask,
                NewObject = string.Format("ErpTaskId:{0},TaskStatus:{1}", id, taskStatus.GetDescription()),
                UserId = userIdValues
            });

            ERPTaskDto erpTask = await _erpTaskService.GetSingalByExpression(p => p.Id == id);

            if(erpTask==null)
            {
                return new ApiResult<bool> 
                {
                    Data=false,
                    ResultCode="500",
                    ErrorMsg="任务不存在，请刷新后再次重试"
                };
            }

            erpTask.LastModifiedTime=DateTime.Now;
            erpTask.TaskStatus = taskStatus;

            bool bRet = await _erpTaskService.EditSingalWithSpecificCols(erpTask,[nameof(ERPTaskDto.LastModifiedTime),nameof(ERPTaskDto.TaskStatus)]);

            return new ApiResult<bool>
            {
                Data = bRet,
                ResultCode = bRet ? "200" : "500"
            };
        }

        /// <summary>
        /// 暂停所有待执行的任务
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public async Task<ApiResult<bool>> StopAll(TaskTypeEnum taskType)
        {
            LogHelper.Info("收到PDA暂停所有任务请求");

            List<ERPTaskDto> erpTasks = await _erpTaskService.GetListByExpression(p =>
                p.CreationTime > DateTime.Now.Date &&
                p.TaskStatus == TaskStatusEnum.Initial &&
                p.TaskType == taskType);

            if (erpTasks.IsNullOrEmpty())
            {
                return new ApiResult<bool>
                {
                    ResultCode = "200",
                    Data = true
                };
            }

            erpTasks.ForEach(p => p.TaskStatus = TaskStatusEnum.Paused);

            bool bRet = await _erpTaskService.EditBatch(erpTasks);

            return new ApiResult<bool>
            {
                Data = bRet,
                ResultCode = bRet ? "200" : "500"
            };
        }

        /// <summary>
        /// 恢复所有暂停的任务
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public async Task<ApiResult<bool>> ResumeAll(TaskTypeEnum taskType)
        {
            LogHelper.Info("收到PDA恢复所有任务请求");

            List<ERPTaskDto> erpTasks = await _erpTaskService.GetListByExpression(p =>
                p.CreationTime > DateTime.Now.Date &&
                p.TaskStatus == TaskStatusEnum.Paused &&
                p.TaskType == taskType);

            if (erpTasks.IsNullOrEmpty())
            {
                return new ApiResult<bool>
                {
                    ResultCode = "200",
                    Data = true
                };
            }

            erpTasks.ForEach(p => p.TaskStatus = TaskStatusEnum.Initial);

            bool bRet = await _erpTaskService.EditBatch(erpTasks);

            return new ApiResult<bool>
            {
                Data = bRet,
                ResultCode = bRet ? "200" : "500"
            };
        }
    }
}