using Admin.NET.Plugin.AiDOP.Entity;
using Admin.NET.Plugin.AiDOP.Manufacturing.Dto;
using Admin.NET.Plugin.ApprovalFlow;
using Admin.NET.Plugin.ApprovalFlow.Service;
using Yitter.IdGenerator;

namespace Admin.NET.Plugin.AiDOP.Manufacturing;

/// <summary>
/// S6 Phase 1D 过程检验单（Phase 1C bill）审核流程服务（桥接：Phase 1C Complete → ApprovalFlow）。
///
/// business_id = ado_s6_process_inspection_bill.id（BizType=S6_PROCESS_INSPECTION）。复用 ApprovalFlow 引擎，不改核心。
/// 提交门槛：结果 status=COMPLETED 才能提交审核；幂等：一单最多一个 active flow。
/// N1_SUBMIT=发起人本人（提交即自动通过）→ N2_SUP_REVIEW 主管审核 → GW_RESULT(overall_result=FAIL→N3 / PASS→end)
///   → N3_QE_DISPOSITION 质量工程师处置 → end。质量结果 overall_result 全程只读、审批不改写（§20 硬门）。
/// 处置落 ado_s6_ipqc_quality_disposition（biz_type 区分，复用不建重复表）。严格租户隔离（ResolveTenantOrThrow）。
/// </summary>
[ApiDescriptionSettings(Order = 305, Description = "过程检验单审核")]
[Route("api/S6ProcessInspectionReview")]
[NonUnify]
public class S6ProcessInspectionReviewService : IDynamicApiController, ITransient
{
    private const long MainTenantId = 1300000000001L;

    private readonly ISqlSugarClient _db;
    private readonly FlowEngineService _flowEngine;
    private readonly UserManager _userManager;

    public S6ProcessInspectionReviewService(ISqlSugarClient db, FlowEngineService flowEngine, UserManager userManager)
    {
        _db = db;
        _flowEngine = flowEngine;
        _userManager = userManager;
    }

    private long ResolveTenantOrThrow()
    {
        var tid = _userManager.TenantId;
        if (tid <= 0) throw Oops.Oh("无法确定当前租户，请重新登录或选择目标租户");
        if (_userManager.SuperAdmin && tid == MainTenantId) throw Oops.Oh("超级管理员操作前必须选择目标租户");
        return tid;
    }

    /// <summary>审核流状态（只读，供前端按钮控制）。</summary>
    [DisplayName("过程检验单审核状态")]
    [HttpGet("state")]
    public async Task<S6ReviewStateOutput> GetState([FromQuery] long billId)
    {
        await LoadBillAsync(billId);
        return await BuildStateAsync(billId);
    }

