using System;
using System.ArrayExtensions;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using Aspose.Cells.Drawing;
using COSXML.Model.Tag;
using JNPF.Common.Contracts;
using JNPF.Common.Core.Manager;
using JNPF.Common.Enums;
using JNPF.Common.Security;
using JNPF.DependencyInjection;
using JNPF.DynamicApiController;
using JNPF.FriendlyException;
using JNPF.JsonSerialization;
using JNPF.Systems.Entitys.System;
using JNPF.TaskScheduler;
using JNPF.TaskScheduler.Entitys.Dto.TaskScheduler;
using JNPF.TaskScheduler.Entitys.Model;
using JNPF.VisualDev;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using SqlSugar;
using Tnb.ProductionMgr.Entities;
using Tnb.QcMgr.Entities;
using Tnb.QcMgr.Entities;
using Tnb.QcMgr.Entities.Entity;
using Tnb.QcMgr.Entities.Enums;
using Tnb.QcMgr.Interfaces;

namespace Tnb.QcMgr
{
    /// <summary>
    /// 质检方案模块
    /// </summary>
    [ApiDescriptionSettings(Tag = ModuleConsts.Tag, Area = ModuleConsts.Area, Order = 800)]
    [Route("api/[area]/[controller]/[action]")]
    [OverideVisualDev(ModuleId)]
    public class QcCheckPlanService : IOverideVisualDevService, IQcCheckPlanService, IDynamicApiController, ITransient
    {
        private const string ModuleId = "26589675013909";
        private readonly ISqlSugarRepository<QcCheckPlanH> _repository;
        private readonly IUserManager _userManager;
        private readonly TimeTaskService _timeTaskService;
        public OverideVisualDevFunc OverideFuncs { get; } = new OverideVisualDevFunc();
        public QcCheckPlanService(ISqlSugarRepository<QcCheckPlanH> repository, IUserManager userManager, TimeTaskService timeTaskService)
        {
            _repository = repository;
            _userManager = userManager;
            _timeTaskService = timeTaskService;
            OverideFuncs.DeleteAsync = Delete;
        }
        private async Task Delete(string id)
        {
            var db = _repository.AsSugarClient();
            var QcCheckPlanH = await db.Queryable<QcCheckPlanH>().Where(p => p.id == id).FirstAsync();
            var QcCheckPlanDs = await db.Queryable<QcCheckPlanD>().Where(p => p.mainid == id).ToListAsync();
            var QcCheckPlanAdds = await db.Queryable<QcCheckPlanAdd>().Where(p => p.mainid == id).ToListAsync();
            var QcCheckPlanMaterials = await db.Queryable<QcCheckPlanMaterial>().Where(p => p.planid == id).ToListAsync();
            var QcCheckPlanProcesss = await db.Queryable<QcCheckPlanProcess>().Where(p => p.planid == id).ToListAsync();
            var QcCheckPlanWorks = await db.Queryable<QcCheckPlanWork>().Where(p => p.planid == id).ToListAsync();
            await _timeTaskService.DeleteByName("生成质检任务" + QcCheckPlanH.id);
            await db.Ado.BeginTranAsync();
            await db.Deleteable(QcCheckPlanH).ExecuteCommandAsync();
            await db.Deleteable(QcCheckPlanDs).ExecuteCommandAsync();
            await db.Deleteable(QcCheckPlanAdds).ExecuteCommandAsync();
            await db.Deleteable(QcCheckPlanMaterials).ExecuteCommandAsync();
            await db.Deleteable(QcCheckPlanProcesss).ExecuteCommandAsync();
            await db.Deleteable(QcCheckPlanWorks).ExecuteCommandAsync();
            await db.Ado.CommitTranAsync();
        }
        /// <summary>
        /// 获取方案质检项附加信息
        /// </summary>
        /// <param name="CheckPlanInput"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<dynamic> GetCheckItems(string id)
        {
            var db = _repository.AsSugarClient();
            var QcCheckItems = await db.Queryable<QcCheckItem>().ToListAsync();
            var QcCheckTypes = await db.Queryable<QcCheckType>().ToListAsync();
            var QcCheckPlanAdd = await db.Queryable<QcCheckPlanAdd>().Where(p => p.mainid == id).FirstAsync();
            var QcCheckPlanDs = await db.Queryable<QcCheckPlanD>().Where(p => p.mainid == id).ToListAsync();
            var CheckPlansOut = new CheckPlansOut();
            CheckPlansOut.id = id;
            CheckPlansOut.hasadd = false;
            CheckPlansOut.hasitem = false;
            if (QcCheckPlanAdd != null)
            {
                CheckPlansOut.hasadd = true;
                CheckPlansOut.addid = QcCheckPlanAdd.id;
                CheckPlansOut.triggertype = QcCheckPlanAdd.triggertype!;
                CheckPlansOut.content = QcCheckPlanAdd.content!;
                CheckPlansOut.number = QcCheckPlanAdd.number;
            }
            if (QcCheckPlanDs != null && QcCheckPlanDs.Count > 0)
            {
                CheckPlansOut.hasitem = true;
                CheckPlansOut.checktypes = new List<CheckPlanTypeOut>();
                foreach (var QcCheckPlanD in QcCheckPlanDs)
                {
                    if (CheckPlansOut.checktypes.Where(p => p.checktypeid == QcCheckPlanD.typeid).ToList().Count == 0)
                    {
                        CheckPlanTypeOut checkType = new CheckPlanTypeOut();
                        checkType.checktypeid = QcCheckPlanD.typeid!;
                        checkType.checktypename = QcCheckTypes.Where(p => p.id == QcCheckPlanD.typeid).First().name!;
                        checkType.items = new List<PlanItemOut>();
                        CheckPlansOut.checktypes.Add(checkType);
                    }
                    PlanItemOut Item = new PlanItemOut();
                    Item.itemid = QcCheckPlanD.itemid!;
                    Item.itemdid = QcCheckPlanD.id!;
                    Item.code = QcCheckItems.Where(p => p.id == QcCheckPlanD.itemid).First().code!;
                    Item.name = QcCheckItems.Where(p => p.id == QcCheckPlanD.itemid).First().name!;
                    Item.setData = new PlanItemData();
                    Item.setData.extype = QcCheckPlanD.extype!;
                    Item.setData.excontent = JSON.Deserialize<Excontent>(QcCheckPlanD.excontent!);
                    Item.setData.check = QcCheckPlanD.check!;
                    if (!string.IsNullOrEmpty(QcCheckPlanD.errorcause))
                        Item.setData.errorcause = QcCheckPlanD.errorcause!.Replace("[", "").Replace("]", "").Split(',', StringSplitOptions.RemoveEmptyEntries);
                    if (!string.IsNullOrEmpty(QcCheckPlanD.errorlevel))
                        Item.setData.errorlevel = QcCheckPlanD.errorlevel!.Replace("[", "").Replace("]", "").Split(',', StringSplitOptions.RemoveEmptyEntries);
                    Item.setData.remark = QcCheckPlanD.remark!;
                    Item.setData.attachment = QcCheckPlanD.attachment!;
                    Item.setData.customer = QcCheckPlanD.custom!;
                    if (!string.IsNullOrEmpty(QcCheckPlanD.isexec))
                        Item.setData.isexec = JSON.Deserialize<IsexecP>(QcCheckPlanD.isexec!);
                    Item.setShow = new PlanItemShow();
                    Item.setShow.extype = !string.IsNullOrEmpty(Item.setData.extype);
                    Item.setShow.excontent = !string.IsNullOrEmpty(QcCheckPlanD.excontent);
                    Item.setShow.check = !string.IsNullOrEmpty(Item.setData.check);
                    Item.setShow.errorcause = Item.setData.errorcause == null ? false : true;
                    Item.setShow.errorlevel = Item.setData.errorlevel == null ? false : true;
                    Item.setShow.remark = !string.IsNullOrEmpty(Item.setData.remark);
                    Item.setShow.attachment = !string.IsNullOrEmpty(Item.setData.attachment);
                    Item.setShow.customer = !string.IsNullOrEmpty(Item.setData.customer);
                    if (Item.setData.isexec == null)
                    {
                        Item.setShow.isexec = false;
                    }
                    else
                    { 
                      if(!Item.setData.isexec.attachment&& !Item.setData.isexec.remark)
                            Item.setShow.isexec = false;
                      else
                            Item.setShow.isexec = true;
                    }
                     
                    CheckPlansOut.checktypes.Where(p => p.checktypeid == QcCheckPlanD.typeid).First()?.items?.Add(Item);
                }
            }
            return CheckPlansOut;
        }

