using JNPF.Common.Core.Manager;
using JNPF.Common.Enums;
using JNPF.Common.Extension;
using JNPF.Common.Security;
using JNPF.DependencyInjection;
using JNPF.DynamicApiController;
using JNPF.FriendlyException;
using JNPF.Logging;
using JNPF.Message.Service;
using JNPF.Systems.Entitys.System;
using JNPF.Systems.Interfaces.System;
using JNPF.TaskScheduler;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using SqlSugar;
using Tnb.BasicData;
using Tnb.BasicData.Entities;
using Tnb.ProductionMgr.Entities;
using Tnb.ProductionMgr.Entities.Dto.PrdManage;
using Tnb.ProductionMgr.Entities.Entity;
using Tnb.WarehouseMgr.Entities.Consts;

namespace Tnb.ProductionMgr
{
    [ApiDescriptionSettings(Tag = ModuleConst.Tag, Area = ModuleConst.Area, Order = 700)]
    [Route("api/[area]/[controller]/[action]")]
    public class MesForErpService:  IDynamicApiController, ITransient
    {
        private readonly ISqlSugarClient _db;
        private readonly IUserManager _userManager;
        private readonly IBillRullService _billRuleService;

        public static Dictionary<string, string> moTypeDic = new Dictionary<string, string>()
        {
            ["1"] = "25019163616533", //注塑
            ["2"] = "25019172714005", //挤出
            ["3"] = "25019181615125", //组装
            ["4"] = "25019191681045", //包装
        };

        public MesForErpService(ISqlSugarRepository<PrdMo> repository,
            IBillRullService billRuleService,
            IUserManager userManager)
        {
            _userManager = userManager;
            _billRuleService = billRuleService;
            _db = repository.AsSugarClient();
        }
        
