using PadApplication.DB;
using PadApplication.Entites.DbModels;
using PadApplication.Entites.Dto;
using System.Net.Http;
using System.Text;
using Newtonsoft.Json;
using SqlSugar;

namespace PadApplication.Services;

/// <summary>
///     工单状态管理类,负责工单状态相关的数据操作
///     继承自Repository<MesOrderSta>基类,包含基础的CRUD操作
/// </summary>
public class MesOrderStaManager : Repository<MesOrderSta>
{
    private readonly MesQaItemsDetect02Manager
        mesQaItemsDetect02Manager = new();

    /// <summary>
    ///     更新不良品ID
    /// </summary>
    /// <param name="dto">包含不良品ID(ngId)和状态ID(staId)的数据传输对象</param>
    /// <returns>更新是否成功</returns>
    public bool UpdateNg(OrderMachineDto dto)
    {
        // 更新MesOrderSta表中指定ID记录的不良品ID
        return Db.Updateable<MesOrderSta>()
            // 设置NgId字段为传入的ngId值
            .SetColumns(s => s.NgId == dto.ngId)
            // 根据主键Id匹配记录
            .Where(s => s.Id == dto.staId)
            // 执行更新并判断影响行数是否大于0
            .ExecuteCommand() > 0;
    }

    /// <summary>
    ///     根据工单号查找工单状态信息
    /// </summary>
    /// <param name="query">包含工单ID的查询条件</param>
    /// <returns>工单状态信息,包含工单状态等详细信息</returns>
    public MesOrderSta FindByOrderNo(OrderMachineDto query)
    {
        // 查询MesOrderSta表获取工单状态记录
        var mesOrderSta = Db.Queryable<MesOrderSta>()
            .Where(s => s.OrderId == query.OrderId)
            .First();

        // 如果未找到记录,返回空对象
        if (mesOrderSta == null) return new MesOrderSta();

        // 查询Womdaa表获取工单主表信息
        var womdaa = Db.Queryable<Womdaa>()
            .Where(a => a.Id == query.OrderId).First();

        // 判空处理，避免空引用异常
        mesOrderSta.OrderStatus = womdaa != null ? womdaa.Daa018 : null;
        return mesOrderSta;
    }