        /// <summary>
        /// 获取触发计划清单
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<dynamic> GetTriggerPlans()
        {
            var db = _repository.AsSugarClient();
            var QcTriggerPlans = await db.Queryable<QcTriggerPlan>().ToListAsync();
            var QcTriggerEvents = await db.Queryable<QcTriggerEvent>().ToListAsync();
            List<TriggerPlan> TriggerPlans = new List<TriggerPlan>();
            foreach (var triggerPlan in QcTriggerPlans)
            {
                TriggerPlan TriggerPlan = new TriggerPlan();
                TriggerPlan.id = triggerPlan.id;
                TriggerPlan.name = triggerPlan.name!;
                TriggerPlan.code = triggerPlan.code!;
                TriggerPlan.type = triggerPlan.type!;
                TriggerPlan.cycle = triggerPlan.cycle!;
                if (!string.IsNullOrEmpty(triggerPlan.trievent))
                {
                    TriggerPlan.trieventid = triggerPlan.trievent!.Replace("[", "").Replace("]", "").Replace("\r\n", "").Replace("\"", "").Replace("  ", "").Split(',', StringSplitOptions.RemoveEmptyEntries);
                    TriggerPlan.trievent = QcTriggerEvents.Where(p => TriggerPlan.trieventid.Contains(p.id)).Select(p => p.name!).ToArray();
                }
                TriggerPlans.Add(TriggerPlan);
            }
            return TriggerPlans;
        }

