using Aliyun.OSS;
using DOAN.Model;
using DOAN.Model.Business;
using DOAN.Model.Dto;
using DOAN.Model.MES.dev;
using DOAN.Model.MES.dev.Dto;
using DOAN.Model.MES.process;
using DOAN.Repository;
using DOAN.Service.Business.IBusinessService;
using Infrastructure.Attribute;
using Infrastructure.Extensions;
using JinianNet.JNTemplate;
using NPOI.SS.Formula.Functions;
using NPOI.XSSF.Streaming.Values;
using SqlSugar;
using System;
using System.Linq;
using UAParser;

namespace DOAN.Service.Business
{
    /// <summary>
    /// Service业务层处理
    /// </summary>
    [AppService(ServiceType = typeof(IProcessmodelWorkStepService), ServiceLifetime = LifeTime.Transient)]
    public class ProcessmodelWorkStepService : BaseService<ProcessmodelWorkStep>, IProcessmodelWorkStepService
    {
        /// <summary>
        /// 查询列表
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        public PagedInfo<ProcessmodeWorkStepDto> GetList(ProcessmodelWorkStepQueryDto parm)
        {
            var predicate = Expressionable.Create<ProcessmodelWorkStep>()
                                          .AndIF(!string.IsNullOrEmpty(parm.ProcessCode), p => p.ProcessCode.Contains(parm.ProcessCode))
                                          .AndIF(!string.IsNullOrEmpty(parm.StepCode), p => p.StepCode.Contains(parm.StepCode))
                                          .AndIF(!string.IsNullOrEmpty(parm.StepName), p => p.StepName.Contains(parm.StepName));

            var response = Queryable()
                .Where(predicate.ToExpression())
                .GroupBy(p => p.StepCode)
                .ToPage<ProcessmodelWorkStep, ProcessmodeWorkStepDto>(parm);

            return response;
        }


        /// <summary>
        /// 获取详情
        /// </summary>
        /// <param name="Id"></param>
        /// <returns></returns>
        public ProcessmodelWorkStep GetInfo(long Id)
        {
            var response = Queryable()
                .Where(x => x.Id == Id)
                .First();

            return response;
        }

        /// <summary>
        /// 添加
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public ProcessmodelWorkStep AddProcessmodelWorkStep(ProcessmodelWorkStep model)
        {
            return Context.Insertable(model).ExecuteReturnEntity();
        }

        /// <summary>
        /// 修改
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public int UpdateProcessmodelWorkStep(ProcessmodelWorkStep model)
        {
            return Update(model, true);
        }

        /// <summary>
        /// 获取设备列表
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        public PagedInfo<UniqueValueQueryDto> GetUniqueValueList(UniqueDto parm)
        {
            // 1. 构建查询条件
            var predicate = Expressionable.Create<ProcessmodelWorkStep>()
                .AndIF(!string.IsNullOrEmpty(parm.StepCode), p => p.StepCode == parm.StepCode)
                .AndIF(!string.IsNullOrEmpty(parm.DeviceCode), p => p.UniqueValue.Contains(parm.DeviceCode))
                .ToExpression();

            // 2. 查询总记录数
            int totalCount = Queryable()
                .Where(predicate)
                .Count();

            // 3. 查询当前页数据列表
            int skipCount = (parm.PageNum - 1) * parm.PageSize;
            var dataList = Queryable()
                .Where(predicate)
                .Distinct()
                .LeftJoin<DeviceAccount>((w, a) => w.UniqueValue == a.DeviceCode)
                .Select((w, a) => new UniqueValueQueryDto
                {
                    Id = w.Id,
                    DeviceCode = w.UniqueValue,
                    DeviceName = a.DeviceName,
                    Workshop = a.Workshop,
                    Workline = a.Workline,
                    Status = a.Status,
                    DeviceSpecification = a.DeviceSpecification,
                    ResponsiblePerson = a.ResponsiblePerson
                })
                .Skip(skipCount)
                .Take(parm.PageSize)
                .ToList();

            // 4. 封装分页结果
            return new PagedInfo<UniqueValueQueryDto>
            {
                PageIndex = parm.PageNum,
                PageSize = parm.PageSize,
                TotalNum = totalCount,
                Result = dataList,
                TotalPage = totalCount > 0 ? (totalCount + parm.PageSize - 1) / parm.PageSize : 0
            };
        }

        public List<WorkshopDto> GetAccountList()
        {
            // 1. SqlSugar 链式查询
            var flatData = Context.Queryable<DeviceAccount>()
                .Where(d => !string.IsNullOrEmpty(d.Workshop) && !string.IsNullOrEmpty(d.Workline))
                .Select(d => new
                {
                    d.Workshop,
                    d.Workline,
                    d.DeviceCode,
                    d.DeviceName
                })
                .ToList();

            // 2. 手动构建 DTO 结构
            var result = new List<WorkshopDto>();

            // 先获取所有不重复的车间
            var allWorkshops = flatData.Select(d => d.Workshop).Distinct().ToList();

            foreach (var workshop in allWorkshops)
            {
                // 构建当前车间 DTO
                var workshopDto = new WorkshopDto { Workshop = workshop };

                // 获取当前车间下的所有数据
                var workshopData = flatData.Where(d => d.Workshop == workshop).ToList();

                // 获取当前车间下不重复的产线
                var allWorklines = workshopData.Select(d => d.Workline).Distinct().ToList();

                foreach (var workline in allWorklines)
                {
                    // 构建当前产线 DTO
                    var worklineDto = new WorklineDto { Workline = workline };

                    // 获取当前产线下的所有设备
                    var devices = workshopData
                        .Where(d => d.Workline == workline)
                        .Select(d => new DeviceDto
                        {
                            DeviceCode = d.DeviceCode,
                            DeviceName = d.DeviceName
                        })
                        .ToList();

                    worklineDto.Devices = devices;
                    workshopDto.Worklines.Add(worklineDto);
                }

                result.Add(workshopDto);
            }

            return result;
        }

        /// <summary>
        /// 新增设备
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        /// <exception cref="ArgumentException"></exception>
        /// <exception cref="Exception"></exception>
        public int AddUniqueValue(UniqueQueryDto parm)
        {

            // 查询工步基础信息
            var workStep = Context.Queryable<ProcessmodelWorkStep>()
                .Where(x => x.StepCode == parm.StepCode && x.ProcessCode == parm.ProcessCode)
                .First();

            if (workStep == null)
            {
                throw new Exception("未找到对应的工步信息");
            }

            // 插入新的工步记录
            var newWorkStep = new ProcessmodelWorkStep
            {
                StepCode = workStep.StepCode,
                StepName = workStep.StepName,
                ProcessCode = workStep.ProcessCode,
                Description = workStep.Description,
                IsActive = workStep.IsActive,
                UniqueValue = parm.DeviceCode,
                CreateTime = DateTime.Now
            };

            return Context.Insertable(newWorkStep).ExecuteCommand();
        }

        /// <summary>
        /// 获取工序表
        /// </summary>
        public List<ProcessListDto> GetModelProcessList()
        {
            var response = Context.Queryable<ProcessmodelProcess>()
                                  .Select(p => new ProcessListDto
                                  {
                                      ProcessCode = p.ProcessCode,
                                      ProcessName = p.ProcessName,
                                  })
                                  .ToList();
            return response;
        }
    }
}