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 Microsoft.AspNetCore.Mvc;
using Microsoft.CodeAnalysis;
using SqlSugar;
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)
        {
            ISqlSugarClient db = _repository.AsSugarClient();
            QcCheckItemsH QcCheckItemsH = await db.Queryable<QcCheckItemsH>().Where(p => p.id == id).FirstAsync();
            List<QcCheckItemsR> QcCheckItemsRs = await db.Queryable<QcCheckItemsR>().Where(p => p.itemshid == id).ToListAsync();
            List<QcCheckItemsD> 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()
        {
            ISqlSugarClient db = _repository.AsSugarClient();
            List<CheckItemOut> CheckItemOuts = new();
            var datas = await db.Queryable<QcCheckItem>().InnerJoin<QcCheckType>((a, b) => a.type == b.id).Select((a, b) => new
            {
                a.id,
                a.name,
                a.code,
                a.type,
                typename = b.name
            }).ToListAsync();
            foreach (var data in datas)
            {
                if (CheckItemOuts.Where(p => p.checktypeid == data.type).Any())
                {
                    CheckItemOut CheckItemOut = CheckItemOuts.Where(p => p.checktypeid == data.type).First();
                    if (CheckItemOut.items == null)
                    {
                        CheckItemOut.items = new List<CheckItem>
                        {
                            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>() });
                    CheckItemOut 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)
        {
            ISqlSugarClient db = _repository.AsSugarClient();
            List<QcCheckItem> QcCheckItems = await db.Queryable<QcCheckItem>().ToListAsync();
            List<QcCheckType> QcCheckTypes = await db.Queryable<QcCheckType>().ToListAsync();
            QcCheckItemsH QcCheckItemsH = await db.Queryable<QcCheckItemsH>().Where(p => p.id == CheckItemsInput.id).FirstAsync();
            List<QcCheckItemsR> QcCheckItemsRs = new();
            List<QcCheckItemsD> QcCheckItemsDs = new();
            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);
            }

            CheckItemsOut CheckItemsOut = new()
            {
                id = QcCheckItemsH.id,
                name = QcCheckItemsH.name!,
                status = QcCheckItemsH.status!,
                checktypes = new List<CheckTypeOut>()
            };
            if (QcCheckItemsRs != null && QcCheckItemsDs != null)
            {
                foreach (QcCheckItemsR QcCheckItemsR in QcCheckItemsRs)
                {
                    if (CheckItemsOut.checktypes.Where(p => p.checktypeid == QcCheckItemsR.typeid).ToList().Count == 0)
                    {
                        CheckTypeOut checkType = new()
                        {
                            checktypeid = QcCheckItemsR.typeid!,
                            checktypename = QcCheckTypes.Where(p => p.id == QcCheckItemsR.typeid).First().name!,
                            items = new List<ItemOut>()
                        };
                        CheckItemsOut.checktypes.Add(checkType);
                    }
                    QcCheckItemsD? item = QcCheckItemsDs.Where(p => p.id == QcCheckItemsR.itemsdid).FirstOrDefault();
                    if (item != null)
                    {
                        ItemOut Item = new()
                        {
                            itemid = QcCheckItemsR.itemid!,
                            itemdid = item.id!,
                            code = QcCheckItems.Where(p => p.id == QcCheckItemsR.itemid).First().code!,
                            name = QcCheckItems.Where(p => p.id == QcCheckItemsR.itemid).First().name!,
                            setData = new Data
                            {
                                extype = item.extype!,
                                excontent = JSON.Deserialize<Excontent>(item.excontent!),
                                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
                        {
                            extype = !string.IsNullOrEmpty(Item.setData.extype),
                            excontent = !string.IsNullOrEmpty(item.excontent),
                            check = !string.IsNullOrEmpty(Item.setData.check),
                            errorcause = Item.setData.errorcause != null,
                            errorlevel = Item.setData.errorlevel != null,
                            remark = !string.IsNullOrEmpty(Item.setData.remark),
                            attachment = !string.IsNullOrEmpty(Item.setData.attachment),
                            customer = !string.IsNullOrEmpty(Item.setData.customer),
                            isexec = Item.setData.isexec != null
                        };
                        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)
        {
            ISqlSugarClient db = _repository.AsSugarClient();
            try
            {
                if (!string.IsNullOrEmpty(CheckItemsInput.id))
                {
                    await Delete(CheckItemsInput.id);
                }

                QcCheckItemsH QcCheckItemsH = new()
                {
                    name = CheckItemsInput.name,
                    status = CheckItemsInput.status,
                    create_time = DateTime.Now,
                    create_id = _userManager.UserId
                };
                List<QcCheckItemsR> QcCheckItemsRs = new();
                List<QcCheckItemsD> QcCheckItemsDs = new();
                if (CheckItemsInput.checktypes != null)
                {
                    foreach (CheckTypeInput checktype in CheckItemsInput.checktypes)
                    {
                        if (checktype.items != null)
                        {
                            foreach (ItemInput item in checktype.items)
                            {
                                QcCheckItemsD QcCheckItemsD = new()
                                {
                                    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);
                                QcCheckItemsR QcCheckItemsR = new()
                                {
                                    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);
            }
        }
    }
}