        [HttpPost]
        [AllowAnonymous]
        public async Task<string> SavePrdMo(List<PrdMo> input)
        {
            if (input == null || input.IsEmpty())
                throw Oops.Bah("参数不能为空");
            
            Log.Information($"生产工单接收参数:{JsonConvert.SerializeObject(input)}");

            List<PrdMo> moList = new List<PrdMo>();
            List<string> deleteMoList = new List<string>();
            List<ErpExtendField> extendFieldList = new List<ErpExtendField>();
            foreach (var item in input)
            {
                if (string.IsNullOrEmpty(item.mo_code))
                {
                    Log.Error("【SavePrdMo】工单代码不能为空");
                    throw Oops.Bah("工单代码不能为空");
                }

                if (string.IsNullOrEmpty(item.mo_type))
                {
                    Log.Error("【SavePrdMo】工单类型不能为空");
                    throw Oops.Bah("工单类型不能为空");
                }

                if (item.plan_start_date == null)
                {
                    Log.Error("【SavePrdMo】计划开始日期不能为空");
                    throw Oops.Bah("计划开始日期不能为空");
                }

                if (item.plan_end_date == null)
                {
                    Log.Error("【SavePrdMo】计划结束日期不能为空");
                    throw Oops.Bah("计划结束日期不能为空");
                }

                if (string.IsNullOrEmpty(item.material_code))
                {
                    Log.Error("【SavePrdMo】物料编号不能为空");
                    throw Oops.Bah("物料编号不能为空");
                }

                if (string.IsNullOrEmpty(item.unit_id))
                {
                    Log.Error("【SavePrdMo】单位不能为空");
                    throw Oops.Bah("单位不能为空");
                }

                if (item.plan_qty == null || item.plan_qty <= 0)
                {
                    Log.Error("【SavePrdMo】计划数量不能为空");
                    throw Oops.Bah("计划数量不能为空");
                }

                if (string.IsNullOrEmpty(item.dept_id))
                {
                    Log.Error("【SavePrdMo】生产部门id不能为空");
                    throw Oops.Bah("生产部门id不能为空");
                }

                if (item.ebom_version == null || item.ebom_version.IsEmpty())
                {
                    Log.Error("【SavePrdMo】物料清单版本不能为空");
                    throw Oops.Bah("物料清单版本不能为空");
                }

                BasMaterial basMaterial = await _db.Queryable<BasMaterial>().SingleAsync(x => x.code == item.material_code);
                if (basMaterial == null)
                {
                    Log.Error($"【SavePrdMo】未找到物料编号为{item.material_code}的物料");
                    throw Oops.Bah($"未找到物料编号为{item.material_code}的物料");
                }

                List<BasMaterialUnit> basMaterialUnits = await _db.Queryable<BasMaterialUnit>().Where(x => x.material_id == basMaterial.id).ToListAsync();
                List<String> units = basMaterialUnits.Select(x => x.auxiliary_unit_id).Distinct().ToList();
                if(units!=null && !string.IsNullOrEmpty(basMaterial.unit_id)) units.Add(basMaterial.unit_id);

                if (!units.Contains(item.unit_id))
                {
                    Log.Error($"【SavePrdMo】{basMaterial.name}不存在{item.unit_id}该单位");
                    throw Oops.Bah($"{basMaterial.name}不存在{item.unit_id}该单位");
                }
                
                if (!await _db.Queryable<BasEbomH>().AnyAsync(x => x.material_id == basMaterial.id && x.version == item.ebom_version))
                {
                    Log.Error($"【SavePrdMo】系统中无法找到物料清单{item.ebom_version}版本");
                    throw Oops.Bah($"系统中无法找到物料清单{item.ebom_version}版本");
                }
                
                DictionaryDataEntity unitDic = await _db.Queryable<DictionaryDataEntity>().Where(x=>x.DictionaryTypeId==WmsWareHouseConst.UNITTYPEID && x.EnCode==item.unit_id).FirstAsync();
                
                string mocode = item.mo_code+"-"+item.erp_lineno;
                PrdMo existMo = await _db.Queryable<PrdMo>().Where(x => x.mo_code == mocode).FirstAsync();
                if (existMo!=null && existMo.mo_status != DictConst.ToBeScheduledId)
                {
                    Log.Error($"【SavePrdMo】生产工单{mocode}状态不是待下发无法覆盖");
                    throw Oops.Bah($"【SavePrdMo】生产工单{mocode}状态不是待下发无法覆盖");
                }

                if (existMo != null)
                {
                    deleteMoList.Add(mocode);
                }
                 
                item.id = SnowflakeIdHelper.NextId();
                item.material_id = basMaterial.id;
                item.mo_source = "1";
                item.mo_type = moTypeDic[item.mo_type];
                item.mo_code = mocode;
                item.create_id = WmsWareHouseConst.AdministratorUserId;
                item.create_time = DateTime.Now;
                item.mo_status = DictConst.ToBeScheduledId;
                item.erp_mo_pk = item.erp_mo_pk;
                item.erp_line_pk = item.erp_line_pk;
                item.erp_lineno = item.erp_lineno;
                item.unit_id = unitDic?.EnCode ?? item.unit_id;
                item.dept_id = item.dept_id;
                
                moList.Add(item);
            }
            DbResult<bool> result = await _db.Ado.UseTranAsync(async () =>
            {
                if (!deleteMoList.IsEmpty())
                {
                    await _db.Deleteable<PrdMo>(x => deleteMoList.Contains(x.mo_code)).ExecuteCommandAsync();
                }
                await _db.Insertable(moList).ExecuteCommandAsync();
            });
            if (result.IsSuccess)
            {
                Log.Information($"【SavePrdMo】生产工单保存成功");
            }
            else
            {
                Log.Error($"【SavePrdMo】{result.ErrorMessage}");
                throw Oops.Bah($"{result.ErrorMessage}");
            }
            
            return !result.IsSuccess ? result.ErrorMessage : "保存成功";
        }