    /// <summary>
    /// 提交审核（仅 COMPLETED 可提交），同时承载**首次提交**与**主管退回后的重新提交**。
    ///
    /// 两者是同一条业务命令：校验相同（本租户单据 + 结果 COMPLETED）、都不写业务行，
    /// 唯一差异是要不要先起流程。故复用同一入口，由后端按真实 Flow 状态分流：
    ///   无实例 / 上一轮已 Rejected|Cancelled → 首次提交：StartFlow + 通过 N1 → N2
    ///   Running 且已退回 N1 且本人持有该 N1 待办 → 重新提交：沿用同一实例，只通过既有 N1 任务 → N2
    ///
    /// S6-PI-RESUBMIT-1：原实现用「实例 Running」当作「已提交」的代理判据，对 N2/N3 正确，
    /// 但 ReturnToPrev 只回退 CurrentNodeId、**实例仍是 Running**，于是把合法重提一并挡死，
    /// 单据卡在 N1 无任何专用出口。此处改为按「节点 + 本人待办」精确判定 ——
    /// **不是放宽 Running**：N2/N3 仍拒绝，非本人待办仍拒绝，终态仍拒绝。
    /// </summary>
    [DisplayName("提交审核")]
    [HttpPost("submit-review")]
    public async Task<S6ReviewStateOutput> SubmitReview([FromBody] S6SubmitReviewInput input)
    {
        var bill = await LoadBillAsync(input.BillId);
        if (!string.Equals(bill.ResultStatus, S6ProcessInspectionFlowConst.StatusCompleted, StringComparison.OrdinalIgnoreCase))
            throw Oops.Oh("INSPECTION_NOT_COMPLETED：检验未完成，无法提交审核");

        var inst = await GetLatestInstanceAsync(input.BillId);
        var resubmitTask = inst != null && inst.Status == FlowInstanceStatusEnum.Running
            ? await RequireResubmittableTaskAsync(inst)
            : null;
        if (resubmitTask == null && inst != null
            && inst.Status != FlowInstanceStatusEnum.Rejected && inst.Status != FlowInstanceStatusEnum.Cancelled)
            throw Oops.Oh("该检验单审核流程已结束");

        var tran = await _db.AsTenant().UseTranAsync(async () =>
        {
            var taskId = resubmitTask?.Id;
            if (taskId == null)
            {
                var instanceId = await _flowEngine.StartFlow(new StartFlowInput
                {
                    BizType = S6ProcessInspectionFlowConst.BizType,
                    BizId = input.BillId,
                    BizNo = bill.WorkOrderNo,
                    Title = $"过程检验单 {bill.WorkOrderNo}",
                    Comment = input.Comment,
                });
                // N1_SUBMIT=发起人本人，取自己的 N1 待办并自动通过 → N2
                var myTask = await GetMyPendingTaskAsync(instanceId);
                if (myTask == null || myTask.NodeId != S6ProcessInspectionFlowConst.NodeSubmit)
                    throw Oops.Oh("提交审核节点异常，未取到发起人任务");
                taskId = myTask.Id;
            }
            // 重提路径复用同一实例的既有 N1 待办，不再 StartFlow —— StartFlow 每次都会新建实例，
            // 重跑首次路径会造成同一单据出现多个并存实例。
            await _flowEngine.Approve(taskId.Value, input.Comment);
        });
        if (!tran.IsSuccess) throw tran.ErrorException;

        return await BuildStateAsync(input.BillId);
    }

    /// <summary>主管审核通过（N2）：Approve→GW_RESULT，按 overall_result 自动分流（FAIL→N3 / PASS→end）。不改写质量结果。</summary>
    [DisplayName("主管审核通过")]
    [HttpPost("supervisor-approve")]
    public async Task<S6ReviewStateOutput> SupervisorApprove([FromBody] S6ReviewApproveInput input)
    {
        await LoadBillAsync(input.BillId);
        var (_, myTask) = await RequireSupervisorTaskAsync(input.BillId);
        var tran = await _db.AsTenant().UseTranAsync(async () =>
        {
            await _flowEngine.Approve(myTask.Id, input.Comment);
        });
        if (!tran.IsSuccess) throw tran.ErrorException;
        return await BuildStateAsync(input.BillId);
    }

    /// <summary>主管退回（N2→N1，意见必填）。质量结果不改写。</summary>
    [DisplayName("主管退回")]
    [HttpPost("supervisor-return")]
    public async Task<S6ReviewStateOutput> SupervisorReturn([FromBody] S6ReviewReturnInput input)
    {
        if (string.IsNullOrWhiteSpace(input.Comment)) throw Oops.Oh("退回必须填写意见");
        await LoadBillAsync(input.BillId);
        var (_, myTask) = await RequireSupervisorTaskAsync(input.BillId);
        var tran = await _db.AsTenant().UseTranAsync(async () =>
        {
            await _flowEngine.ReturnToPrev(myTask.Id, input.Comment);
        });
        if (!tran.IsSuccess) throw tran.ErrorException;
        return await BuildStateAsync(input.BillId);
    }

