using Furion.DatabaseAccessor;
using Furion.DatabaseAccessor.Extensions;
using Furion.DependencyInjection;
using Furion.DynamicApiController;
using Furion.FriendlyException;
using iWare.Wms.Core;
using iWare.Wms.Core.Enum;
using iWare.Wms.Core.Util;
using Mapster;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using System.ComponentModel;
using System.Drawing.Printing;
using System.Linq.Dynamic.Core;
using System.Text;
using System.Web;

namespace iWare.Wms.Application
{
    /// <summary>
    /// 在制品监控服务
    /// </summary>
    [ApiDescriptionSettings("数据查询服务", Name = "WorkPieceInfo", Order = 100)]
    [Route("api/[Controller]")]
    public class WorkPieceInfoService : IWorkPieceInfoService, IDynamicApiController, ITransient
    {
        private readonly IRepository<WorkPieceInfo, MasterDbContextLocator> _workPieceInfoRep;
        private readonly IRepository<WorkPieceInfoLog, MasterDbContextLocator> _workPieceInfoLogRep;
        private readonly IRepository<EquipmentCurrentMonitor, MasterDbContextLocator> _equipmentCurrentMonitorRep;
        private readonly IRepository<EquipmentBaseInfo, MasterDbContextLocator> _equipmentBaseInfoRep;
        private readonly IRepository<SysDictType, MasterDbContextLocator> _sysDictTypeRep;
        private readonly IRepository<SysDictData, MasterDbContextLocator> _sysDictDataRep;

        /// <summary>
        /// 在制品监控构造
        /// </summary>
        /// <param name="workPieceInfoRep"></param>
        /// <param name="equipmentBaseInfoRep"></param>
        /// <param name="equipmentCurrentMonitorRep"></param>
        /// <param name="sysDictTypeRep"></param>
        /// <param name="sysDictDataRep"></param>
        public WorkPieceInfoService(
            IRepository<WorkPieceInfo, MasterDbContextLocator> workPieceInfoRep,
            IRepository<EquipmentBaseInfo, MasterDbContextLocator> equipmentBaseInfoRep,
            IRepository<EquipmentCurrentMonitor, MasterDbContextLocator> equipmentCurrentMonitorRep,
            IRepository<SysDictType, MasterDbContextLocator> sysDictTypeRep,
            IRepository<SysDictData, MasterDbContextLocator> sysDictDataRep
,
            IRepository<WorkPieceInfoLog, MasterDbContextLocator> workPieceInfoLogRep        )
        {
            _workPieceInfoRep = workPieceInfoRep;
            _equipmentBaseInfoRep = equipmentBaseInfoRep;
            _equipmentCurrentMonitorRep = equipmentCurrentMonitorRep;
            _sysDictTypeRep = sysDictTypeRep;
            _sysDictDataRep = sysDictDataRep;
            _workPieceInfoLogRep = workPieceInfoLogRep;
        }