        /// <summary>
        /// 删除生产订单
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost]
        [AllowAnonymous]
        public async Task<string> DelPrdMo(DeletePrdMoInput input)
        {
            Log.Information($"删除生产订单接收参数:{JsonConvert.SerializeObject(input)}");
            try
            {
                if (string.IsNullOrEmpty(input.mo_code))
                    throw Oops.Bah("工单代码不能为空");
                if (string.IsNullOrEmpty(input.erp_lineno))
                    throw Oops.Bah("行号不能为空");
                var mo_code= input.mo_code + "-" + input.erp_lineno;
                await _db.Ado.BeginTranAsync();

                PrdMo existMo = await _db.Queryable<PrdMo>().Where(x => x.mo_code == mo_code).FirstAsync();
                if (existMo != null)
                {
                    if (existMo.mo_status != DictConst.ToBeScheduledId)
                    {
                        throw Oops.Bah($"【DelPrdMo】生产工单{input.mo_code}状态不是待下发无法删除");
                    }

                    await _db.Deleteable<PrdMo>().Where(r => r.id == existMo.id).ExecuteCommandAsync();
                }
                else
                {
                    throw Oops.Bah($"【DelPrdMo】生产工单{input.mo_code}数据不存在");
                }

                await _db.Ado.CommitTranAsync();
            }
            catch (Exception e)
            {
                await _db.Ado.RollbackTranAsync();
                throw Oops.Bah($"{e.Message}");
            }
            return "删除成功";
        }