    /// <summary>QE 质量处置（N3）：落处置记录（不改写 overall_result），Approve→end。一单一有效处置。</summary>
    [DisplayName("质量处置")]
    [HttpPost("qe-disposition")]
    public async Task<S6ReviewStateOutput> QeDisposition([FromBody] S6QeDispositionInput input)
    {
        var bill = await LoadBillAsync(input.BillId);
        var type = (input.DispositionType ?? "").Trim().ToUpperInvariant();
        if (type != S6ProcessInspectionFlowConst.DispTypeRework && type != S6ProcessInspectionFlowConst.DispTypeConcession
            && type != S6ProcessInspectionFlowConst.DispTypeScrap && type != S6ProcessInspectionFlowConst.DispTypeOther)
            throw Oops.Oh("处置类型非法（REWORK/CONCESSION/SCRAP/OTHER）");
        if (string.IsNullOrWhiteSpace(input.DispositionOpinion)) throw Oops.Oh("处置意见必填");

        var inst = await GetLatestInstanceAsync(input.BillId);
        if (inst == null || inst.Status != FlowInstanceStatusEnum.Running) throw Oops.Oh("该检验单审核流程已结束");
        var myTask = await GetMyPendingTaskAsync(inst.Id);
        if (myTask == null) throw Oops.Oh("当前用户没有待处理的处置任务（需质量工程师角色成员）");
        if (myTask.NodeId != S6ProcessInspectionFlowConst.NodeDisposition) throw Oops.Oh("当前不在质量处置节点");

        var tid = ResolveTenantOrThrow();
        // 一单一有效处置（status=1 且未软删）+ InspectionId 唯一约束
        var existed = await _db.Queryable<AdoS6IpqcQualityDisposition>().ClearFilter()
            .AnyAsync(x => x.InspectionId == input.BillId && x.TenantId == tid && x.Status == 1);
        if (existed) throw Oops.Oh("该检验单已存在有效质量处置记录");

        var now = DateTime.Now;
        var opName = _userManager.RealName ?? _userManager.Account;
        var tran = await _db.AsTenant().UseTranAsync(async () =>
        {
            await _db.Insertable(new AdoS6IpqcQualityDisposition
            {
                Id = YitIdHelper.NextId(),
                TenantId = tid,
                InspectionId = input.BillId,
                InspectionNo = bill.WorkOrderNo,
                BizType = S6ProcessInspectionFlowConst.BizType,
                FlowInstanceId = inst.Id,
                DispositionNo = $"S6PIDISP-{bill.WorkOrderNo}-{now:yyyyMMddHHmmss}",
                DispositionType = type,
                DispositionQty = input.DispositionQty,
                ReworkQty = input.ReworkQty,
                ConcessionQty = input.ConcessionQty,
                ScrapQty = input.ScrapQty,
                DispositionOpinion = input.DispositionOpinion,
                ResponsibilityDept = input.ResponsibilityDept,
                ResponsibleUser = input.ResponsibleUser,
                Status = 1,
                SubmittedBy = _userManager.UserId,
                SubmittedByName = opName,
                SubmittedAt = now,
                RowVersion = 1,
                CreateTime = now,
            }).ExecuteCommandAsync();
            await _flowEngine.Approve(myTask.Id, input.Comment);
        });
        if (!tran.IsSuccess) throw tran.ErrorException;
        return await BuildStateAsync(input.BillId);
    }

    // ───────────────────────── helpers ─────────────────────────

    private sealed class BillRow
    {
        public long Id { get; set; }
        public string? WorkOrderNo { get; set; }
        public string? OverallResult { get; set; }
        public string? ResultStatus { get; set; }
    }

    /// <summary>加载 Phase 1C 单据 + 结果（严格租户隔离）。</summary>
    private async Task<BillRow> LoadBillAsync(long billId)
    {
        if (billId <= 0) throw Oops.Oh("检验单 id 非法");
        var tid = ResolveTenantOrThrow();
        var row = await _db.Ado.SqlQuerySingleAsync<BillRow>(
            """
            SELECT b.id AS Id, b.work_order_no AS WorkOrderNo, r.overall_result AS OverallResult, r.status AS ResultStatus
            FROM ado_s6_process_inspection_bill b
            LEFT JOIN ado_s6_process_inspection_result r ON r.bill_id=b.id AND r.tenant_id=b.tenant_id
            WHERE b.id=@id AND b.tenant_id=@tid LIMIT 1
            """,
            new List<SugarParameter> { new("@id", billId), new("@tid", tid) });
        if (row == null) throw Oops.Oh("检验单不存在");
        return row;
    }

    private async Task<ApprovalFlowInstance?> GetLatestInstanceAsync(long bizId)
        => await _db.Queryable<ApprovalFlowInstance>().ClearFilter()
            .Where(x => x.BizType == S6ProcessInspectionFlowConst.BizType && x.BizId == bizId)
            .OrderByDescending(x => x.Id).FirstAsync();

