using JNPF.Common.Core.Manager;
using JNPF.Common.Enums;
using JNPF.DependencyInjection;
using JNPF.DynamicApiController;
using JNPF.FriendlyException;
using Microsoft.AspNetCore.Mvc;
using SqlSugar;
using Tnb.EquipMgr.Entities;
using Tnb.PerMgr.Entities;
using Tnb.PerMgr.Entities.Dto;
using Tnb.PerMgr.Interfaces;

namespace Tnb.PerMgr
{
    /// <summary>
    /// 工艺参数类型
    /// </summary>
    [ApiDescriptionSettings
        (Tag = ModuleConsts.Tag, Area = ModuleConsts.Area, Order = 700)]
    [Route("api/[area]/[controller]/[action]")]
    public class PerProcessParamTypeService : IPerProcessParamTypeService, IDynamicApiController, ITransient
    {
        private readonly ISqlSugarRepository<PerProcessParamType> _repository;
        private readonly IUserManager _userManager;
        
        public PerProcessParamTypeService(ISqlSugarRepository<PerProcessParamType> repository, IUserManager userManager)
        {
            _userManager = userManager;
            _repository = repository;
        }

        [HttpPost]
        public async Task<dynamic> GetProcessParamType(Dictionary<string, string> dic)
        {
            string equipId = dic["equip_id"];
            var db = _repository.AsSugarClient();
            var equipment = await db.Queryable<EqpEquipment>().Where(x => x.id == equipId).SingleAsync();
            string equipTypeId = equipment?.equip_type_id;

            //List<PerProcessParamType> perProcessParamTypes = await _repository.GetListAsync(x => x.equip_type_id == equipTypeId);
            var result = await db.Queryable<PerProcessParamType>()
                .Where(x => x.equip_type_id == equipTypeId)
                .OrderBy(x=>x.ordinal)
                .Select(x => new
                {
                    tab_id = x.id,
                    tab_name = x.name,
                    children = SqlFunc.Subqueryable<PerProcessParam>()
                        .LeftJoin<PerToleranceCategory>((y,z)=>y.tolerance_category_id==z.id)
                        .Where(y=>y.process_param_type_id==x.id)
                        .OrderBy((y,z)=>y.ordinal)
                        .ToList<ProcessParamTypeChildrenOutput>((y,z)=>new ProcessParamTypeChildrenOutput
                            {
                                process_param_id = y.id,
                                name = y.name,
                                upper_value = z.upper_value,
                                lower_value = z.lower_value
                            }),
                }).ToListAsync();


            return result;

        }

        [HttpPost]
        public async Task<string> SaveData(List<ProcessChildDataInput> input)
        {
            var db = _repository.AsSugarClient();
            DbResult<bool> result = await db.Ado.UseTranAsync(async () =>
            {

                List<PerProcessStandardsD> list = new List<PerProcessStandardsD>();
                if (input != null && input.Count > 0)
                {
                    foreach (var item in input)
                    {
                        list.Add(new PerProcessStandardsD()
                        {
                            process_standards_id = item.process_standards_id,
                            process_param_id = item.process_param_id,
                            value = item.value
                        });
                    }

                    await db.Insertable<PerProcessStandardsD>(list).ExecuteCommandAsync();
                }
                
            });
            if(!result.IsSuccess) throw Oops.Oh(ErrorCode.COM1008);

            return result.IsSuccess ? "保存成功" : result.ErrorMessage;
        }

        [HttpPost]
        public async Task<dynamic> GetProcessStandardsChildrenInfo(Dictionary<string, string> dic)
        {
            string id = dic["id"];
            var db = _repository.AsSugarClient();
            var perProcessStandardsH = await db.Queryable<PerProcessStandardsH>().SingleAsync(x => x.id == id);
            var equipment = await db.Queryable<EqpEquipment>().Where(x => x.id == perProcessStandardsH.equip_id).SingleAsync();
            string equipTypeId = equipment?.equip_type_id;

            var result = await db.Queryable<PerProcessParamType>()
                .Where(a => a.equip_type_id == equipTypeId)
                .OrderBy(a=>a.ordinal)
                .Select(a => new
                {
                    tab_id = a.id,
                    tab_name = a.name,
                    children = SqlFunc.Subqueryable<PerProcessStandardsD>()
                        .LeftJoin<PerProcessParam>((b,c)=>b.process_param_id==c.id)
                        .LeftJoin<PerToleranceCategory>((b,c,d)=>c.tolerance_category_id==d.id)
                        .Where((b,c,d)=>c.process_param_type_id==a.id && b.process_standards_id==id)
                        .OrderBy((b,c,d)=>c.ordinal)
                        .ToList<ProcessParamTypeChildrenOutput>((b,c,d)=>new ProcessParamTypeChildrenOutput
                            {
                                id = b.id,
                                process_param_id = c.id,
                                name = c.name,
                                value = b.value,
                                upper_value = d.upper_value,
                                lower_value = d.lower_value
                            }),
                }).ToListAsync();


            return result;
        }
    }
}