using System.Dynamic;
using JNPF.Common.Core.Manager;
using JNPF.Common.Dtos.VisualDev;
using JNPF.Common.Enums;
using JNPF.Common.Filter;
using JNPF.Common.Security;
using JNPF.DependencyInjection;
using JNPF.DynamicApiController;
using JNPF.FriendlyException;
using JNPF.Systems.Entitys.Permission;
using JNPF.Systems.Interfaces.System;
using JNPF.VisualDev;
using JNPF.VisualDev.Entitys;
using JNPF.VisualDev.Entitys.Dto.VisualDevModelData;
using JNPF.VisualDev.Interfaces;
using Mapster;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using NPOI.SS.Formula.Functions;
using SqlSugar;
using Tnb.EquipMgr.Entities;
using Tnb.EquipMgr.Entities.Dto;
using Tnb.EquipMgr.Interfaces;
using Tnb.ProductionMgr.Entities;

namespace Tnb.EquipMgr
{
    /// <summary>
    /// 模具领用接口
    /// </summary>
    [ApiDescriptionSettings(Tag = ModuleConsts.Tag, Area = ModuleConsts.Area, Order = 700)]
    [Route("api/[area]/[controller]/[action]")]
    [OverideVisualDev(ModuleId)]
    public class ToolMoldRequisitionService : IOverideVisualDevService, IToolMoldRequisitionService,
        IDynamicApiController, ITransient
    {
        private const string ModuleId = "27254745336853";
        private readonly ISqlSugarClient _db;
        private readonly IRunService _runService;
        private readonly IVisualDevService _visualDevService;
        private readonly IBillRullService _billRuleService;
        private readonly IUserManager _userManager;
        public OverideVisualDevFunc OverideFuncs { get; } = new OverideVisualDevFunc();

        public ToolMoldRequisitionService(
            ISqlSugarRepository<ToolMoldRequisition> repository,
            IRunService runService,
            IVisualDevService visualDevService,
            IBillRullService billRullService,
            IUserManager userManager
        )
        {
            _db = repository.AsSugarClient();
            _runService = runService;
            _visualDevService = visualDevService;
            OverideFuncs.GetListAsync = GetList;
            OverideFuncs.CreateAsync = Create;
            _billRuleService= billRullService;
            _userManager= userManager;
        }

        private async Task<dynamic> GetList(VisualDevModelListQueryInput input)
        {
            Dictionary<string, object>? queryJson = new();
            string? code = "";
            DateTime[]? requisitionTimeArr = null;
            DateTime[]? estimatedReturnArr = null;
            if (input != null && !string.IsNullOrEmpty(input.queryJson))
            {
                queryJson = JsonConvert.DeserializeObject<Dictionary<string, object>>(input?.queryJson ?? "");
            }

            if (queryJson!.TryGetValue("code", out object? value))
            {
                code = value.ToString();
            }
            if (queryJson!.TryGetValue("requisition_time", out object? value1))
            {
                requisitionTimeArr = value1.ToObject<long[]>().Select(x => DateTimeOffset.FromUnixTimeSeconds(x / 1000).ToLocalTime().DateTime).ToArray();
            }
            if (queryJson!.TryGetValue("estimated_return_time", out object? value2))
            {
                estimatedReturnArr = value2.ToObject<long[]>().Select(x => DateTimeOffset.FromUnixTimeSeconds(x / 1000).ToLocalTime().DateTime).ToArray();
            }

            SqlSugarPagedList<ToolMoldRequisitionListOutput> result = await _db.Queryable<ToolMoldRequisition>()
                .LeftJoin<PrdMoTask>((a, b) => a.mo_task_id == b.id)
                .LeftJoin<EqpEquipment>((a, b, c) => a.equip_id == c.id)
                .LeftJoin<UserEntity>((a, b, c, d) => a.recipient_id == d.Id)
                .LeftJoin<ToolMolds>((a, b, c, d, e) => a.mold_id == e.id)
                .WhereIF(!string.IsNullOrEmpty(code), (a, b, c, d) => a.code.Contains(code))
                .WhereIF(requisitionTimeArr != null, (a, b, c, d) => a.requisition_time >= requisitionTimeArr[0] && a.requisition_time <= requisitionTimeArr[1])
                .WhereIF(estimatedReturnArr != null, (a, b, c, d) => a.estimated_return_time >= estimatedReturnArr[0] && a.estimated_return_time <= estimatedReturnArr[1])
                .Select((a, b, c, d, e) => new ToolMoldRequisitionListOutput
                {
                    id = a.id,
                    code = a.code,
                    mold_id = e.mold_code,
                    mo_task_id = b.mo_task_code,
                    equip_id = c.code + "/" + c.name,
                    recipient_id = d.RealName,
                    estimated_return_time = a.estimated_return_time == null ? "" : a.estimated_return_time.Value.ToString("yyyy-MM-dd"),
                    requisition_time = a.requisition_time == null ? "" : a.requisition_time.Value.ToString("yyyy-MM-dd"),
                    remark = a.remark
                }).ToPagedListAsync(input.currentPage, input.pageSize);

            return PageResult<ToolMoldRequisitionListOutput>.SqlSugarPageResult(result);
        }
        private DateTime GetDateTime(long value)
        {
 
            DateTime unixStartTime = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);
            DateTime dateTime = unixStartTime.AddMilliseconds(value);
            return dateTime;
        }
        private async Task<dynamic> Create(VisualDevModelDataCrInput input)
        {
            string Code = await _billRuleService.GetBillNumber("moldRequisition");
            DbResult<bool> result = await _db.Ado.UseTranAsync(async () =>
            {
                ToolMoldRequisition toolMoldRequisition = new ToolMoldRequisition();
                toolMoldRequisition.code = Code;
                toolMoldRequisition.mold_id= input.data[nameof(ToolMoldRequisition.mold_id)].ToString();
                toolMoldRequisition.mo_task_id = input.data[nameof(ToolMoldRequisition.mo_task_id)].ToString();
                toolMoldRequisition.equip_id = input.data[nameof(ToolMoldRequisition.equip_id)].ToString();
                if (input.data[nameof(ToolMoldRequisition.requisition_time)] != null)
                {
                    toolMoldRequisition.requisition_time = GetDateTime(long.Parse(input.data[nameof(ToolMoldRequisition.requisition_time)].ToString()!));
                }
                if (input.data[nameof(ToolMoldRequisition.estimated_return_time)] != null)
                {
                    toolMoldRequisition.estimated_return_time = GetDateTime(long.Parse(input.data[nameof(ToolMoldRequisition.estimated_return_time)].ToString()!));
                }
               
                toolMoldRequisition.recipient_id = input.data[nameof(ToolMoldRequisition.recipient_id)].ToString();
                if (input.data.ContainsKey(nameof(ToolMoldRequisition.remark)))
                {
                    toolMoldRequisition.remark = input.data[nameof(ToolMoldRequisition.remark)].ToString();
                }
                toolMoldRequisition.create_time = DateTime.Now;
                toolMoldRequisition.create_id = _userManager.UserId;
                await _db.Insertable(toolMoldRequisition).ExecuteCommandAsync();
                //  VisualDevEntity? templateEntity = await _visualDevService.GetInfoById(ModuleId, true);
                //  await _runService.Create(templateEntity, input);


                _ = await _db.Updateable<ToolMolds>().SetColumns(x => x.mold_status == Tnb.BasicData.DictConst.SCTypeId)
                    .Where(X => X.id == input.data["mold_id"]).ExecuteCommandAsync();
            });

            return !result.IsSuccess ? throw Oops.Oh(ErrorCode.COM1008) : (dynamic)(result.IsSuccess ? "保存成功" : result.ErrorMessage);
        }
        [HttpPost]
        public async Task<dynamic> GetTools(ToolInput toolinput)
        {
            Dictionary<string, string> dic = new()
            {
                { "26149307089941", "在库" },
                { "26149309121045", "生产" },
                { "26149311082005", "保养" },
                { "26149314425877", "报废" },
                { "26149312750101", "外协" },
                { "26149320818965", "维修" }
            };
            List<dynamic> result = new();
            List<ToolLocation> BasLocations = await _db.Queryable<ToolLocation>().ToListAsync();
            List<ToolMolds> ToolMolds = await _db.Queryable<ToolMolds>()
              .WhereIF(!string.IsNullOrEmpty(toolinput.keyword), p => p.mold_code!.Contains(toolinput.keyword!) || p.mold_name!.Contains(toolinput.keyword!))
              .WhereIF(!string.IsNullOrEmpty(toolinput.status), p => p.mold_status == dic.Where(p => p.Value == toolinput.status).First().Key)
              .ToListAsync();
            if (string.IsNullOrEmpty(toolinput.sort))
            {
                if (toolinput.sort == "mold_code")
                {
                    ToolMolds = ToolMolds.OrderByDescending(p => p.mold_code).ToList();
                }
            }
            foreach (ToolMolds tool in ToolMolds)
            {
                dynamic info = new ExpandoObject();
                info.id = tool.id;
                info.mold_code = tool.mold_code;
                info.mold_name = tool.mold_name;
                info.mold_status = dic.Where(p => p.Key == tool.mold_status).Any() ? dic.Where(p => p.Key == tool.mold_status).First().Value : "";
                info.warehosue_id = tool.warehosue_id;
                info.location_id = BasLocations.Where(p => p.id == tool.location_id).Any() ? BasLocations.Where(p => p.id == tool.location_id).First().location_code : "";
                result.Add(info);
            }
            return result;
        }
    }
}