        /// <summary>
        /// 保存质检方案质检项和附加信息
        /// </summary>
        /// <param name="CheckPlanInput"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task SaveData(CheckPlanInput CheckPlanInput)
        {
            var db = _repository.AsSugarClient();
            try
            {
                if (string.IsNullOrEmpty(CheckPlanInput.mainid))
                    return;
                await _timeTaskService.DeleteByName("生成质检任务" + CheckPlanInput.mainid);
                await db.Deleteable<QcCheckPlanD>(p => p.mainid == CheckPlanInput.mainid).ExecuteCommandAsync();
                await db.Deleteable<QcCheckPlanAdd>(p => p.mainid == CheckPlanInput.mainid).ExecuteCommandAsync();
                QcCheckPlanAdd QcCheckPlanAdd = new QcCheckPlanAdd();
                QcCheckPlanAdd.mainid = CheckPlanInput.mainid;
                QcCheckPlanAdd.triggertype = CheckPlanInput.triggertype;
                QcCheckPlanAdd.content = CheckPlanInput.content;
                QcCheckPlanAdd.number = CheckPlanInput.number;
                List<QcCheckPlanD> QcCheckPlanDs = new List<QcCheckPlanD>();
                if (CheckPlanInput.checktypes != null)
                {
                    foreach (var checktype in CheckPlanInput.checktypes)
                    {
                        if (checktype.items != null)
                        {
                            foreach (var item in checktype.items)
                            {
                                QcCheckPlanD QcCheckPlanD = new QcCheckPlanD();
                                QcCheckPlanD.mainid = CheckPlanInput.mainid;
                                QcCheckPlanD.typeid = checktype.id;
                                QcCheckPlanD.itemid = item.itemid;
                                QcCheckPlanD.extype = item.extype;
                                QcCheckPlanD.excontent = item.excontent;
                                QcCheckPlanD.check = item.check;
                                QcCheckPlanD.errorcause = item.errorcause?.Replace("\"", "").Trim();
                                QcCheckPlanD.errorlevel = item.errorlevel?.Replace("\"", "").Trim();
                                QcCheckPlanD.remark = item.remark;
                                QcCheckPlanD.attachment = item.attachment;
                                QcCheckPlanD.isexec = item.isexec;
                                QcCheckPlanD.custom = item.customer;
                                QcCheckPlanD.create_id = _userManager.UserId;
                                QcCheckPlanD.create_time = DateTime.Now;
                                QcCheckPlanDs.Add(QcCheckPlanD);
                            }
                        }
                    }
                }
                await db.Ado.BeginTranAsync();
                await db.Insertable(QcCheckPlanDs).ExecuteCommandAsync();
                await db.Insertable(QcCheckPlanAdd).ExecuteCommandAsync();
                await db.Ado.CommitTranAsync();
                if (QcCheckPlanAdd.triggertype == ((int)EnumTriggerType.周期触发).ToString() || QcCheckPlanAdd.triggertype == ((int)EnumTriggerType.一次性).ToString())
                {
                    var comtentModel = new ContentModel();
                    comtentModel.cron = QcCheckPlanAdd.content!.Replace("\"", "");
                    comtentModel.interfaceId = "";
                    comtentModel.interfaceName = "";
                    comtentModel.parameter = new List<InterfaceParameter>();
                    comtentModel.parameter!.Add(new InterfaceParameter() { field = "id", value = QcCheckPlanAdd.mainid, defaultValue = "" });
                    if (QcCheckPlanAdd.triggertype == ((int)EnumTriggerType.一次性).ToString())
                        comtentModel.parameter!.Add(new InterfaceParameter() { field = "doonce", value = true.ToString(), defaultValue = "" });
                    comtentModel.localHostTaskId = "QcTaskTimeWorker/CreateTask";
                    comtentModel.startTime = DateTimeOffset.Now.ToUnixTimeMilliseconds();
                    comtentModel.TenantId = _userManager?.TenantId!;
                    comtentModel.TenantDbName = _userManager?.TenantDbName!;
                    comtentModel.ConnectionConfig = _userManager?.ConnectionConfig!;
                    comtentModel.Token = _userManager?.ToKen!;
                    TimeTaskCrInput timeTaskCrInput = new TimeTaskCrInput()
                    {
                        enCode = DateTime.Now.ToString("yyyyMMddHHmmss"),
                        fullName = "生成质检任务" + QcCheckPlanAdd.mainid,
                        executeType = "3",
                        executeContent = comtentModel.ToJsonString(),
                        description = "",
                        sortCode = 99,
                        enabledMark = 1,
                    };
                    await _timeTaskService.DeleteByName(timeTaskCrInput.fullName);
                    await _timeTaskService.Create(timeTaskCrInput, false);
                }
            }
            catch (Exception)
            {
                await db.Ado.RollbackTranAsync();
                throw Oops.Oh(ErrorCode.COM1000);
            }
        }