    private async Task<ApprovalFlowTask?> GetMyPendingTaskAsync(long instanceId)
    {
        var userId = _userManager.UserId;
        return await _db.Queryable<ApprovalFlowTask>().ClearFilter()
            .Where(x => x.InstanceId == instanceId && x.AssigneeId == userId && x.Status == FlowTaskStatusEnum.Pending)
            .FirstAsync();
    }

    private async Task<(ApprovalFlowInstance inst, ApprovalFlowTask task)> RequireSupervisorTaskAsync(long bizId)
    {
        var inst = await GetLatestInstanceAsync(bizId);
        if (inst == null) throw Oops.Oh("该检验单尚未发起审核");
        if (inst.Status != FlowInstanceStatusEnum.Running) throw Oops.Oh("该检验单审核流程已结束");
        var myTask = await GetMyPendingTaskAsync(inst.Id);
        if (myTask == null) throw Oops.Oh("当前用户没有待处理的审核任务（需检验主管角色成员）");
        if (myTask.NodeId != S6ProcessInspectionFlowConst.NodeSupervisor) throw Oops.Oh("当前不在主管审核节点");
        return (inst, myTask);
    }

    /// <summary>
    /// S6-PI-RESUBMIT-1：判定一个 Running 实例是否处于「合法可重新提交」状态，是则返回本人那条 N1 待办。
    ///
    /// 仅凭 <c>CurrentNodeId == N1_SUBMIT</c> 不够——实例可能异常残留该字段却无待办，
    /// 或待办属于别人。故三条同时成立才放行：节点已回到 N1、当前用户持有 Pending 任务、该任务就在 N1。
    /// 租户隔离由调用前的 <see cref="LoadBillAsync"/> 承担（Flow 两表无 TenantId 列，
    /// 与 <see cref="RequireSupervisorTaskAsync"/> 同一既有模式）。
    /// </summary>
    private async Task<ApprovalFlowTask> RequireResubmittableTaskAsync(ApprovalFlowInstance inst)
    {
        if (inst.CurrentNodeId != S6ProcessInspectionFlowConst.NodeSubmit)
            throw Oops.Oh($"当前流程节点不允许提交审核（{NodeNameOf(inst.CurrentNodeId) ?? inst.CurrentNodeId}）");
        var myTask = await GetMyPendingTaskAsync(inst.Id);
        if (myTask == null || myTask.NodeId != S6ProcessInspectionFlowConst.NodeSubmit)
            throw Oops.Oh("当前用户不是该检验单当前检验任务处理人");
        return myTask;
    }

    private async Task<bool> HasRoleAsync(long roleId)
    {
        var userId = _userManager.UserId;
        return await _db.Queryable<SysUserRole>().ClearFilter().AnyAsync(x => x.UserId == userId && x.RoleId == roleId);
    }

