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 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.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.QcMgr.Entities;
using Tnb.QcMgr.Entities.Dto;
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]")]
    public class QcCheckPlanService : IQcCheckPlanService, IDynamicApiController, ITransient
    {
        private readonly ISqlSugarRepository<QcCheckPlanH> _repository;
        private readonly IUserManager _userManager;
        private readonly TimeTaskService _timeTaskService;
        public QcCheckPlanService(ISqlSugarRepository<QcCheckPlanH> repository, IUserManager userManager, TimeTaskService timeTaskService)
        {
            _repository = repository;
            _userManager = userManager;
            _timeTaskService = timeTaskService;
        }

        /// <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!;
            }
            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);
                    Item.setShow.isexec = Item.setData.isexec == null ? false : 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 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;
                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;
                                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);
            }
        }
    }
}