        /// <summary>
        /// 根据计划生成任务
        /// </summary>
        /// <param name="TriggerPlanEntity"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task CreateTask(TriggerPlanEntity entity)
        {
            var Query = _repository.AsSugarClient().Queryable<QcCheckPlanH, QcCheckPlanAdd, QcCheckPlanMaterial, QcCheckPlanProcess, QcCheckPlanWork>
                 ((a, b, c, d, e) => new object[] {
                        JoinType.Inner,a.id== b.mainid,
                        JoinType.Left,a.id == c.planid,
                        JoinType.Left,a.id == d.planid,
                        JoinType.Left,a.id == e.planid,
                  });
            GetQuery(Query, entity);
            var list = await Query.ToListAsync();
            List<string> removes = new List<string>();
            foreach (var data in list)
            {
                if (!string.IsNullOrEmpty(entity.materialid))
                {
                    if (_repository.AsSugarClient().Queryable<QcCheckPlanMaterial>().Where(p => p.planid == data.id).Any())
                    {
                        if (!_repository.AsSugarClient().Queryable<QcCheckPlanMaterial>().Where(p => p.planid == data.id && p.materialid == entity.materialid).Any())
                        {
                            removes.Add(data.id);
                        }
                    }
                }
                if (!string.IsNullOrEmpty(entity.processid))
                {
                    if (_repository.AsSugarClient().Queryable<QcCheckPlanProcess>().Where(p => p.planid == data.id).Any())
                    {
                        if (!_repository.AsSugarClient().Queryable<QcCheckPlanProcess>().Where(p => p.planid == data.id && p.processid == entity.processid).Any())
                        {
                            removes.Add(data.id);
                        }

                    }
                }
                if (!string.IsNullOrEmpty(entity.workid))
                {
                    if (_repository.AsSugarClient().Queryable<QcCheckPlanWork>().Where(p => p.planid == data.id).Any())
                    {
                        if (!_repository.AsSugarClient().Queryable<QcCheckPlanWork>().Where(p => p.planid == data.id && p.workid == entity.workid).Any())
                        {
                            removes.Add(data.id);
                        }
                    }
                }
            }

            list = list.Where(p => !removes.Contains(p.id)).ToList();
            //   .WhereIF(!string.IsNullOrEmpty(entity.materialid), (a, b, c, d, e) => c.materialid == entity.materialid)
            //     .WhereIF(!string.IsNullOrEmpty(entity.processid), (a, b, c, d, e) => d.processid == entity.processid)
            //    .WhereIF(!string.IsNullOrEmpty(entity.workid), (a, b, c, d, e) => e.workid == entity.workid).ToListAsync();
            Filter(list, entity);
            if (list.Count > 0)
                await SaveTask(list, entity);
        }
        private void GetQuery(ISugarQueryable<QcCheckPlanH, QcCheckPlanAdd, QcCheckPlanMaterial, QcCheckPlanProcess, QcCheckPlanWork> Query, TriggerPlanEntity entity)
        {
            var DictionaryData = _repository.AsSugarClient().Queryable<DictionaryDataEntity, DictionaryTypeEntity>
                ((a, b) => new object[] { JoinType.Left, a.DictionaryTypeId == b.Id, })
                .Where((a, b) => b.FullName == "质检类型选择").ToList();
            var TriggerEvent = new QcTriggerEvent();
            var enumTriggerEvent = entity.triggerevent;
            var remark = RemarkAttribute.GetRemark(enumTriggerEvent);
            var type = DictionaryData.Where(p => p.FullName == remark.CheckType).First().Id;
            TriggerEvent = _repository.AsSugarClient().Queryable<QcTriggerEvent>().Where(p => p.type == type && p.name == remark.CheckContent).First();
            Query = Query.Where((a, b, c, d, e) => b.triggertype == "3" && b.content!.Contains(TriggerEvent.id));
        }
        private void Filter(List<QcCheckPlanH> QcCheckPlanHs, TriggerPlanEntity entity)
        {
            var removePlanHs = new List<QcCheckPlanH>();
            var enumTriggerEvent = entity.triggerevent;
            foreach (var plan in QcCheckPlanHs)
            {
                if (enumTriggerEvent == EnumTriggerEvent.首件检换模具)
                {

                }
                if (enumTriggerEvent == EnumTriggerEvent.首件检换物料批号)
                {

                }

                if (enumTriggerEvent == EnumTriggerEvent.首件检换物料编号)
                {

                }
                if (enumTriggerEvent == EnumTriggerEvent.首件检新的生产任务)
                {

                }
                if (enumTriggerEvent == EnumTriggerEvent.首件检生产任务暂停)
                {

                }

                if (enumTriggerEvent == EnumTriggerEvent.出厂检按入厂频次)
                {

                }
                if (enumTriggerEvent == EnumTriggerEvent.入厂检按物料频次)
                {

                }
                if (enumTriggerEvent == EnumTriggerEvent.入厂检按物料编号)
                {

                }
                if (enumTriggerEvent == EnumTriggerEvent.生产检定量)
                {
                    var number = _repository.AsSugarClient().Queryable<QcCheckPlanAdd>().Where(p => p.mainid == plan.id).First().number;
                    if ((entity.newpronum + entity.oldpronum / number) <= (entity.oldpronum / number))
                        removePlanHs.Add(plan);
                }
                if (enumTriggerEvent == EnumTriggerEvent.生产检定码)
                {

                }
                if (enumTriggerEvent == EnumTriggerEvent.生产检产出频次)
                {
                    var number = _repository.AsSugarClient().Queryable<QcCheckPlanAdd>().Where(p => p.mainid == plan.id).First().number;
                    if ((entity.pronum % number) != 0)
                        removePlanHs.Add(plan);
                }
                if (enumTriggerEvent == EnumTriggerEvent.生产检固定次数)
                {

                }
                if (enumTriggerEvent == EnumTriggerEvent.生产检按流转卡)
                {

                }
            }
            removePlanHs.ForEach(p => { QcCheckPlanHs.Remove(p); });
        }
        private async Task SaveTask(List<QcCheckPlanH> planhs, TriggerPlanEntity entity)
        {
            var DictionaryData = _repository.AsSugarClient().Queryable<DictionaryDataEntity, DictionaryTypeEntity>
               ((a, b) => new object[] { JoinType.Left, a.DictionaryTypeId == b.Id, })
               .Where((a, b) => b.FullName == "质检状态" && a.FullName == "待执行").First();
            var plands = await _repository.AsSugarClient().Queryable<QcCheckPlanD>().Where(p => planhs.Select(p => p.id).ToList().Contains(p.mainid!)).ToListAsync();
            foreach (var planh in planhs)
            {
                var time = DateTime.Now;
                QcCheckExecH qcCheckExecH = new QcCheckExecH();
                qcCheckExecH.id = SnowflakeIdHelper.NextId();
                qcCheckExecH.checktype = planh.checktype;
                qcCheckExecH.status = DictionaryData.Id;
                qcCheckExecH.tasktime = time.ToString("yyyy-MM-dd HH:mm:ss");
                qcCheckExecH.materialid = entity.materialid;
                qcCheckExecH.processid = entity.processid;
                qcCheckExecH.workid = entity.workid;
                qcCheckExecH.create_id = _userManager.UserId;
                qcCheckExecH.create_time = time;
                var ExecDs = new List<QcCheckExecD>();
                foreach (var pland in plands.Where(p => p.mainid == planh.id).ToList())
                {
                    QcCheckExecD QcCheckExecD = new QcCheckExecD();
                    QcCheckExecD.mainid = qcCheckExecH.id;
                    QcCheckExecD.extype = pland.extype;
                    QcCheckExecD.excontent = pland.excontent;
                    QcCheckExecD.check = pland.check;
                    QcCheckExecD.errorcause = pland.errorcause;
                    QcCheckExecD.errorlevel = pland.errorlevel;
                    QcCheckExecD.remark = pland.remark;
                    QcCheckExecD.attachment = pland.attachment;
                    QcCheckExecD.isexec = pland.isexec;
                    QcCheckExecD.custom = pland.custom;
                    QcCheckExecD.typeid = pland.typeid;
                    QcCheckExecD.itemid = pland.itemid;
                    QcCheckExecD.create_id = _userManager.UserId;
                    QcCheckExecD.create_time = time;
                    ExecDs.Add(QcCheckExecD);
                }
                await _repository.AsSugarClient().Insertable(qcCheckExecH).ExecuteCommandAsync();
                await _repository.AsSugarClient().Insertable(ExecDs).ExecuteCommandAsync();
            }
        }

    }
}