using System;
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.Core.Manager;
using JNPF.Common.Enums;
using JNPF.DependencyInjection;
using JNPF.DynamicApiController;
using JNPF.FriendlyException;
using JNPF.JsonSerialization;
using JNPF.VisualDev;
using JNPF.VisualDev.Interfaces;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Mvc;
using Microsoft.CodeAnalysis;
using NPOI.SS.Formula.Eval;
using NPOI.Util;
using SqlSugar;
using Tnb.Common;
using Tnb.QcMgr.Entities;
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 QcCheckItemService : IOverideVisualDevService, IQcCheckItemService, IDynamicApiController, ITransient
    {
        private const string ModuleId = "26477150883109";
        private readonly ISqlSugarRepository<QcCheckItemsH> _repository;
        private readonly IUserManager _userManager;
        public OverideVisualDevFunc OverideFuncs { get; } = new OverideVisualDevFunc();
        public QcCheckItemService(ISqlSugarRepository<QcCheckItemsH> repository, IUserManager userManager)
        {
            _repository = repository;
            _userManager = userManager;
            OverideFuncs.DeleteAsync = Delete;
        }

        private async Task Delete(string id)
        {
            var db = _repository.AsSugarClient();
            var QcCheckItemsH=await db.Queryable< QcCheckItemsH >().Where(p=>p.id==id).FirstAsync();
            var QcCheckItemsRs = await db.Queryable<QcCheckItemsR>().Where(p => p.itemshid == id).ToListAsync() ;
            var QcCheckItemsDs = await db.Queryable<QcCheckItemsD>().Where(p => QcCheckItemsRs.Select(p => p.itemsdid).ToList().Contains(p.id)).ToListAsync();
            await db.Ado.BeginTranAsync();
            await db.Deleteable(QcCheckItemsH).ExecuteCommandAsync();
            await db.Deleteable(QcCheckItemsRs).ExecuteCommandAsync();
            await db.Deleteable(QcCheckItemsDs).ExecuteCommandAsync();
            await db.Ado.CommitTranAsync();
        }

        /// <summary>
        /// 获取质检项集合
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public async Task<dynamic> GetCheckItem()
        {
            var db = _repository.AsSugarClient();
            List<CheckItemOut> CheckItemOuts = new List<CheckItemOut>();
            var datas = await db.Queryable<QcCheckItem>().InnerJoin<QcCheckType>((a, b) => a.type == b.id).Select((a, b) => new
            {
                id = a.id,
                name = a.name,
                code = a.code,
                type = a.type,
                typename = b.name
            }).ToListAsync();
            foreach (var data in datas)
            {
                if (CheckItemOuts.Where(p => p.checktypeid == data.type).Any())
                {
                    var CheckItemOut = CheckItemOuts.Where(p => p.checktypeid == data.type).First();
                    if (CheckItemOut.items == null)
                    {
                        CheckItemOut.items = new List<CheckItem>();
                        CheckItemOut.items.Add(new CheckItem { itemid = data.id, name = data.name!, code = data.code! });
                    }
                    else
                        CheckItemOut.items.Add(new CheckItem { itemid = data.id, name = data.name!, code = data.code! });
                }
                else
                {
                    CheckItemOuts.Add(new CheckItemOut { checktypeid = data.type!, checktypename = data.typename!, items = new List<CheckItem>() });
                    var CheckItemOut = CheckItemOuts.Where(p => p.checktypeid == data.type).First();
                    CheckItemOut.items?.Add(new CheckItem() { itemid = data.id, name = data.name!, code = data.code! });
                }
            }
            return CheckItemOuts;
        }

        /// <summary>
        /// 获取质检项清单
        /// </summary>
        /// <param name="CheckItemInput"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<dynamic> GetCheckItems(CheckItemsInput CheckItemsInput)
        {
            var db = _repository.AsSugarClient();
            var QcCheckItems = await db.Queryable<QcCheckItem>().ToListAsync();
            var QcCheckTypes = await db.Queryable<QcCheckType>().ToListAsync();
            var QcCheckItemsH = await db.Queryable<QcCheckItemsH>().Where(p => p.id == CheckItemsInput.id).FirstAsync();
            List<QcCheckItemsR> QcCheckItemsRs = new List<QcCheckItemsR>();
            List<QcCheckItemsD> QcCheckItemsDs = new List<QcCheckItemsD>();
            if (QcCheckItemsH != null)
            {
                QcCheckItemsRs = await db.Queryable<QcCheckItemsR>().Where(p => p.itemshid == QcCheckItemsH.id).ToListAsync();
                if (QcCheckItemsRs != null)
                    QcCheckItemsDs = await db.Queryable<QcCheckItemsD>().Where(p => QcCheckItemsRs.Select(p => p.itemsdid).ToList().Contains(p.id)).ToListAsync();
            }
            else
                throw Oops.Oh(ErrorCode.COM1005);
            var CheckItemsOut = new CheckItemsOut();
            CheckItemsOut.id = QcCheckItemsH.id;
            CheckItemsOut.name = QcCheckItemsH.name!;
            CheckItemsOut.status = QcCheckItemsH.status!;
            CheckItemsOut.checktypes = new List<CheckTypeOut>();
            if (QcCheckItemsRs != null && QcCheckItemsDs != null)
            {
                foreach (var QcCheckItemsR in QcCheckItemsRs)
                {
                    if (CheckItemsOut.checktypes.Where(p => p.checktypeid == QcCheckItemsR.typeid).ToList().Count == 0)
                    {
                        CheckTypeOut checkType = new CheckTypeOut();
                        checkType.checktypeid = QcCheckItemsR.typeid!;
                        checkType.checktypename = QcCheckTypes.Where(p => p.id == QcCheckItemsR.typeid).First().name!;
                        checkType.items = new List<ItemOut>();
                        CheckItemsOut.checktypes.Add(checkType);
                    }
                    var item = QcCheckItemsDs.Where(p => p.id == QcCheckItemsR.itemsdid).FirstOrDefault();
                    if (item != null)
                    {
                        ItemOut Item = new ItemOut();
                        Item.itemid = QcCheckItemsR.itemid!;
                        Item.itemdid = item.id!;
                        Item.code = QcCheckItems.Where(p => p.id == QcCheckItemsR.itemid).First().code!;
                        Item.name = QcCheckItems.Where(p => p.id == QcCheckItemsR.itemid).First().name!;
                        Item.setData = new Data();
                        Item.setData.extype = item.extype!;
                        Item.setData.excontent = JSON.Deserialize<Excontent>(item.excontent!);
                        Item.setData.check = item.check!;
                        if (!string.IsNullOrEmpty(item.errorcause))
                            Item.setData.errorcause = item.errorcause!.Replace("[", "").Replace("]", "").Split(',', StringSplitOptions.RemoveEmptyEntries);
                        if (!string.IsNullOrEmpty(item.errorlevel))
                            Item.setData.errorlevel = item.errorlevel!.Replace("[", "").Replace("]", "").Split(',', StringSplitOptions.RemoveEmptyEntries);
                        Item.setData.remark = item.remark!;
                        Item.setData.attachment = item.attachment!;
                        Item.setData.customer = item.custom!;
                        if (!string.IsNullOrEmpty(item.isexec))
                            Item.setData.isexec = JSON.Deserialize<Isexec>(item.isexec!);
                        Item.setShow = new Show();
                        Item.setShow.extype = !string.IsNullOrEmpty(Item.setData.extype);
                        Item.setShow.excontent = !string.IsNullOrEmpty(item.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;
                        CheckItemsOut.checktypes.Where(p => p.checktypeid == QcCheckItemsR.typeid).First().items?.Add(Item);
                    }
                }
            }
            return CheckItemsOut;
        }


        /// <summary>
        /// 保存质检项清单
        /// </summary>
        /// <param name="CheckItemInput"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task SaveData(CheckItemsInput CheckItemsInput)
        {
            var db = _repository.AsSugarClient();
            try
            {
                if (!string.IsNullOrEmpty(CheckItemsInput.id))
                    await Delete(CheckItemsInput.id);
                QcCheckItemsH QcCheckItemsH = new QcCheckItemsH();
                QcCheckItemsH.name = CheckItemsInput.name;
                QcCheckItemsH.status = CheckItemsInput.status;
                QcCheckItemsH.create_time = DateTime.Now;
                QcCheckItemsH.create_id = _userManager.UserId;
                List<QcCheckItemsR> QcCheckItemsRs = new List<QcCheckItemsR>();
                List<QcCheckItemsD> QcCheckItemsDs = new List<QcCheckItemsD>();
                if (CheckItemsInput.checktypes != null)
                {
                    foreach (var checktype in CheckItemsInput.checktypes)
                    {
                        if (checktype.items != null)
                        {
                            foreach (var item in checktype.items)
                            {
                                var QcCheckItemsD = new QcCheckItemsD()
                                {
                                    extype = item.extype,
                                    excontent = item.excontent,
                                    check = item.check,
                                    errorcause = item.errorcause?.Replace("\"", "").Trim(),
                                    errorlevel = item.errorlevel?.Replace("\"", "").Trim(),
                                    remark = item.remark,
                                    attachment = item.attachment,
                                    isexec = item.isexec,
                                    custom = item.customer
                                };
                                QcCheckItemsDs.Add(QcCheckItemsD);
                                var QcCheckItemsR = new QcCheckItemsR()
                                {
                                    itemshid = QcCheckItemsH.id,
                                    typeid = checktype.id,
                                    itemid = item.itemid,
                                    itemsdid = QcCheckItemsD.id
                                };

                                QcCheckItemsRs.Add(QcCheckItemsR);
                            }
                        }
                    }
                }
                QcCheckItemsDs.ForEach(p =>
                {
                    p.create_id = _userManager.UserId;
                    p.create_time = DateTime.Now;

                });
                await db.Ado.BeginTranAsync();
                await db.Insertable(QcCheckItemsH).ExecuteCommandAsync();
                await db.Insertable(QcCheckItemsRs).ExecuteCommandAsync();
                await db.Insertable(QcCheckItemsDs).ExecuteCommandAsync();
                await db.Ado.CommitTranAsync();
            }
            catch (Exception)
            {  
                await db.Ado.RollbackTranAsync();
                throw Oops.Oh(ErrorCode.COM1000);
            }
        }
    }
}