    /// <summary>
    ///     更新换模时间
    /// </summary>
    /// <param name="entity">工单状态实体,包含换模开始/结束时间</param>
    /// <returns>更新是否成功</returns>
    public bool ChangeMoldTime(MesOrderSta entity)
    {
        var vWom = Db.Queryable<VWom>()
            .Where(s => s.MachineNo == entity.MachineNo)
            .OrderByDescending(s => s.WGSJ)
            .First();

        return Db.Updateable<MesOrderSta>()
            // 如果有换模开始时间则更新
            // .SetColumnsIF(entity.ChangeMoldStartTime != null,
            //     s => s.ChangeMoldStartTime == entity.ChangeMoldStartTime)
            // 如果有换模结束时间则更新  
            .SetColumnsIF(entity.ChangeMoldEndTime != null,
                s => s.ChangeMoldEndTime == entity.ChangeMoldEndTime)
            // 如果标记为1则更新机器开始时间为当前时间
            .SetColumnsIF(entity.Flag == 1,
                s => s.MaStartTime ==
                     DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"))
            .SetColumnsIF(entity.Flag == 1 && vWom.WGSJ.Value < DateTime.Now,
                s => s.ChangeMoldStartTime ==
                     vWom.WGSJ.Value.ToString("yyyy-MM-dd HH:mm:ss"))
            // 根据ID匹配记录
            .Where(s => s.Id == entity.Id)
            // 执行更新并判断影响行数是否大于0
            .ExecuteCommand() > 0;
    }

    /// <summary>
    ///     更新机器时间并处理首检
    /// </summary>
    /// <param name="entity">工单状态实体,包含机器时间信息</param>
    /// <returns>更新是否成功</returns>
    public bool ChangeMachineTime(MesOrderSta entity)
    {
        // 查询工单主表信息
        var womdaa = Db.Queryable<Womdaa>()
            .Where(s => s.Id == entity.OrderId).First();

        // 如果标记为1,需要处理首检相关逻辑
        if (entity.Flag == 1)
        {
            // 调用存储过程执行自动首检
            // Db.Ado.ExecuteCommand(
            //     "BEGIN AUTOMATIC_IPQC_FIRST_CHECK(:BILL_NO); END;",
            //     new SugarParameter("BILL_NO", womdaa.Daa001,
            //         DbType.String));
            var automaticIpqcFirstCheck =
                mesQaItemsDetect02Manager
                    .AutomaticIpqcFirstCheck(womdaa.Daa001);
            if (!automaticIpqcFirstCheck) throw new Exception("首检生成失败");

            // 获取当前时间
            var s1 = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
            // 生成首检备注信息
            var remeke = "工控机于" + s1 + "自动创建的首检单";

            // 更新首检单备注信息
            Db.Updateable<MesQaItemsDetect02>()
                .SetColumns(s => s.Remeke == remeke)
                .Where(s => s.Ftype == "首检" && s.Aufnr == womdaa.Daa001)
                .ExecuteCommand();
        }

        var mesReporting = Db.Queryable<MesReporting>()
            .Where(s => s.BillNo == womdaa.Daa001)
            .OrderByDescending(s => s.Id)
            .First();


        var editDate = DateTime.Now.ToString("yyyy-MM-dd");

        // 发送HTTP请求到数据刷新接口
        MesNumerical mesNumerical = null;
        try
        {
            using (var httpClient = new HttpClient())
            {
                httpClient.Timeout = TimeSpan.FromSeconds(30);

                var content = new StringContent(
                    JsonConvert.SerializeObject(new
                        { machineNo = entity.MachineNo }),
                    Encoding.UTF8,
                    "application/json");

                var response = httpClient
                    .PostAsync("http://192.168.0.94:9095/Numerical/RefreshDev",
                        content).GetAwaiter().GetResult();

                if (response.IsSuccessStatusCode)
                {
                    var responseString = response.Content.ReadAsStringAsync()
                        .GetAwaiter().GetResult();
                    var responseObj =
                        JsonConvert.DeserializeObject<dynamic>(responseString);

                    if (responseObj != null && responseObj.code == 200)
                    {
                        // 请求成功，获取MesNumerical数据
                        mesNumerical = Db.Queryable<MesNumerical>()
                            .Where(s => s.EditDate == editDate
                                        && s.MachineNo == entity.MachineNo)
                            .OrderByDescending(s => s.Id)
                            .First();
                    }
                }
            }
        }
        catch (Exception ex)
        {
            // 记录异常但不阻止流程
            Console.WriteLine($"发送数据刷新请求时出错: {ex.Message}");
        }

        // 如果请求失败或获取数据失败，mesNumerical将保持为null

        Db.Deleteable<MesAnchors>()
            .Where(a => a.EditDate == editDate
                        && a.OrderId == womdaa.Id)
            .ExecuteCommand();

        MesAnchors eAnchors = new MesAnchors
        {
            OrderId = womdaa.Id,
            OrderNo = womdaa.Daa001,
            EditDate = editDate,
            Qty = mesReporting == null ? 0 : Int64.Parse(mesReporting.DyQty),
            InitialValue = mesNumerical == null ? 0 : mesNumerical.CjNum
        };
        Db.Insertable<MesAnchors>(eAnchors)
            .ExecuteCommand();


        // 更新工单状态表
        return Db.Updateable<MesOrderSta>()
            // 如果有送检时间则更新
            .SetColumnsIF(entity.MaShoutTime != null,
                s => s.MaShoutTime == entity.MaShoutTime)
            // 如果标记为1则更新备注信息
            .SetColumnsIF(entity.Flag == 1,
                s => s.remark == "于" + entity.MaShoutTime + "时间有一次送检")
            // 根据ID匹配记录
            .Where(s => s.Id == entity.Id)
            // 执行更新并判断影响行数是否大于0
            .ExecuteCommand() > 0;
    }

    /// <summary>
    ///     初始化工单状态
    /// </summary>
    /// <param name="query">包含工单信息的查询条件</param>
    /// <returns>初始化是否成功</returns>
    public bool init(OrderMachineDto query)
    {
        // 查询是否已存在该工单的状态记录
        var count = Db.Queryable<MesOrderSta>()
            .Where(s => s.OrderId == query.OrderId).Count();

        // 如果已存在则返回true
        if (count > 0) return true;

        // 创建新的工单状态记录
        var mesOrderSta = new MesOrderSta
        {
            OrderId = query.OrderId.Value,
            OrderNo = query.orderNo,
            MachineNo = query.machineNo,
            StartTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")
        };
        // 插入新记录
        return Insert(mesOrderSta);
    }

    /// <summary>
    ///     绑定工单到机器
    /// </summary>
    /// <param name="entity">工单状态实体,包含机器编号等信息</param>
    /// <returns>绑定是否成功</returns>
    public bool Binding(MesOrderSta entity)
    {
        // 验证ID是否有效
        if (entity.Id <= 0) return true;
        // 验证机器编号是否为空
        if (string.IsNullOrEmpty(entity.MachineNo)) return false;

        // 将该机器上其他显示的工单状态设为不显示
        var executeCommand = Db.Updateable<MesOrderSta>()
            .SetColumns(s => s.IsShow == 0)
            .Where(s => s.IsShow == 1 && s.MachineNo == entity.MachineNo)
            .ExecuteCommand();

        // 将当前工单状态设为显示
        var sql = "UPDATE MES_ORDER_STA SET IS_SHOW = 1 WHERE ID = " +
                  entity.Id;
        executeCommand += Db.Ado.ExecuteCommand(sql);

        // 判断是否至少有一条记录被更新
        return executeCommand >= 1;
    }

    /// <summary>
    ///     更新工单时间和状态
    /// </summary>
    /// <param name="entity">工单状态实体,包含时间和状态信息</param>
    /// <returns>更新是否成功</returns>
    public bool UpdateTime(MesOrderSta entity)
    {
        // 验证ID是否有效
        if (entity.Id <= 0) return true;
        // 验证机器编号是否为空
        if (string.IsNullOrEmpty(entity.MachineNo)) return false;

        var executeCommand = 0;

        // 使用事务处理更新操作
        executeCommand += UseTransaction(db =>
        {
            // 根据标记获取对应的状态文本
            var daa018 = entity.Flag switch
            {
                0 => "开工",
                1 => "完工", // 这里将daa018设置为完工
                2 => "暂停",
                3 => "未开工",
                _ => ""
            };

            // 如果状态无效则返回0
            if ("".Equals(daa018)) return 0;

            var date = DateTime.Now.ToString("yyyy-MM-dd");

            // 查询当前机器上的工单选择记录
            var list = Db.Queryable<MesOrderSelect>()
                .Where(a => a.MachineNo == entity.MachineNo
                            && a.EditDate == date
                            && a.IsShow == 0).ToList();

            // 获取工单ID列表
            var orderIds = list.Select(s => s.OrderId).ToList();
            // 初始化每个工单的状态
            list.ForEach(s =>
            {
                var query = new OrderMachineDto
                {
                    OrderId = s.OrderId,
                    orderNo = s.OrderNo,
                    machineNo = s.MachineNo
                };
                init(query);
            });

            var updateable = 0;
            var endDate = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
            // 根据不同状态执行相应的处理
            switch (daa018)
            {
                case "开工":
                    // 开工时绑定工单
                    Binding(entity);
                    break;
                case "暂停":
                    foreach (var orderId in orderIds)
                    {
                        var womdaa = db.Queryable<Womdaa>()
                            .Where(s => s.Id == orderId).First();

                        var btnLog = new MesWorkorderBtnLog
                        {
                            WorkNo = womdaa.Daa001,
                            BtnType = "工控暂停工单",
                            BtnDate = DateTime.Now
                        };
                        db.Insertable<MesWorkorderBtnLog>(btnLog)
                            .ExecuteCommand();

                        updateable += db.Updateable<Womdaa>()
                            .SetColumns(s => s.Daa018 == daa018)
                            .SetColumnsIF("暂停".Equals(daa018),
                                s => s.Daa034 == DateTime.Now)
                            .Where(s => s.Id == orderId).ExecuteCommand();

                        db.Updateable<MesOrderSelect>()
                            .SetColumns(a => a.IsShow == 1)
                            .Where(a => a.OrderId == orderId)
                            .ExecuteCommand();

                        //更新工单状态表
                        db.Updateable<MesOrderSta>()
                            .SetColumns(a => a.IsShow == 0)
                            .SetColumns(a => a.SuspendTime == endDate)
                            .Where(a => a.OrderId == orderId)
                            .ExecuteCommand();
                    }

                    break;
                case "完工":
                {
                    // 更新工单选择表显示状态
                    // Db.Updateable<MesOrderSelect>()
                    //     .SetColumns(a => a.IsShow == 1)
                    //     .Where(a => orderIds.Contains(a.OrderId))
                    //     .ExecuteCommand();

                    // 更新工单状态表
                    // Db.Updateable<MesOrderSta>()
                    //     .SetColumns(a => a.IsShow == 0)
                    //     .SetColumns(a => a.EndTime == endDate)
                    //     .Where(a => orderIds.Contains(a.OrderId))
                    //     .ExecuteCommand();

                    // 处理每个工单的报工数据
                    foreach (var orderId in orderIds)
                    {
                        // 查询工单主表信息
                        var womdaa = Db.Queryable<Womdaa>()
                            .Where(s => s.Id == orderId).First();

                        //当已生成数不等于完工数是就跳过
                        if (womdaa.Daa008 > womdaa.Daa011)
                        {
                            updateable += 1;
                            continue;
                        }

                        var btnLog = new MesWorkorderBtnLog
                        {
                            WorkNo = womdaa.Daa001,
                            BtnType = "工控自动完工",
                            BtnDate = DateTime.Now
                        };
                        db.Insertable<MesWorkorderBtnLog>(btnLog)
                            .ExecuteCommand();

                        // 更新工单主表状态 - 这里将Womdaa表的daa018更新为完工状态
                        updateable = db.Updateable<Womdaa>()
                            .SetColumns(s => s.Daa018 == daa018)
                            .SetColumnsIF("完工".Equals(daa018),
                                s => s.Daa017 == DateTime.Now)
                            .SetColumnsIF("暂停".Equals(daa018),
                                s => s.Daa034 == DateTime.Now)
                            .Where(s => s.Id == orderId).ExecuteCommand();

                        // Db.Deleteable<MesOrderSelect>()
                        //     .Where(a =>  a.OrderId == orderId)
                        //     .ExecuteCommand();
                        //
                        // Db.Deleteable<MesOrderSta>()
                        //     .Where(a => a.OrderId == orderId)
                        //     .ExecuteCommand();
                        //更新工单选择表显示状态
                        db.Updateable<MesOrderSelect>()
                            .SetColumns(a => a.IsShow == 1)
                            .Where(a => a.OrderId == orderId)
                            .ExecuteCommand();

                        //更新工单状态表
                        db.Updateable<MesOrderSta>()
                            .SetColumns(a => a.IsShow == 0)
                            .SetColumns(a => a.EndTime == endDate)
                            .Where(a => a.OrderId == orderId)
                            .ExecuteCommand();

                        // 查询已报工数量
                        var reporting = db.Queryable<MesReporting>()
                            .Where(s => s.BillNo == womdaa.Daa001)
                            .Select(s => new MesReporting
                            {
                                OkQty = SqlFunc.AggregateSum(s.OkQty),
                                BfQty = SqlFunc.AggregateSum(s.BfQty)
                            }).First();
                        
                        reporting.OkQty ??= 0;
                        reporting.BfQty ??= 0;
                        
                        // 查询工单视图信息
                        // var vOrder = db.Queryable<VOrder>()
                        //     .Where(s => s.ID == orderId).First();
                        
                        // 计算待报工数量
                        // var reportingOkQty =
                        //     Convert.ToDecimal(vOrder.todayOutput) -
                        //     reporting.OkQty;
                        var CjQty = Db.Queryable<MesNumerical>()
                            .Where(s => s.MachineNo == entity.MachineNo && s.EditDate == date)
                            .OrderByDescending(s=>s.CjTiem)
                            .Select<long?>(s=>s.CjNum).First();
                        
                        // 计算待报工数量
                        var reportingOkQty = CjQty - reporting.OkQty;
                        
                        // 如果有待报工数量则创建报工记录
                        if (!(reportingOkQty > 0)) continue;
                        var mesReporting = new MesReporting
                        {
                            CheckType = 1,
                            BgDate = DateTime.Now,
                            AddressCode = womdaa.AddressCode,
                            MachineNo = womdaa.MachineNo,
                            // BfQty = reportingOkQty,
                            BfQty = 0,
                            BlQty = reportingOkQty.ToString(),
                            OkQty = 0,
                            ItemNo = womdaa.Daa002,
                            BillNo = womdaa.Daa001,
                            CjQty = CjQty.ToString(),
                            DyQty = reporting.OkQty.ToString()
                        };
                        
                        // 插入报工记录
                        db.Insertable(mesReporting)
                            .IgnoreColumns(true).ExecuteCommand();
                    }

                    break;
                }
            }


            // 判断更新是否成功
            if (updateable >= 1) return updateable;

            throw new Exception("工单状态更新错误");
        });

        return executeCommand >= 1;
    }

    /// <summary>
    ///     检查工单状态是否允许操作
    /// </summary>
    /// <param name="query">包含工单信息和操作标识的查询条件</param>
    /// <returns>是否允许操作</returns>
    public bool StateCheck(OrderMachineDto query)
    {
        // 查询工单视图信息
        var vOrder = Db.Queryable<VOrder>()
            .Where(s => s.ID == query.OrderId).First();

        // 根据不同操作标识进行检查
        switch (query.Flag)
        {
            case 0: // 开工检查
                vOrder.BGQTY ??= 0;
                // 判断是否已完工
                if (vOrder.Daa008 > vOrder.BGQTY) return true;
                throw new Exception("当前工单已经完工，不允许再开工");

            case 1: // 完工检查
                return true;

            case 2: // 暂停检查
                // 判断是否处于开工状态
                if (!"开工".Equals(vOrder.Daa018))
                    throw new Exception("只有开工状态下才允许暂停");
                return true;

            case 3: // 反完工检查
                // 判断是否处于完工状态
                if (!"完工".Equals(vOrder.Daa018))
                    throw new Exception("只有完工状态下才允许反完工");
                return true;

            default:
                return false;
        }
    }

    /// <summary>
    ///     检验合格时更新工单状态
    /// </summary>
    /// <param name="query">包含工单信息的查询条件</param>
    /// <returns>更新是否成功</returns>
    public bool QualifiedInspection(OrderMachineDto query)
    {
        var endDate = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");

        // 查询工单主表信息
        var womdaa = Db.Queryable<Womdaa>()
            .Where(s => s.Id == query.OrderId).First();

        // 根据是否有首检时间更新不同的字段
        if (!womdaa.Daa016.HasValue)
            // 首次首检更新
            Db.Updateable<Womdaa>()
                .SetColumns(s => s.Daa018 == "开工")
                .SetColumns(s => s.Daa022 == 1)
                .SetColumns(s => s.Daa016 == DateTime.Now)
                .SetColumns(s => s.Daa032 == DateTime.Now)
                .Where(s => s.Id == query.OrderId).ExecuteCommand();
        else
            // 非首次首检更新
            Db.Updateable<Womdaa>()
                .SetColumns(s => s.Daa018 == "开工")
                .SetColumns(s => s.Daa022 == 1)
                .SetColumns(s => s.Daa032 == DateTime.Now)
                .Where(s => s.Id == query.OrderId).ExecuteCommand();

        // 查询工单状态信息
        var entity = Db.Queryable<MesOrderSta>()
            .Where(s => s.OrderId == query.OrderId).First();

        // 绑定工单并更新时间
        var binding = Binding(entity);

        var btnLog = new MesWorkorderBtnLog
        {
            WorkNo = womdaa.Daa001,
            BtnType = "工控首检开工",
            BtnDate = DateTime.Now
        };
        Db.Insertable<MesWorkorderBtnLog>(btnLog).ExecuteCommand();

        if (binding)
            return Db.Updateable<MesOrderSta>()
                .SetColumns(s => s.MaEndTime == endDate)
                .SetColumns(s => s.StartTime == entity.MaShoutTime)
                .Where(s => s.OrderId == query.OrderId).ExecuteCommand() > 0;

        return false;
    }

    /// <summary>
    ///     检验不合格时清空首检时间
    /// </summary>
    /// <param name="query">包含工单信息的查询条件</param>
    /// <returns>清空是否成功</returns>
    public bool InspectionIsUnqualified(OrderMachineDto query)
    {
        // 清空工单状态表的送检时间
        return Db.Updateable<MesOrderSta>()
            .SetColumns(s => s.MaShoutTime == null)
            .Where(s => s.OrderId == query.OrderId).ExecuteCommand() > 0;
    }

    /// <summary>
    ///     完工检查
    /// </summary>
    /// <param name="query">包含工单信息的查询条件</param>
    /// <returns>完工处理是否成功</returns>
    public bool Completed(OrderMachineDto query)
    {
        // 查询工单状态信息
        var entity = Db.Queryable<MesOrderSta>()
            .Where(s => s.OrderId == query.OrderId).First();
        // 设置完工标记
        entity.Flag = 1;
        // 更新工单时间和状态
        return UpdateTime(entity);
    }
}