        /// <summary>
        /// 修改生产订单
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost]
        [AllowAnonymous]
        public async Task<string> ModifyPrdMo(PrdMo input)
        {
            Log.Information($"删除生产订单接收参数:{JsonConvert.SerializeObject(input)}");
            try
            {
                if (string.IsNullOrEmpty(input.mo_code))
                {
                    Log.Error("【ModifyPrdMo】工单代码不能为空");
                    throw Oops.Bah("工单代码不能为空");
                }

                if (string.IsNullOrEmpty(input.mo_type))
                {
                    Log.Error("【ModifyPrdMo】工单类型不能为空");
                    throw Oops.Bah("工单类型不能为空");
                }

                if (input.plan_start_date == null)
                {
                    Log.Error("【ModifyPrdMo】计划开始日期不能为空");
                    throw Oops.Bah("计划开始日期不能为空");
                }

                if (input.plan_end_date == null)
                {
                    Log.Error("【ModifyPrdMo】计划结束日期不能为空");
                    throw Oops.Bah("计划结束日期不能为空");
                }

                if (string.IsNullOrEmpty(input.material_code))
                {
                    Log.Error("【ModifyPrdMo】物料编号不能为空");
                    throw Oops.Bah("物料编号不能为空");
                }

                if (string.IsNullOrEmpty(input.unit_id))
                {
                    Log.Error("【ModifyPrdMo】单位不能为空");
                    throw Oops.Bah("单位不能为空");
                }

                if (input.plan_qty == null || input.plan_qty <= 0)
                {
                    Log.Error("【ModifyPrdMo】计划数量不能为空");
                    throw Oops.Bah("计划数量不能为空");
                }

                if (string.IsNullOrEmpty(input.dept_id))
                {
                    Log.Error("【ModifyPrdMo】生产部门id不能为空");
                    throw Oops.Bah("生产部门id不能为空");
                }

                if (input.ebom_version == null || input.ebom_version.IsEmpty())
                {
                    Log.Error("【ModifyPrdMo】物料清单版本不能为空");
                    throw Oops.Bah("物料清单版本不能为空");
                }

                BasMaterial basMaterial = await _db.Queryable<BasMaterial>().SingleAsync(x => x.code == input.material_code);
                if (basMaterial == null)
                {
                    Log.Error($"【ModifyPrdMo】未找到物料编号为{input.material_code}的物料");
                    throw Oops.Bah($"未找到物料编号为{input.material_code}的物料");
                }

                List<BasMaterialUnit> basMaterialUnits = await _db.Queryable<BasMaterialUnit>().Where(x => x.material_id == basMaterial.id).ToListAsync();
                List<String> units = basMaterialUnits.Select(x => x.auxiliary_unit_id).Distinct().ToList();
                if (units != null && !string.IsNullOrEmpty(basMaterial.unit_id)) units.Add(basMaterial.unit_id);

                if (!units.Contains(input.unit_id))
                {
                    Log.Error($"【ModifyPrdMo】{basMaterial.name}不存在{input.unit_id}该单位");
                    throw Oops.Bah($"{basMaterial.name}不存在{input.unit_id}该单位");
                }

                if (!await _db.Queryable<BasEbomH>().AnyAsync(x => x.material_id == basMaterial.id && x.version == input.ebom_version))
                {
                    Log.Error($"【ModifyPrdMo】系统中无法找到物料清单{input.ebom_version}版本");
                    throw Oops.Bah($"系统中无法找到物料清单{input.ebom_version}版本");
                }

                DictionaryDataEntity unitDic = await _db.Queryable<DictionaryDataEntity>().Where(x => x.DictionaryTypeId == WmsWareHouseConst.UNITTYPEID && x.EnCode == input.unit_id).FirstAsync();

                string mocode = input.mo_code + "-" + input.erp_lineno;
                PrdMo existMo = await _db.Queryable<PrdMo>().Where(x => x.mo_code == mocode).FirstAsync();
                if (existMo == null)
                    throw Oops.Bah($"【ModifyPrdMo】生产工单{mocode}数据不存在");
                if (existMo.mo_status != DictConst.ToBeScheduledId)
                {
                    Log.Error($"【ModifyPrdMo】生产工单{mocode}状态不是待下发，无法修改");
                    throw Oops.Bah($"【ModifyPrdMo】生产工单{mocode}状态不是待下发，无法修改");
                }
                var unit_id= unitDic?.EnCode ?? input.unit_id;

                existMo.org_id=input.org_id;
                existMo.material_code=input.material_code;
                existMo.mo_type = moTypeDic[input.mo_type];
                existMo.mo_status = DictConst.ToBeScheduledId;
                existMo.plan_qty=input.plan_qty;
                existMo.input_qty=input.input_qty;
                existMo.complete_qty=input.complete_qty;
                existMo.reported_work_qty=input.reported_work_qty;
                existMo.scrap_qty=input.scrap_qty;
                existMo.plan_start_date=input.plan_start_date;
                existMo.plan_end_date=input.plan_end_date;
                existMo.act_start_date = input.act_start_date;
                existMo.act_end_date = input.act_end_date;
                existMo.dept_id=input.dept_id;
                existMo.customer_code=input.customer_code;
                existMo.order_no=input.order_no;
                existMo.order_seq=input.order_seq;
                existMo.bom_version=input.bom_version;
                existMo.ebom_version=input.ebom_version;
                existMo.relation_ratio=input.relation_ratio;
                existMo.mo_down_user_id=input.mo_down_user_id;
                existMo.mo_down_user_name=input.mo_down_user_name;
                existMo.mo_down_date=input.mo_down_date;
                existMo.remark=input.remark;
                existMo.work_center_code=input.work_center_code;
                existMo.parent_mo_code=input.parent_mo_code;
                existMo.seduling_start_date=input.seduling_start_date;
                existMo.seduling_end_date=input.seduling_end_date;
                existMo.is_create_dispatch=input.is_create_dispatch;
                existMo.seq=input.seq;
                existMo.data_sources=input.data_sources;
                existMo.production_linecode=input.production_linecode;
                existMo.is_merge=input.is_merge;
                existMo.combine_mo_code=existMo.combine_mo_code;
                existMo.time_stamp=input.time_stamp;
                existMo.extras=input.extras;
                existMo.material_id = basMaterial.id;
                existMo.scheduled_qty=input.scheduled_qty;
                existMo.parent_id=input.parent_id;
                existMo.unit_id = unit_id;
                existMo.mo_source = "1";
                existMo.erp_lineno=input.erp_lineno;
                existMo.erp_line_pk=input.erp_line_pk;
                existMo.erp_mo_pk=input.erp_mo_pk;
                existMo.mo_category=input.mo_category;

                await _db.Updateable(existMo).ExecuteCommandAsync();

                await _db.Ado.CommitTranAsync();
            }
            catch (Exception e)
            {
                await _db.Ado.RollbackTranAsync();
                throw Oops.Bah($"修改失败:{e.Message}");
            }
            return "修改成功";
        }
    }
}