using System.Dynamic;
using Aop.Api.Domain;
using JNPF.Common.Core.Manager;
using JNPF.Common.Extension;
using JNPF.Common.Filter;
using JNPF.Common.Security;
using JNPF.DependencyInjection;
using JNPF.DynamicApiController;
using JNPF.Logging;
using JNPF.Systems.Entitys.System;
using JNPF.Systems.Interfaces.System;
using Mapster;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using NPOI.OpenXmlFormats.Shared;
using SqlSugar;
using Tnb.ProductionMgr.Entitys.Dto.PrdManage;
using Tnb.ProductionMgr.Entitys.Dto.WorkOrder;
using Tnb.ProductionMgr.Entitys.Entity;
using Tnb.ProductionPlanMgr.Entitys.Dto.WorkOrder;
using Tnb.ProductionPlanMgr.Interfaces;

namespace Tnb.ProductionPlanMgr
{
    /// <summary>
    /// 生产计划管理
    /// </summary>
    [ApiDescriptionSettings(Tag = "ProductionMgr", Name = "WorkOrderCreate", Order = 700)]
    [Route("api/production/[controller]")]
    public class PrdMoService : IPrdMoService, IDynamicApiController, ITransient
    {
        private readonly ISqlSugarRepository<PrdMo> _repository;
        private readonly IDataBaseManager _dataBaseManager;
        private readonly IUserManager _userManager;
        private readonly IDictionaryDataService _dictionaryDataService;

        public PrdMoService(
            ISqlSugarRepository<PrdMo> repository,
            IDataBaseManager dataBaseManager,
            IUserManager userManager,
            IDictionaryDataService dictionaryDataService
            )
        {
            _repository = repository;
            _dataBaseManager = dataBaseManager;
            _userManager = userManager;
            _dictionaryDataService = dictionaryDataService;
        }
        /// <summary>
        /// 生产工单创建-生产工单下发
        /// </summary>
        /// <param name="input">生产工单下发输入参数</param>
        /// <returns></returns>
        [HttpPut("workorder-issue")]
        public async Task<dynamic> WorkOrderIssue(MoCrInput input)
        {
            if (input is null)
            {
                throw new ArgumentNullException(nameof(input));
            }
            var db = _repository.AsSugarClient();
            var row = await db.Updateable<PrdMo>()
                          .SetColumns(it => new PrdMo { mo_status = "25019232867093" })
                          .Where(it => input.WorkOrderIds.Contains(it.id))
                          .ExecuteCommandAsync();
            return (row > 0);
        }
        /// <summary>
        /// 关联同组工单
        /// </summary>
        /// <param name="input">关联同组工单输入参数</param>
        /// <returns></returns>
        [HttpPost("relevancy")]
        public async Task<dynamic> RelevancySameGroupMo(MoCrInput input)
        {
            var row = -1;
            var list = await _repository.AsSugarClient().Queryable<PrdMo>()
                                                        .InnerJoin<Molds>((a, b) => a.item_code == b.item_code)
                                                        .Where((a, b) => input.WorkOrderIds.Contains(a.id))
                                                        .Select((a, b) => new
                                                        {
                                                            planDate = a.plan_start_date,
                                                            moldId = b.id,
                                                        }).ToListAsync();
            if (list?.Count > 0)
            {
                var planDate = list.FirstOrDefault()?.planDate;
                var moId = list.FirstOrDefault()?.moldId;

                var all = list.Skip(1).All(x => x.planDate == planDate && x.moldId == moId);
                if (all)
                {
                    var groupId = SnowflakeIdHelper.NextId();
                    row = await _repository.AsSugarClient().Updateable<PrdMo>()
                                                           .SetColumns(c => new PrdMo { mo_group_no = groupId })
                                                           .Where(it => input.WorkOrderIds.Contains(it.id))
                                                           .ExecuteCommandAsync();
                }
            }
            return row > 0;
        }


        /// <summary>
        /// 生产工单-生产排产
        /// </summary>
        /// <param name="input">
        ///<br/>{
        ///<br/>    Id:生产任务主键Id
        ///<br/>    MoType:工单类型 1、注塑/挤出 2、组装/包装
        ///<br/>    MoId:工单Id
        ///<br/>    ItemId:产品编号
        ///<br/>    ItemName:产品名称
        ///<br/>    MoldId:模具Id
        ///<br/>    MoldName:模具名称
        ///<br/>    EqpId:设备Id
        ///<br/>    EqpName:设备名称
        ///<br/>    LineId:产线编号
        ///<br/>    LineName:产线名称
        ///<br/>}
        /// </param>
        /// <returns></returns>