    private async Task<S6ReviewStateOutput> BuildStateAsync(long billId)
    {
        var tid = ResolveTenantOrThrow();
        var output = new S6ReviewStateOutput { BillId = billId };
        var bill = await _db.Ado.SqlQuerySingleAsync<BillRow>(
            """
            SELECT b.id AS Id, b.work_order_no AS WorkOrderNo, r.overall_result AS OverallResult, r.status AS ResultStatus
            FROM ado_s6_process_inspection_bill b
            LEFT JOIN ado_s6_process_inspection_result r ON r.bill_id=b.id AND r.tenant_id=b.tenant_id
            WHERE b.id=@id AND b.tenant_id=@tid LIMIT 1
            """,
            new List<SugarParameter> { new("@id", billId), new("@tid", tid) });
        var completed = string.Equals(bill?.ResultStatus, S6ProcessInspectionFlowConst.StatusCompleted, StringComparison.OrdinalIgnoreCase);
        output.OverallResult = bill?.OverallResult;
        output.ResultStatus = bill?.ResultStatus;
        output.QualityText = QualityTextOf(bill?.OverallResult);
        output.DispositionRequired = string.Equals(bill?.OverallResult, S6ProcessInspectionFlowConst.ResultFail, StringComparison.OrdinalIgnoreCase) ? 1 : 0;
        output.Disposition = await LoadDispositionAsync(billId, tid);
        output.HasDisposition = output.Disposition != null;

        var inst = await GetLatestInstanceAsync(billId);
        if (inst == null)
        {
            output.FlowStatus = "NotStarted";
            // S6-IPQC-EDIT-1：流程未起 → 首次录入阶段，可编辑（不受 completed 约束，否则录完就锁死）。
            output.CanEdit = true;
            output.CanSubmitReview = completed;
            output.DisplayStatus = completed ? "待提交审核" : "检验中";
            output.Message = completed ? "检验完成，待提交审核" : "检验未完成，暂不可提交审核";
            return output;
        }

        output.InstanceId = inst.Id;
        output.FlowStatus = inst.Status.ToString();
        output.History = await LoadHistoryAsync(inst.Id, tid);

        if (inst.Status != FlowInstanceStatusEnum.Running)
        {
            output.IsCompleted = true;
            output.DisplayStatus = inst.Status == FlowInstanceStatusEnum.Approved ? "已关闭"
                : inst.Status == FlowInstanceStatusEnum.Rejected ? "已驳回"
                : inst.Status == FlowInstanceStatusEnum.Cancelled ? "已撤回" : "已结束";
            output.Message = inst.Status == FlowInstanceStatusEnum.Approved ? "审核已闭环（CLOSED）" : $"流程已结束（{inst.Status}）";
            output.CanSubmitReview = inst.Status is FlowInstanceStatusEnum.Rejected or FlowInstanceStatusEnum.Cancelled && completed;
            // S6-IPQC-EDIT-1：流程已结束 → 一律不可编辑。
            // 注：Rejected / Cancelled 下 CanSubmitReview 为 true（会新起一条流程），但此处仍保持
            // CanEdit=false —— 与本次修复前的前端表达式对该状态的取值一致，不在本轮放宽未经运行时
            // 验证的路径（专用链的主管退回走 ReturnToPrev 保持 Running@N1，不进入本分支）。
            output.CanEdit = false;
            return output;
        }

        output.CurrentNodeCode = inst.CurrentNodeId;
        output.DisplayStatus = inst.CurrentNodeId switch
        {
            S6ProcessInspectionFlowConst.NodeSupervisor => "主管审核中",
            S6ProcessInspectionFlowConst.NodeDisposition => "QE质量处置中",
            _ => "审核中",
        };
        var myTask = await GetMyPendingTaskAsync(inst.Id);
        if (myTask != null)
        {
            output.CurrentNodeName = NodeNameOf(myTask.NodeId) ?? myTask.NodeName;
            if (myTask.NodeId == S6ProcessInspectionFlowConst.NodeSupervisor)
            {
                output.CurrentAssigneeRole = S6ProcessInspectionFlowConst.RoleSupervisorCode;
                output.CanSupervisorApprove = true;
                output.CanSupervisorReturn = true;
                output.Message = "待当前用户主管审核";
            }
            else if (myTask.NodeId == S6ProcessInspectionFlowConst.NodeDisposition)
            {
                output.CurrentAssigneeRole = S6ProcessInspectionFlowConst.RoleQualityEngineerCode;
                output.CanSubmitDisposition = true;
                output.Message = "待当前用户提交质量处置";
            }
            else if (myTask.NodeId == S6ProcessInspectionFlowConst.NodeSubmit)
            {
                // S6-PI-RESUBMIT-1：主管退回后流程回到 N1，本人持有该待办 → 可修正结果后重新提交。
                // 复用既有 canSubmitReview（前端已按它显示同一个「提交审核」按钮），
                // 不新增 isRejected / isResubmit 之类让前端自己推断业务状态的字段。
                // S6-IPQC-EDIT-1：同一份待办归属即编辑权限来源（node==N1 且 AssigneeId==当前用户 且 Pending）。
                // 这里**不叠加 completed** —— 退回后通常要把某项结果改掉，改的过程中 ResultStatus 会回到
                // IN_PROGRESS，若叠加 completed 会在"刚开始改"的一瞬间把编辑权关掉。
                output.CanEdit = true;
                output.CanSubmitReview = completed;
                output.DisplayStatus = "已退回待重新提交";
                output.Message = completed ? "已退回，修正检验结果后可重新提交审核" : "已退回，检验结果未完成，暂不可提交审核";
            }
            else
            {
                output.Message = "流程进行中";
            }
        }
        else
        {
            output.CurrentNodeName = NodeNameOf(inst.CurrentNodeId);
            output.CurrentAssigneeRole = inst.CurrentNodeId switch
            {
                S6ProcessInspectionFlowConst.NodeDisposition => S6ProcessInspectionFlowConst.RoleQualityEngineerCode,
                S6ProcessInspectionFlowConst.NodeSupervisor => S6ProcessInspectionFlowConst.RoleSupervisorCode,
                _ => null,
            };
            output.Message = "流程进行中（当前用户无待办）";
        }
        return output;
    }

