using DOAN.Admin.WebApi.Filters;
using DOAN.Model;
using DOAN.Model.MES.base_.Dto;
using DOAN.Model.MES.product;
using DOAN.Model.MES.product.Dto;
using DOAN.Service.MES.product.IService;
using Infrastructure.Converter;
using Microsoft.AspNetCore.Mvc;

//创建时间：2024-07-16
namespace DOAN.Admin.WebApi.Controllers
{
    /// <summary>
    /// 生产工单
    /// </summary>
    [Verify]
    [Route("mes/productManagement/ProWorkorder")]
    public class ProWorkorderController : BaseController
    {
        /// <summary>
        /// 生产工单接口
        /// </summary>
        private readonly IProWorkorderService _ProWorkorderService;

        public ProWorkorderController(IProWorkorderService ProWorkorderService)
        {
            _ProWorkorderService = ProWorkorderService;
        }

        /// <summary>
        /// 查询生产工单列表  启用（9/14）
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        [HttpPost("list")]
        [ActionPermissionFilter(Permission = "productManagement:proworkorder:list")]
        public IActionResult QueryProWorkorder([FromBody] ProWorkorderQueryDto parm)
        {
            var response = _ProWorkorderService.GetList(parm);
            return SUCCESS(response);
        }

        /// <summary>
        /// 查询生产工单列表  启用（9/14）  没有校验
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        [HttpPost("list_nocheck")]
        [ActionPermissionFilter(Permission = "productManagement:proworkorder:list")]
        public IActionResult QueryProWorkorder_NOCheck([FromBody] ProWorkorderQueryDto parm)
        {
            parm.WorkorderDate[0] = DOANConvertDate.ConvertLocalDate(parm.WorkorderDate[0]);
            parm.WorkorderDate[1] = DOANConvertDate.ConvertLocalDate(parm.WorkorderDate[1]);

            var response = _ProWorkorderService.GetList_NOCheck(parm);
            return SUCCESS(response);
        }