        /// <summary>
        /// 添加字典类型(个别基础信息维护)
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("SaveBasicInfo")]
        public async Task SaveBasicInfo(SaveBasicInfoInput input)
        {
            var basic = _sysDictTypeRep.Where(u => u.Code == input.Code).FirstOrDefault();
            if(basic==null||basic.Id<1)
            {
                var dictType = input.Adapt<SysDictType>();
                dictType.Name = dictType.Code;
                await _sysDictTypeRep.InsertAsync(dictType);
            }
            else
            {
                basic.Remark = input.Remark;
            }
        }
        /// <summary>
        /// 添加字典类型(个别基础信息维护)
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpGet("GetBasicInfo")]
        public async Task<List<SaveBasicInfoInput>> GetBasicInfo()
        {
            List<SaveBasicInfoInput> returnlist = new List<SaveBasicInfoInput>();
            returnlist = _sysDictTypeRep.Entities.ProjectToType<SaveBasicInfoInput>().ToList();
            return returnlist;

        }

        /// <summary>
        /// 分页查询在制品监控
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpGet("page")]
        public async Task<PageResult<WorkPieceInfoOutput>> Page([FromQuery] WorkPieceInfoSearch input)
        {
            //var workPieceInfos = await _workPieceInfoRep.DetachedEntities
            //   .Join(_equipmentBaseInfoRep.DetachedEntities, a => a.EquipmentID, b => b.EquipmentId, (a, b) => new { a, b })
            //   .Join(_equipmentCurrentMonitorRep.DetachedEntities, c => c.a.EquipmentID, d => d.EquipmentID, (c, d) => new { c, d })
            //   .Join(_sysDictDataRep.DetachedEntities, e => e.d.EquipmentCurrentState, f => f.Code, (e, f) => new { e, f })
            //   .Join(_sysDictTypeRep.DetachedEntities, g => g.f.TypeId, h => h.Id, (f, g) => new { f, g })
            //   .Where(x => (x.g.Code.Equals("equipment_state") && (string.IsNullOrEmpty(input.EquipmentCurrentState) ? true : x.f.f.Code.Equals   (input.EquipmentCurrentState))))
            //   .Where(!string.IsNullOrEmpty(input.WorkPieceID), u => u.f.e.c.a.WorkPieceID.Contains(input.WorkPieceID))
            //   .Where(!string.IsNullOrEmpty(input.QualityState.ToString()), u => u.f.e.c.a.QualityState == input.QualityState)
            //   .Where(!string.IsNullOrEmpty(input.EquipmentID), u => u.f.e.c.a.EquipmentID.Equals(input.EquipmentID))
            //   .Where(!string.IsNullOrEmpty(input.WorkingProcedureCurrent), u => u.f.e.c.a.WorkingProcedureCurrent.Equals(input.WorkingProcedureCurrent))
            //   .Select(s => new WorkPieceInfoOutput
            //   {
            //       Id = s.f.e.c.a.Id,
            //       WorkPieceID = s.f.e.c.a.WorkPieceID,
            //       WorkingProcedureCurrent = s.f.e.c.a.WorkingProcedureCurrent,
            //       WorkPieceCurrentPosition = s.f.e.c.a.WorkPieceCurrentPosition,
            //       WorkingProcedureStartTime = s.f.e.c.a.WorkingProcedureStartTime,
            //       QualityState = s.f.e.c.a.QualityState,
            //       EquipmentID = s.f.e.c.a.EquipmentID,
            //       EquipmentName = s.f.e.c.b.EquipmentName,
            //       EquipmentCurrentState = s.f.e.d.EquipmentCurrentState,
            //       EquipmentCurrentStateName = s.f.f.Value,
            //   })
            //   .Distinct()
            //   .OrderBy(PageInputOrder.OrderBuilder<WorkPieceInfoSearch>(input))
            //   .ProjectToType<WorkPieceInfoOutput>()
            //   .ToADPagedListAsync(input.PageNo, input.PageSize);


            var workPieceInfos = await _workPieceInfoRep.DetachedEntities
                .GroupJoin(_equipmentBaseInfoRep.DetachedEntities, a => a.EquipmentID, b => b.EquipmentId, (a, bGroup) => new { a, bGroup })
                .SelectMany(ab => ab.bGroup.DefaultIfEmpty(), (ab, b) => new { ab.a, b })
                .GroupJoin(_equipmentCurrentMonitorRep.DetachedEntities, ab => ab.a.EquipmentID, d => d.EquipmentID, (ab, dGroup) => new { ab.a, ab.b, dGroup })
                .SelectMany(abd => abd.dGroup.DefaultIfEmpty(), (abd, d) => new { abd.a, abd.b, d })
                .Where(x => string.IsNullOrEmpty(input.WorkPieceID) || x.a.WorkPieceID.Contains(input.WorkPieceID))
                .Where(x => string.IsNullOrEmpty(input.QualityState.ToString()) || x.a.QualityState == input.QualityState)
                .Where(x => string.IsNullOrEmpty(input.EquipmentID) || x.a.EquipmentID.Equals(input.EquipmentID))
                .Where(x => string.IsNullOrEmpty(input.WorkingProcedureCurrent) || x.a.WorkingProcedureCurrent.Equals(input.WorkingProcedureCurrent))   
                .Where(x=>x.a.WorkPieceState !=((int)EnumWorkPieceState.FinishedProducts))
                .Where(o => !string.IsNullOrEmpty(o.a.WorkPieceID))
                .Where(!string.IsNullOrEmpty(input.StartTimeBeginTime.ToString()), u => u.a.WorkPieceinitOnlineTime >= input.StartTimeBeginTime)
                .Where(!string.IsNullOrEmpty(input.StartTimeEndTime.ToString()), u => u.a.WorkPieceinitOnlineTime <= input.StartTimeEndTime)
                .Select(s => new WorkPieceInfoOutput
                {
                    Id = s.a.Id,
                    WorkPieceID = s.a.WorkPieceID,
                    WorkingProcedureCurrent = s.a.WorkingProcedureCurrent,
                    WorkPieceCurrentPosition = s.a.WorkPieceCurrentPosition,
                    WorkPieceinitOnlineTime = s.a.WorkPieceinitOnlineTime,
                    WorkingProcedureStartTime = s.a.WorkingProcedureStartTime,
                    WorkingProcedureEndTime = s.a.WorkingProcedureEndTime,
                    QualityState = s.a.QualityState,
                    EquipmentID = s.a.EquipmentID,
                    EquipmentName = s.b.EquipmentName,
                    EquipmentCurrentState = s.d.EquipmentCurrentState,
                    WorkPieceState = s.a.WorkPieceState
                    //EquipmentCurrentStateName = s.f.Value,
                })
                .Distinct()
                //.OrderBy(PageInputOrder.OrderBuilder<WorkPieceInfoSearch>(input))
                .OrderByDescending(o=>o.WorkingProcedureStartTime)
                .ProjectToType<WorkPieceInfoOutput>()
                .ToADPagedListAsync(input.PageNo, input.PageSize);

            return workPieceInfos;
        }

        /// <summary>
        /// 根据在制品监控信息导出Excel
        /// </summary>
        /// <param name="input">在制品监控信息</param>
        /// <returns>导出的Excel文件</returns>
        [HttpGet("toExcel")]
        public async Task<IActionResult> ToExcelAsync([FromQuery] WorkPieceInfoSearch input)
        {
            var workPieceInfos = await _workPieceInfoRep.DetachedEntities
                .GroupJoin(_equipmentBaseInfoRep.DetachedEntities, a => a.EquipmentID, b => b.EquipmentId, (a, bGroup) => new { a, bGroup })
                .SelectMany(ab => ab.bGroup.DefaultIfEmpty(), (ab, b) => new { ab.a, b })
                .GroupJoin(_equipmentCurrentMonitorRep.DetachedEntities, ab => ab.a.EquipmentID, d => d.EquipmentID, (ab, dGroup) => new { ab.a, ab.b, dGroup })
                .SelectMany(abd => abd.dGroup.DefaultIfEmpty(), (abd, d) => new { abd.a, abd.b, d })
                .Where(x => string.IsNullOrEmpty(input.WorkPieceID) || x.a.WorkPieceID.Contains(input.WorkPieceID))
                .Where(x => string.IsNullOrEmpty(input.QualityState.ToString()) || x.a.QualityState == input.QualityState)
                .Where(x => string.IsNullOrEmpty(input.EquipmentID) || x.a.EquipmentID.Equals(input.EquipmentID))
                .Where(x => string.IsNullOrEmpty(input.WorkingProcedureCurrent) || x.a.WorkingProcedureCurrent.Equals(input.WorkingProcedureCurrent))
                .Where(x => x.a.WorkPieceState != ((int)EnumWorkPieceState.FinishedProducts))
                .Where(o => !string.IsNullOrEmpty(o.a.WorkPieceID))
              .Where(!string.IsNullOrEmpty(input.StartTimeBeginTime.ToString()), u => u.a.WorkPieceinitOnlineTime >= input.StartTimeBeginTime)
              .Where(!string.IsNullOrEmpty(input.StartTimeEndTime.ToString()), u => u.a.WorkPieceinitOnlineTime <= input.StartTimeEndTime)
                .Select(s => new WorkPieceInfoOutput
                {
                    Id = s.a.Id,
                    WorkPieceID = s.a.WorkPieceID,
                    WorkingProcedureCurrent = s.a.WorkingProcedureCurrent,
                    WorkPieceinitOnlineTime = s.a.WorkPieceinitOnlineTime,
                    WorkPieceCurrentPosition = s.a.WorkPieceCurrentPosition,
                    WorkingProcedureStartTime = s.a.WorkingProcedureStartTime,
                    WorkingProcedureEndTime = s.a.WorkingProcedureEndTime,
                    QualityState = s.a.QualityState,
                    WorkPieceState = s.a.WorkPieceState
                })
              .Distinct()
              .OrderBy(PageInputOrder.OrderBuilder<WorkPieceInfoSearch>(input))
              .ProjectToType<WorkPieceInfoExcelOutput>()
               .ToListAsync();

            //foreach (WorkPieceInfoExcelOutput item in workPieceInfos)
            //{
            //    //item.WorkingProcedureStartTime = string.IsNullOrEmpty(item.WorkingProcedureStartTime) ? "" : Convert.ToDateTime(item.WorkingProcedureStartTime).ToString("yyyy-MM-dd hh:mm");

            //    if ("1".Equals(item.QualityStateName))
            //    {
            //        item.QualityStateName = "合格";
            //    }
            //    else if ("2".Equals(item.QualityStateName))
            //    {
            //        item.QualityStateName = "不合格";
            //    }
            //    else if ("3".Equals(item.QualityStateName))
            //    {
            //        item.QualityStateName = "疑似";
            //    }
            //    else
            //    {
            //        item.QualityStateName = "";
            //    }
            //}

            MemoryStream ms = new();
            DataConvertUtil.ToExcelData(workPieceInfos, _sysDictTypeRep, _sysDictDataRep, out List<string> headers,
                out List<List<object>> data, out string sheetName);

            ExcelUtil.ToExcel(headers, data, sheetName, ms);
            ms.Position = 0;
            var fileName = HttpUtility.UrlEncode($"{sheetName}[{DateTimeOffset.Now:yyyy-MM-dd}].xlsx", Encoding.GetEncoding("UTF-8"));
            return new FileStreamResult(ms, "application/octet-stream") { FileDownloadName = fileName };
        }

        /// <summary>
        /// 在制品监控信息批量/单个修改质量状态
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("batckUpdate")]
        public async Task BatckUpdate(UpdQualityStateInput input)
        {
            if (input == null || input.WorkPieceInfoLst.Count == 0 )
            {
                throw Oops.Oh("修改工件信息失败：数据不能为空！");
            }
            if(string.IsNullOrEmpty(input.QualityState)&& string.IsNullOrEmpty(input.WorkingProcedureCurrent))
            {
                throw Oops.Oh("修改工件信息失败：质量状态和工序信息 至少要选一个！");
            }

            if (input.Password == null||!input.Password.Equals("123456"))
            {
                throw Oops.Oh("修改工件质量状态失败：密码输入错误！");
            }
            if(!string.IsNullOrEmpty(input.QualityState))
            {
                if (!(input.QualityState.Equals("1") || input.QualityState.Equals("2") || input.QualityState.Equals("3")))
                {
                    throw Oops.Oh($"修改工件质量状态失败：传入待修改质量状态不对！");
                }

                string QualityHistoryState = string.Empty;
                foreach (WorkPieceInfoSearch item in input.WorkPieceInfoLst)
                {
                    if (string.IsNullOrEmpty(QualityHistoryState))
                    {
                        QualityHistoryState = item.QualityHistoryState;
                    }
                    else
                    {
                        if (!QualityHistoryState.Equals(item.QualityHistoryState.ToString()))
                        {
                            throw Oops.Oh($"只能选中相同的质量状态进行修改!");
                        }
                    }
                }
            }
            if(!string.IsNullOrEmpty(input.WorkingProcedureCurrent))
            {

                if (input.WorkingProcedureCurrent.Length!=4)
                {
                    throw Oops.Oh($"修改工件信息失败：传入修改的工序信息【{input.WorkingProcedureCurrent}】不对！");
                }
                string Procedure = string.Empty;
                foreach (WorkPieceInfoSearch item in input.WorkPieceInfoLst)
                {
                    if (string.IsNullOrEmpty(Procedure))
                    {
                        Procedure = item.WorkingProcedureCurrent;
                    }
                    else
                    {
                        if (!Procedure.Equals(item.WorkingProcedureCurrent.ToString()))
                        {
                            throw Oops.Oh($"只能选中相同的工序信息进行修改!");
                        }
                    }
                }
            }

            List<WorkPieceInfo> updatelist = new List<WorkPieceInfo>();
            List<WorkPieceInfoLog> addloglist = new List<WorkPieceInfoLog>();
            foreach (WorkPieceInfoSearch item in input.WorkPieceInfoLst)
            {
                WorkPieceInfo workPieceInfo = _workPieceInfoRep.Where(w => w.Id == item.Id).FirstOrDefault();
                if (workPieceInfo is null)
                {
                    throw Oops.Oh($"修改工件信息失败：工件主键ID{item.Id}不存在！");
                }
                WorkPieceInfoLog infolog = EntityPropHelper.Mapper<WorkPieceInfoLog, WorkPieceInfo>(workPieceInfo);
                infolog.LogAddRemark = $"【{CurrentUserInfo.Name}】 PC端手动修改质量信息或当期工序信息";

                if (!string.IsNullOrEmpty(input.QualityState))
                {
                    infolog.LogAddRemark+=$"质量信息[{workPieceInfo.QualityState ?? 0}]到[{input.QualityState}]";
                    workPieceInfo.QualityState = Convert.ToInt32(input.QualityState);
                }
                if (input.WorkingProcedureCurrent != null)
                {
                    infolog.LogAddRemark += $"工序 [{workPieceInfo.WorkingProcedureCurrent}]到[{input.WorkingProcedureCurrent}]";
                    workPieceInfo.WorkingProcedureCurrent = input.WorkingProcedureCurrent;
                }
                updatelist.Add(workPieceInfo);
                infolog.Id = Yitter.IdGenerator.YitIdHelper.NextId();
                infolog.WorkPieceInfoID = workPieceInfo.Id;
                infolog.LogAddTime = DateTime.Now;
                addloglist.Add(infolog);
            }
            await _workPieceInfoLogRep.InsertAsync(addloglist);
            await _workPieceInfoRep.UpdateAsync((updatelist));
        }

        public async Task AddWorkPieceInfoLogAsync(WorkPieceInfoLog input)
        {

            await _workPieceInfoLogRep.InsertNowAsync(input);
        }
        
    }
}