        [HttpPost("scheduling")]
        public async Task<dynamic> ProductionScheduling(ProductionSchedulingCrInput input)
        {
            var row = -1;
            if (input.mo_type.HasValue && input.mo_type.Value == 1)
            {
                input.id ??= SnowflakeIdHelper.NextId();
                var entity = input.Adapt<PrdTask>();
                entity.status = "ToBeScheduled"; //任务单状态默认，待排产
                entity.create_id = _userManager.UserId;
                entity.create_time = DateTime.Now;

                var db = _repository.AsSugarClient();
                try
                {
                    await db.Ado.BeginTranAsync();
                    
                    row = await db.Storageable(entity).ExecuteCommandAsync();
                    var taskLogEntity = input.Adapt<PrdTaskLog>();
                    taskLogEntity.id ??= SnowflakeIdHelper.NextId();
                    taskLogEntity.task_id = input.id;
                    taskLogEntity.status ??= "ToBeStarted";
                    taskLogEntity.create_id = _userManager.UserId;
                    taskLogEntity.create_time = DateTime.Now;
                    taskLogEntity.operator_name = _userManager.RealName;

                    //任务状态变更时插入操作记录 
                    if (!db.Queryable<PrdTaskLog>().Where(it => it.task_id == input.id && it.status == taskLogEntity.status).Any())
                    {
                        row = await db.Insertable(taskLogEntity).ExecuteCommandAsync();
                    }

                    if (row > 0)
                    {
                        var obj = (await db.Queryable<PrdMo>().FirstAsync(it => it.id == input.mo_id));
                        obj.input_qty += entity.scheduled_num;
                        var moStatus = "";
                        //判断，已排产数量>=计划数量时将状态改为 已完成
                        if (obj.input_qty >= obj.plan_qty)
                        {
                            moStatus = "25019252113685";
                            
                        }
                        else
                        {
                            //修改工单状态为已排产，同事修改已排产数量
                            moStatus = "25019244276501";
                        }
                        row = await db.Updateable<PrdMo>().SetColumns(it => new PrdMo
                        {
                            mo_status = moStatus,
                            input_qty = obj.input_qty
                        })
                        .Where(it => it.id == entity.mo_id).ExecuteCommandAsync();
                    }

                    await db.Ado.CommitTranAsync();
                }
                catch (Exception ex)
                {
                    Log.Error("生产任务发布时发生错误", ex);
                    await db.Ado.RollbackTranAsync();
                }
            }
            return row > 0;
        }
        /// <summary>
        /// 生产任务下发
        /// </summary>
        /// <returns></returns>
        [HttpPost("task-release")]
        public async Task<dynamic> PrdTaskRelease(PrdTaskReleaseUpInput input)
        {
            if (input is null)
            {
                throw new ArgumentNullException(nameof(input));
            }
            var db = _repository.AsSugarClient(); ;
            var row = await db.Updateable<PrdTask>()
                              .SetColumns(it => new PrdTask { status = "ToBeStarted" })
                              .Where(it => input.TaskIds.Contains(it.id))
                              .ExecuteCommandAsync();
            return (row > 0);
        }




        /// <summary>
        /// 根据产品ID获取模具列表 
        /// </summary>
        /// <param name="itemId">产品ID</param>
        /// <returns></returns>
        /// <remarks>
        /// <br/>return results:
        /// <br/>[
        /// <br/>    {
        /// <br/>        mold_code:模具编号
        /// <br/>        mold_name:模具名称
        /// <br/>        item_name:产品名称
        /// <br/>        item_code:产品编号
        /// <br/>        cavity_num:模穴数
        /// <br/>    }
        /// <br/>]
        /// </remarks>
        [HttpGet("moldlist/{itemId}")]
        public async Task<dynamic> GetMoldListByItemId(string itemId)
        {
            var db = _repository.AsSugarClient();
            var list = await db.Queryable<Molds>().InnerJoin<BasItem>((a, b) => a.item_id == b.id)
                                  .Where((a, b) => a.item_id == itemId)
                                  .Select((a, b) => new MoldListOutput
                                  {
                                      id = a.id,
                                      mold_code = a.mold_code,
                                      mold_name = a.mold_name,
                                      item_name = b.item_name,
                                      item_code = b.item_code,
                                      cavity_num = a.cavity_num,
                                  })
                                  .ToListAsync();
            return list;

        }
        /// <summary>
        /// 查看工单操作记录
        /// </summary>
        /// <param name="taskId">任务ID</param>
        /// <returns></returns>
        [HttpGet("record/{taskId}")]
        public async Task<dynamic> GetMoOperRecord(string taskId)
        {
            //var list = await _repository.AsSugarClient().Queryable<PrdTask>().LeftJoin<PrdTaskLog>((a, b) => a.prd_task_id == b.id)
            //                            .WhereIF(!string.IsNullOrWhiteSpace(input.mo_no),b=>b.id == input.task_no)
            //                            .WhereIF(!string.IsNullOrWhiteSpace(input.task_no), b => b.prd_task_id == input.task_id)
            //                            .WhereIF(!string.IsNullOrWhiteSpace(input.item_code), a => a.item_code == input.item_code)
            //                            .WhereIF(!string.IsNullOrWhiteSpace(input.eqp_code), a => a.eqp_type_code == input.eqp_code)
            //                            .WhereIF(input.plan_start_date.HasValue, a => a.plan_start_date >= input.plan_start_date!.Value)
            //                            .WhereIF(input.plan_end_date.HasValue, a => a.plan_end_date <= input.plan_end_date!.Value)
            //                            .ToListAsync();
            var list = await _repository.AsSugarClient().Queryable<PrdTaskLog>().Where(it => it.id == taskId).ToListAsync();
            var data = list.Adapt<List<PrdTaskOperOutput>>();
            var dic = await _dictionaryDataService.GetDicByTypeId("25572555259157");
            _repository.AsSugarClient().ThenMapper(data, x => x.statusName = dic.ContainsKey(x.status) ? dic[x.status].ToString() : "");
            return data;
        }
    }
}