    // ── Phase 1E 展示辅助（业务中文映射；后端拥有语义）──
    private static string QualityTextOf(string? overallResult) => (overallResult ?? "").ToUpperInvariant() switch
    {
        "PASS" => "合格",
        "FAIL" => "不合格",
        "PENDING" or "IN_PROGRESS" => "检验中",
        "INVALID" => "无效",
        _ => "—",
    };

    private static string? NodeNameOf(string? nodeId) => nodeId switch
    {
        S6ProcessInspectionFlowConst.NodeSubmit => "提交审核",
        S6ProcessInspectionFlowConst.NodeSupervisor => "检验主管审核",
        S6ProcessInspectionFlowConst.NodeDisposition => "质量处置",
        _ => null,
    };

    private static string DispositionTypeTextOf(string? t) => (t ?? "").ToUpperInvariant() switch
    {
        "REWORK" => "返工",
        "CONCESSION" => "让步接收",
        "SCRAP" => "报废",
        "OTHER" => "其它",
        _ => t ?? "",
    };

    private static string ActionTextOf(int action) => action switch
    {
        1 => "提交",
        2 => "通过",
        3 => "驳回",
        5 => "撤回",
        6 => "退回",
        9 => "取消",
        _ => "操作",
    };

    private async Task<S6DispositionView?> LoadDispositionAsync(long billId, long tid)
    {
        var d = await _db.Queryable<AdoS6IpqcQualityDisposition>().ClearFilter()
            .Where(x => x.InspectionId == billId && x.TenantId == tid && x.Status == 1)
            .OrderByDescending(x => x.Id).FirstAsync();
        if (d == null) return null;
        return new S6DispositionView
        {
            DispositionType = d.DispositionType,
            DispositionTypeText = DispositionTypeTextOf(d.DispositionType),
            DispositionQty = d.DispositionQty,
            DispositionOpinion = d.DispositionOpinion,
            ResponsibilityDept = d.ResponsibilityDept,
            ResponsibleUser = d.ResponsibleUser,
            OperatorName = d.SubmittedByName,
            SubmittedAt = d.SubmittedAt,
        };
    }

    private sealed class FlowLogRow
    {
        public int Action { get; set; }
        public string? NodeId { get; set; }
        public string? OperatorName { get; set; }
        public string? Comment { get; set; }
        public DateTime? CreateTime { get; set; }
    }

    private async Task<List<S6ReviewHistoryItem>> LoadHistoryAsync(long instanceId, long tid)
    {
        // 复用正式 ApprovalFlowLog（不造第二套 history）。租户隔离由实例归属保证（instanceId 已按 BizType+BizId 定位）。
        var rows = await _db.Ado.SqlQueryAsync<FlowLogRow>(
            "SELECT Action AS Action, NodeId AS NodeId, OperatorName AS OperatorName, Comment AS Comment, CreateTime AS CreateTime FROM ApprovalFlowLog WHERE InstanceId=@iid ORDER BY Id",
            new List<SugarParameter> { new("@iid", instanceId) });
        return rows.Select(r => new S6ReviewHistoryItem
        {
            Time = r.CreateTime,
            OperatorName = r.OperatorName,
            NodeName = NodeNameOf(r.NodeId) ?? r.NodeId,
            ActionText = ActionTextOf(r.Action),
            Comment = r.Comment,
        }).ToList();
    }
}