        /// <summary>
        /// 查询生产工单详情
        /// </summary>
        /// <param name="Id"></param>
        /// <returns></returns>
        [HttpGet("{Id}")]
        [ActionPermissionFilter(Permission = "productManagement:proworkorder:query")]
        public IActionResult GetProWorkorder(string Id)
        {
            var response = _ProWorkorderService.GetInfo(Id);

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

        /// <summary>
        /// 添加生产工单
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        [ActionPermissionFilter(Permission = "productManagement:proworkorder:add")]
        [Log(Title = "生产工单", BusinessType = BusinessType.INSERT)]
        public IActionResult AddProWorkorder([FromBody] ProWorkorderDto parm)
        {
            var modal = parm.Adapt<ProWorkorder>().ToCreate(HttpContext);

            var response = _ProWorkorderService.AddProWorkorder(modal);

            return SUCCESS(response);
        }

        /// <summary>
        /// 更新生产工单 启用（9/14）
        /// </summary>
        /// <returns></returns>
        [HttpPut]
        [ActionPermissionFilter(Permission = "productManagement:proworkorder:edit")]
        [Log(Title = "生产工单", BusinessType = BusinessType.UPDATE)]
        public IActionResult UpdateProWorkorder([FromBody] ProWorkorderDto parm)
        {
            var modal = parm.Adapt<ProWorkorder>().ToUpdate(HttpContext);
            var response = _ProWorkorderService.UpdateProWorkorder(modal);

            return ToResponse(response);
        }

        /// <summary>
        /// 删除生产工单 启用（9/14）
        /// </summary>
        /// <returns></returns>
        [HttpDelete("{ids}")]
        [ActionPermissionFilter(Permission = "productManagement:proworkorder:delete")]
        [Log(Title = "生产工单", BusinessType = BusinessType.DELETE)]
        public IActionResult DeleteProWorkorder(string ids)
        {
            string[] idsArr = Tools.SpitStrArrary(ids);
            if (idsArr.Length <= 0)
            {
                return ToResponse(ApiResult.Error($"删除失败Id 不能为空"));
            }

            var response = _ProWorkorderService.Delete(idsArr);

            return ToResponse(response);
        }

        ///// <summary>
        ///// 生成工单号
        ///// </summary>
        ///// <param name="parm"></param>
        ///// <returns>生成工单号 数量 </returns>
        //[HttpPost("Generate_workorder")]
        //public IActionResult Generate_workorder([FromBody] ProWorkorderQueryDto2 parm)
        //{
        //    if (parm.WorkorderDate <= DateTime.MinValue)
        //    {
        //        SUCCESS(null);
        //    }

        //    var response = _ProWorkorderService.Generate_workorder(parm);

        //    return SUCCESS(response);
        //}

        /// <summary>
        /// 插入工单/或者新增工单 启用（9/14）
        /// </summary>
        /// <param name="parm"></param>
        /// <returns>1成功 0失败</returns>
        [HttpPost("insert_workorder")]
        [Log(Title = "插入工单/或者新增工单", BusinessType = BusinessType.INSERT)]
        public IActionResult Insert_workOrder([FromBody] ProWorkorderDto2 parm)
        {
            if (parm == null)
            {
                return SUCCESS(null);
            }

            ProWorkorder newparm = parm.Adapt<ProWorkorder>().ToCreate(HttpContext);
            var response = _ProWorkorderService.Insert_workOrder(newparm, parm.next_id);

            return SUCCESS(response);
        }

        /// <summary>
        /// 移动工单
        /// </summary>
        /// <param name="id"> 1上  2下</param>
        /// <param name="type"></param>
        /// <returns></returns>
        [HttpGet("move_workorder")]
        [Log(Title = "移动工单", BusinessType = BusinessType.INSERT)]
        public IActionResult MoveWorkorder(string id, int type)
        {
            if (string.IsNullOrEmpty(id))
            {
                return SUCCESS(null);
            }
            var response = _ProWorkorderService.MoveWorkorder(id, type);
            return SUCCESS(response);
        }

        /// <summary>
        /// 生产工单导入模板下载 workorder  启用（9/14）
        /// </summary>
        /// <returns></returns>
        [HttpGet("importTemplate")]
        [Log(
            Title = "生产工单导入模板",
            BusinessType = BusinessType.EXPORT,
            IsSaveRequestData = true,
            IsSaveResponseData = false
        )]
        [AllowAnonymous]
        public IActionResult ImportTemplateExcel()
        {
            (string, string) result = DownloadImportTemplate("workorder");
            return ExportExcel(result.Item2, result.Item1);
        }

        /// <summary>
        /// 导入 启用（9/14）
        /// </summary>
        /// <param name="formFile">使用IFromFile必须使用name属性否则获取不到文件</param>
        /// <returns>导入成功数   若-1 则excel读取异常</returns>
        [HttpPost("importData")]
        [Log(
            Title = "生产工单导入",
            BusinessType = BusinessType.IMPORT,
            IsSaveRequestData = false,
            IsSaveResponseData = true
        )]
        [AllowAnonymous]
        public IActionResult ImportData([FromForm(Name = "file")] IFormFile formFile)
        {
            if (formFile == null)
            {
                return SUCCESS(null);
            }
            int response = _ProWorkorderService.ImportData(formFile, HttpContext.GetName());

            return SUCCESS(response);
        }

        //TODO  分批导入工单，追加工单
        [HttpPost("importData_append")]
        [Log(
            Title = "生产工单导入",
            BusinessType = BusinessType.IMPORT,
            IsSaveRequestData = false,
            IsSaveResponseData = true
        )]
        [AllowAnonymous]
        public IActionResult ImportDataAppend([FromForm(Name = "file")] IFormFile formFile)
        {
            if (formFile == null)
            {
                return SUCCESS(null);
            }
            int response = _ProWorkorderService.ImportDataAppend(formFile, HttpContext.GetName());

            return SUCCESS(response);
        }

        /// <summary>
        /// 工单导出  启用（9/14）
        /// </summary>
        /// <param name="user"></param>
        /// <returns></returns>
        [HttpGet("export")]
        [Log(Title = "工单导出", BusinessType = BusinessType.EXPORT)]
        [AllowAnonymous]
        public IActionResult WorkOrderExport([FromQuery] DateTime extportDate)
        {
            if (extportDate == DateTime.MinValue)
            {
                return SUCCESS(null);
            }
            var list = _ProWorkorderService.WorkOrderExport(extportDate);

            var result = ExportExcelMini(list, "workorder", "工单列表");
            return ExportExcel(result.Item2, result.Item1);
        }

        //TODO  获取物料
        [HttpPost("get_material")]
        public IActionResult GetMaterialInfo([FromBody] BaseMaterialListQueryDto5 query)
        {
            if (query == null)
            {
                return SUCCESS(null);
            }
            var response = _ProWorkorderService.GetMaterialInfo(query);
            return SUCCESS(response);
        }

        //TODO 获取客户
        [HttpPost("get_custom")]
        public IActionResult GetCustomInfo([FromBody] BaseCustomQueryDto2 parm)
        {
            if (parm == null)
            {
                return SUCCESS(null);
            }
            var response = _ProWorkorderService.GetCustomInfo(parm);
            return SUCCESS(response);
        }

        //TODO 获取指定日期工艺路线
        [HttpGet("get_process_route")]
        public IActionResult GetProcessRoute(DateTime dateTime)
        {
            if (dateTime == DateTime.MinValue)
            {
                return SUCCESS(null);
            }

            var response = _ProWorkorderService.GetProcessRoute(dateTime);
            return SUCCESS(response);
        }

        //TODO  获取全部工艺路线  启用（9/14）
        [HttpGet("get_all_route")]
        public IActionResult GetAllRoute()
        {
            var response = _ProWorkorderService.GetAllRoute();
            return SUCCESS(response);
        }

        //TODO 获取组
        //[HttpGet("get_groups")]
        //public IActionResult GetGroupList(string route_code,DateTime dateTime)
        //{
        //    if (string.IsNullOrEmpty(route_code)) { return SUCCESS(null); }
        //    if (dateTime == DateTime.MinValue)
        //    {
        //        return SUCCESS(null);

        //    }

        //    var response = _ProWorkorderService.GetGroupList(route_code, dateTime);
        //    return SUCCESS(response);

        //}
        // 启用（9/14）
        [HttpGet("get_groups")]
        public IActionResult GetGroupList()
        {
            var response = _ProWorkorderService.GetGroupList();
            return SUCCESS(response);
        }

        //TODO  查询BOM 及其所需数量
        /// <summary>
        /// 查询BOM 及其所需数量
        /// </summary>
        /// <param name="workorder_num">工单号</param>
        /// <returns></returns>
        [HttpGet("search_BOM_num")]
        public IActionResult SearchBOMNum(string workorder_num)
        {
            if (string.IsNullOrEmpty(workorder_num))
            {
                return SUCCESS(null);
            }

            var response = _ProWorkorderService.SearchBOMNum(workorder_num);
            return SUCCESS(response);
        }

        //TODO  工单变更日志
        [HttpGet("workorder_log")]
        public IActionResult WorkOrderLog(string workorder)
        {
            if (string.IsNullOrEmpty(workorder))
            {
                return SUCCESS(null);
            }
            var response = _ProWorkorderService.WorkOrderLog(workorder);
            return SUCCESS(response);
        }

        //TODO  获取工单进度追溯
        [HttpPost("get_workorder_trace_progress")]
        public IActionResult GetWorkorderTraceProgressList([FromBody] ProWorkorderQueryDto query)
        {
            query.WorkorderDate[0] = DOANConvertDate.ConvertLocalDate(query.WorkorderDate[0]);
            query.WorkorderDate[1] = DOANConvertDate.ConvertLocalDate(query.WorkorderDate[1]);
            if (query == null)
            {
                throw new Exception("query为空");
            }
            var response = _ProWorkorderService.GetWorkorderTraceProgressList(query);

            return SUCCESS(response);
        }

        //TODO 打印机打印工单

        [HttpPost("print")]
        [AllowAnonymous]
        public async Task<IActionResult> ExportWorkorderPDF([FromBody] ProWorkorderExportDto param)
        {
            try
            {
                if (param.WorkorderArray == null || param.WorkorderArray.Length < 1)
                {
                    return ToResponse(500, "工单列表为空");
                }
                param.Path = "D:/mes/Label/Trace.btw";
                //Task<(string, Stream)> conntext =   _ProWorkorderService.ExportPDFByQuestPDFDemo(workorderArray);
                var exception = await _ProWorkorderService.PrintTicketsByTemplate(param);

                return (IActionResult)exception;
                //return File(conntext.Result.Item2, "application/pdf", HttpUtility.UrlEncode(conntext.Result.Item1));
            }
            catch (Exception ex)
            {
                return ToResponse(500, ex.Message);
            }
        }
    }
}