using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Aspose.Cells.Drawing;
using JNPF.Common.Extension;
using JNPF.Common.Filter;
using JNPF.Common.Security;
using JNPF.DependencyInjection;
using JNPF.DynamicApiController;
using JNPF.Systems.Entitys.Permission;
using JNPF.Systems.Interfaces.System;
using Mapster;
using Microsoft.AspNetCore.Mvc;
using Microsoft.CodeAnalysis.Operations;
using NPOI.POIFS.Properties;
using Spire.Pdf.Widget;
using SqlSugar;
using Tnb.BasicData;
using Tnb.BasicData.Entities;
using Tnb.ProductionMgr.Entities;
using Tnb.ProductionMgr.Entities.Dto.PrdManage;
using Tnb.ProductionMgr.Interfaces;

namespace Tnb.ProductionMgr
{
    /// <summary>
    /// 组装、包装生产提报服务
    /// </summary>
    [ApiDescriptionSettings(Tag = ModuleConst.Tag, Area = ModuleConst.Area, Order = 700)]
    [Route("api/[area]/[controller]/[action]")]

    public class PrdPackReportService : IPrdPackReportService, IDynamicApiController, ITransient
    {
        private readonly ISqlSugarClient _db;
        private readonly IDictionaryDataService _dictionaryDataService;
        private static Dictionary<string, Tuple<string, string>> _dicWorkLine = new Dictionary<string, Tuple<string, string>>();
        public PrdPackReportService(ISqlSugarRepository<PrdMoTask> repository, IDictionaryDataService dictionaryDataService)
        {
            _db = repository.AsSugarClient();
            _dictionaryDataService = dictionaryDataService;
        }
        /// <summary>
        /// 获取组装包装生产任务记录，树形结构
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        public async Task<dynamic> GetList(PrdPackReportQueryInput input)
        {
            if (input == null) throw new ArgumentNullException("input");
            List<PackReportTreeOutput> trees = new();
            var dic = await _dictionaryDataService.GetDicByTypeId(DictConst.PrdTaskStatusTypeId);
            var list = await _db.Queryable<OrganizeEntity>().Where(it => it.Category == "workline").ToListAsync();
            if (_dicWorkLine.Count < 1)
            {

                _dicWorkLine = list.ToDictionary(x => x.Id, x => Tuple.Create<string, string>(x.EnCode, x.FullName));
            }
            bool start = false;
            bool end=false;
            DateTime[] startTimes = new DateTime[2];
            DateTime[] endTimes = new DateTime[2];
            if (input.estimated_start_date != null && input.estimated_start_date.Count() == 2)
            {
                start=true;
                startTimes[0] = GetDateTimeMilliseconds(input.estimated_start_date![0]);
                startTimes[1] = GetDateTimeMilliseconds(input.estimated_start_date![1]);

            }
            if (input.estimated_end_date != null && input.estimated_end_date.Count() == 2)
            {
                end = true;
                endTimes[0] = GetDateTimeMilliseconds(input.estimated_end_date![0]);
                endTimes[1] = GetDateTimeMilliseconds(input.estimated_end_date![1]);

            }
            var items = await _db.Queryable<PrdMoTask>().LeftJoin<BasProcess>((a, b) => a.process_id == b.id).LeftJoin<PrdMo>((a, b, c) => a.mo_id == c.id)
                                     .WhereIF(!string.IsNullOrEmpty(input.mo_task_code), a => a.mo_task_code == input.mo_task_code.Trim())
                                  //   .WhereIF(start, a => a.estimated_start_date != null&& startTimes[0] <= a.estimated_start_date && startTimes[1] >= a.estimated_start_date)
                                  //   .WhereIF(end, a => a.estimated_end_date != null && endTimes[0] <= a.estimated_end_date && endTimes[1] >= a.estimated_end_date)
                                     .WhereIF(!string.IsNullOrEmpty(input.workline), a => list.Where(p => p.EnCode.Contains(input.workline) || p.FullName.Contains(input.workline)).Select(p => p.Id).ToList().Contains(a.workline_id!))
                                     .Where(a => string.IsNullOrEmpty(a.parent_id) && a.schedule_type == 2 && a.mo_task_status != "ToBeScheduled")
                                     .Select((a, b, c) => new PrdMoTask
                                     {
                                         id = a.id,
                                         mo_task_code = a.mo_task_code,
                                         workline_id = a.workline_id,
                                         process_id = a.process_id,
                                         plan_start_date = a.estimated_start_date,
                                         plan_end_date = a.estimated_end_date,
                                         plan_qty = c.scheduled_qty,
                                         // complete_qty = SqlFunc.Subqueryable<PrdReport>().Where(it => it.mo_task_code == a.mo_task_code).Sum(it => it.reported_work_qty),
                                         complete_qty = a.last_process_complete_qty,
                                         mo_task_status = a.mo_task_status,

                                     })
                                     .ToPagedListAsync(input.currentPage, input.pageSize);
            if (start)
                items.list= items.list.Where(a => startTimes[0] <= a.plan_start_date && startTimes[1] >= a.plan_start_date).ToList();
            if (end)
                items.list= items.list.Where(a => endTimes[0] <= a.plan_end_date && endTimes[1] >= a.plan_end_date).ToList();
            _db.ThenMapper(items.list, it =>
            {
                it.mo_task_status = it.mo_task_status.IsNotEmptyOrNull() && dic.ContainsKey(it.mo_task_status) ? dic[it.mo_task_status].ToString() : "";
            });

            if (items != null && items.list != null && items.list.Any())
            {
                foreach (var item in items.list)
                {
                    var node = item.Adapt<PackReportTreeOutput>();
                    node.parentId = "0";
                    if (item.workline_id.IsNotEmptyOrNull())
                    {
                        var workLine = _dicWorkLine.ContainsKey(item.workline_id) ? (Tuple<string, string>)_dicWorkLine[item.workline_id] : null;
                        if (workLine != null)
                        {
                            node.workline_id = $"{workLine.Item1}/{workLine.Item2}";
                        }
                    }
                    node.plan_start_date = item.plan_start_date.HasValue ? item.plan_start_date.Value.ToString("yyyy-MM-dd HH:mm:ss") : "";
                    node.plan_end_date = item.plan_end_date.HasValue ? item.plan_end_date.Value.ToString("yyyy-MM-dd HH:mm:ss") : "";
                    await GetChild(item.id, trees, dic);
                    trees.Add(node);
                }
            }
            var treeList = trees.ToTree();
            if (!string.IsNullOrEmpty(input.process))
            {
                List< PackReportTreeOutput > removelist = new List< PackReportTreeOutput >();
                foreach (var item in treeList)
                {
                    bool flag = false;
                    if (item.process_id != null && item.process_id.Contains(input.process))
                        flag = true;
                    if (item.children != null&& item.children.Count>0)
                    {
                       var childs = item.children.Adapt<List<PackReportTreeOutput>>();
                        if (childs.Where(p => p.process_id.Contains(input.process)).Any())
                            flag = true;
                    }
                    if (!flag)
                        removelist.Add(item);
                     
                }
                removelist.ForEach(p => treeList.Remove(p));
               
            }
            SqlSugarPagedList<PackReportTreeOutput> pagedList = new()
            {
                list = treeList,
                pagination = new Pagination
                {
                    CurrentPage = input.currentPage,
                    PageSize = input.pageSize,
                    Total = treeList.Count
                }
            };
            return PageResult<PackReportTreeOutput>.SqlSugarPageResult(pagedList);
        }
        private static DateTime GetDateTimeMilliseconds(long timestamp)
        {
            long begtime = timestamp * 10000;
            DateTime dt_1970 = new DateTime(1970, 1, 1, 8, 0, 0);
            long tricks_1970 = dt_1970.Ticks;//1970年1月1日刻度
            long time_tricks = tricks_1970 + begtime;//日志日期刻度
            DateTime dt = new DateTime(time_tricks);//转化为DateTime
            return dt;

        }
        private async Task GetChild(string parentId, List<PackReportTreeOutput> nodes, Dictionary<string, object> dic)
        {
            var items = await _db.Queryable<PrdMoTask>()
                .LeftJoin<BasProcess>((a, b) => a.process_id == b.id)
                .LeftJoin<PrdMo>((a, b, c) => a.mo_id == c.id)
                .LeftJoin<BasMbomProcess>((a, b, c, d) => a.mbom_process_id == d.id)
                .Where(a => a.parent_id == parentId && a.mo_task_status != "ToBeScheduled")
                .OrderBy((a, b, c, d) => d.ordinal)
                .Select((a, b, c) => new PrdMoTask
                {
                    id = a.id,
                    mo_task_code = a.mo_task_code,
                    workline_id = a.workline_id,
                    process_id = a.process_id,
                    process_code = b.process_code,
                    process_name = b.process_name,
                    plan_start_date = a.estimated_start_date,
                    plan_end_date = a.estimated_end_date,
                    plan_qty = c.scheduled_qty,
                    //complete_qty = SqlFunc.Subqueryable<PrdReport>().Where(it => it.mo_task_code == a.mo_task_code).Sum(it => it.reported_work_qty),
                    complete_qty = SqlFunc.IsNull(a.reported_work_qty,0) + SqlFunc.IsNull(a.scrap_qty,0),
                    mo_task_status = a.mo_task_status,

                }).ToListAsync();
            _db.ThenMapper(items, it =>
            {
                it.mo_task_status = it.mo_task_status.IsNotEmptyOrNull() && dic.ContainsKey(it.mo_task_status) ? dic[it.mo_task_status].ToString() : "";
            });

            if (items?.Count > 0)
            {
                var nsChild = items.Adapt<List<PackReportTreeOutput>>();
                for (int i = 0; i < nsChild.Count; i++)
                {
                    nsChild[i].parentId = parentId;
                    nsChild[i].process_id = $"{items[i].process_code}/{items[i].process_name}";
                    nsChild[i].plan_start_date = items[i].plan_start_date.HasValue ? items[i].plan_start_date.Value.ToString("yyyy-MM-dd HH:mm:ss") : "";
                    nsChild[i].plan_end_date = items[i].plan_end_date.HasValue ? items[i].plan_end_date.Value.ToString("yyyy-MM-dd HH:mm:ss") : "";
                    
                    if (nsChild[i].workline_id.IsNotEmptyOrNull())
                    {
                        var workLine = _dicWorkLine.ContainsKey(nsChild[i].workline_id) ? (Tuple<string, string>)_dicWorkLine[nsChild[i].workline_id] : null;
                        if (workLine != null)
                        {
                            nsChild[i].workline_id = $"{workLine.Item1}/{workLine.Item2}";
                        }
                    }
                }

                nodes.AddRange(nsChild);
                foreach (var item in items)
                {
                    await GetChild(item.id, nodes, dic);
                }
            }
        }
    }
}