import { Injectable } from '@nestjs/common';
// clean subpath(运行时 exports map 放行);类型见 src/types/mcp-sdk.d.ts ambient 声明
import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
import { z } from 'zod';
import { PERSONA_TAG_FILTER_DIMS, personaTagDimId, Permission } from '@pac/types';
import { PrismaService } from '../../prisma/prisma.service';
import { PatientService } from '../patient/patient.service';
import { PersonaService } from '../persona/persona.service';
import { PlanService } from '../plan/plan.service';
import { AgentRosterService } from '../plan/agent-roster.service';
import { PlanAssignmentService } from '../plan/plan-assignment.service';
import { AssignmentProposalService } from '../plan/assignment-proposal.service';
import type { ListPlansQueryDto } from '../plan/dto/plan.dto';
import type { TenantScopeContext } from '../../common/decorators/tenant-scope.decorator';
import type { McpAuthContext } from './mcp-auth.service';

function jsonResult(data: unknown) {
  return { content: [{ type: 'text' as const, text: JSON.stringify(data, null, 2) }] };
}

/**
 * personaTags 圈人字典(从 PERSONA_TAG_FILTER_DIMS 生成,单一真理源,自动同步)。
 * 格式给 LLM 看:`key(中文): code=中文 / code=中文 …`,一维一行。
 * 入参格式:"key:value" 逗号串;同维多选 OR,跨维 AND(如 "rfm:important_value,urgency_level:urgent")。
 */
const PERSONA_TAGS_HELP = PERSONA_TAG_FILTER_DIMS.map((d) =>
  // ⚠️ 用 personaTagDimId 不用 d.key:source='patient' 的维度 key 为空串、筛选串用 id,
  //   用 key 会给 LLM 一个空维度名,它照着发就永远筛不出人。
  // 开集维度(医生)options 为空 → 提示取值是自由文本,并指向名单接口,免得 LLM 瞎猜姓名。
  d.dynamic
    ? `${personaTagDimId(d)}(${d.nameZh}): <医生姓名,精确匹配;名单见 GET /pac/v1/plans/doctors>`
    : `${personaTagDimId(d)}(${d.nameZh}): ${d.options.map((o) => `${o.value}=${o.zh}`).join(' / ')}`,
).join('\n');

const PERSONA_TAGS_DESC =
  '画像圈人(可选):"key:value" 逗号串,同维多选 OR、跨维 AND。可用维度与取值:\n' +
  PERSONA_TAGS_HELP;

function maskPhone(phone: string | null): string | null {
  if (!phone) return null;
  const d = phone.replace(/\D/g, '');
  if (d.length < 7) return '***';
  return `${d.slice(0, 3)}****${d.slice(-4)}`;
}

/** 患者基础卡(掩码手机号,去掉真号 PII) */
function patientCard(p: {
  id: string;
  externalId: string;
  name: string | null;
  phone: string | null;
  gender: string | null;
  birthDate: string | null;
  status: string;
}) {
  return {
    id: p.id,
    externalId: p.externalId,
    name: p.name,
    phoneMasked: maskPhone(p.phone),
    gender: p.gender,
    birthDate: p.birthDate,
    status: p.status,
  };
}

/**
 * McpServerFactory — 每个(已鉴权的)请求构建一个 scoped McpServer。
 *
 * 6 个**只读**工具,全部薄封装现有 service。租户隔离两条路径(均等价安全):
 *   - 调不带 scope 的读(persona.getCurrent)的工具 → 先过 assertPatientInScope 堵越权;
 *   - get_facts → getTimeline 内部 findFirst{host,tenant}+NotFound 自守,无需额外 assert。
 */
@Injectable()
export class McpServerFactory {
  constructor(
    private readonly prisma: PrismaService,
    private readonly patient: PatientService,
    private readonly persona: PersonaService,
    private readonly plans: PlanService,
    private readonly roster: AgentRosterService,
    private readonly assignments: PlanAssignmentService,
    private readonly proposals: AssignmentProposalService,
  ) {}

  build(ctx: McpAuthContext): McpServer {
    const { scope, permissions } = ctx;
    const server = new McpServer({ name: 'pac-patient-tools', version: '0.1.0' });

    // ⚠️ 身份工具放**最前**:工具清单的顺序会影响模型的默认注意力,
    //   而"我在跟主管说话还是跟客服说话"决定了后面走哪条工作流,必须第一个被看到。
    server.registerTool(
      'get_current_user',
      {
        description:
          '当前登录人是谁、能做什么。**每轮对话开始时先调它**,据此决定走主管工作流(可发起批次分配)还是客服工作流(只处理自己的任务)。',
        inputSchema: {},
      },
      async () =>
        jsonResult({
          userId: scope.userId,
          displayName: ctx.userName ?? null,
          // ⭐ 返回**能力**不返回 role(T19):真正控制权限的是 permission,role 只是给人看的标签。
          //   模型该问的是"我能不能分配",不是"我是不是 leader" —— 后者会诱导它自己发明规则
          //   (比如"leader 应该也能看全部执行记录"),而那不是权限模型说了算的。
          capabilities: {
            canDispatch: permissions.includes(Permission.PLAN_DISPATCH),
            canViewAllPlans: permissions.includes(Permission.PLAN_VIEW_ALL),
            canExecute: permissions.includes(Permission.PLAN_EXECUTE),
          },
          clinicIds: scope.clinicIds,
          tenantId: scope.tenantId,
          // ⚠️ canDispatch=false 时助手要说"登录态可能已过期,请重新登录",**不要**说"你没有权限":
          //   权限是按 role 现算的,但 token 里的 role 是签发时固化的 ——
          //   真正的高频原因是 token 旧了,不是这个人真没权限。
          hint: permissions.includes(Permission.PLAN_DISPATCH)
            ? '主管工作流:可发起批次分配'
            : '客服工作流:只处理自己名下的任务;若你确信自己是主管,可能是登录态已过期,请重新登录',
        }),
    );

    server.registerTool(
      'find_patient',
      {
        description:
          '按姓名/手机号/患者号模糊检索患者,返回极简候选卡片(手机号掩码)用于消歧。先用它拿到 patientId,再调其它工具。',
        inputSchema: {
          query: z.string().describe('姓名 / 手机号 / 患者号(模糊匹配)'),
          limit: z.number().int().min(1).max(50).optional(),
        },
      },
      async ({ query, limit }) => jsonResult(await this.patient.search(scope, query, limit ?? 10)),
    );

    server.registerTool(
      'get_patient_overview',
      {
        description:
          '一次拉取患者 360 全景:画像要点 + 近期事实 + 当前召回计划。召回前的首选工具,省去多次往返。',
        inputSchema: { patientId: z.string() },
      },
      async ({ patientId }) => {
        await this.assertPatientInScope(scope, patientId);
        const [persona, recallPlan, timeline] = await Promise.all([
          this.persona.getCurrent(scope, patientId),
          this.activeRecallPlan(scope, patientId),
          this.patient.getTimeline(scope, patientId, 20),
        ]);
        return jsonResult({
          patient: patientCard(timeline.patient),
          persona,
          recallPlan,
          recentFacts: timeline.facts,
        });
      },
    );

    server.registerTool(
      'get_persona',
      {
        description:
          '患者全量画像:RFM 价值分群 / 生命周期 / 治疗史 / 治疗敏感 / 禁忌 / 潜在治疗 等所有 persona 特征(PAC 的推断分析层)。',
        inputSchema: { patientId: z.string() },
      },
      async ({ patientId }) => {
        await this.assertPatientInScope(scope, patientId);
        return jsonResult(await this.persona.getCurrent(scope, patientId));
      },
    );

    server.registerTool(
      'get_facts',
      {
        description:
          '患者客观事实数据(诊断/治疗/预约/收费等 active 版本时间轴)。只给事实,不含推断分析(分析见 get_persona)。',
        inputSchema: {
          patientId: z.string(),
          limit: z.number().int().min(1).max(200).optional(),
        },
      },
      async ({ patientId, limit }) => {
        // 无需单独 assertPatientInScope:getTimeline 内部 findFirst{hostId,tenantId} 且
        // 越租户即抛 NotFound —— 已自带租户隔离(与其它 4 个工具的显式 assert 等价安全)。
        const t = await this.patient.getTimeline(scope, patientId, limit ?? 50);
        return jsonResult({ patient: patientCard(t.patient), facts: t.facts });
      },
    );

    server.registerTool(
      'get_recall_plan',
      {
        description:
          '患者当前的召回计划:为什么召回(场景/原因)、优先级、目标诊所、状态。无活跃计划则返回 null。',
        inputSchema: { patientId: z.string() },
      },
      async ({ patientId }) => {
        await this.assertPatientInScope(scope, patientId);
        return jsonResult(await this.activeRecallPlan(scope, patientId));
      },
    );

    server.registerTool(
      'list_recall_queue',
      {
        description:
          '召回工作台:列出待跟进的召回计划(view=pool 未分配召回池 / mine 我名下),按优先级排序。回答"现在该联系谁 / 今日推荐"。' +
          '\n支持画像圈人(personaTags)+ 病种(scenario)+ 关键字(keyword:姓名/手机/患者号)+ 真实号(phoneVerified)筛选。' +
          '\n' +
          PERSONA_TAGS_DESC,
        inputSchema: {
          view: z.enum(['pool', 'mine']).optional().describe('pool=未分配召回池(默认) / mine=我名下'),
          personaTags: z.string().optional().describe(PERSONA_TAGS_DESC),
          scenario: z
            .string()
            .optional()
            .describe('召回场景过滤,如 treatment_initiation_recall(启治召回)'),
          status: z.enum(['active', 'assigned', 'completed', 'abandoned']).optional(),
          keyword: z.string().optional().describe('姓名 / 手机 / 患者号 模糊匹配'),
          phoneVerified: z.boolean().optional().describe('只看真实号码(已核实)'),
          sort: z
            .enum(['priority_desc', 'priority_asc', 'created_desc'])
            .optional()
            .describe('排序,默认 priority_desc'),
          clinicId: z.string().optional(),
          limit: z.number().int().min(1).max(100).optional(),
        },
      },
      async ({ view, personaTags, scenario, status, keyword, phoneVerified, sort, clinicId, limit }) => {
        // ⭐ view 的权限分流(2026-08 补):`plan.service.list` **只对 view='all' 校验 PLAN_VIEW_ALL**,
        //   `view='pool'` 一路无校验 —— 于是客服在前端看不到召回池(T16 已撤入口),
        //   却可以直接问助手「召回池里还有谁」把整池捞出来,绕过 T16。
        //   这里按能力降级:没有看全池的权限就只给 'mine'。
        //   ⚠️ 是**静默降级**不是报错:客服问"今天该联系谁"是正当需求,
        //   给他自己的单就好,不该甩一个权限错误让他以为系统坏了。
        const canSeePool = permissions.includes(Permission.PLAN_VIEW_ALL);
        const effectiveView = view === 'mine' ? 'mine' : canSeePool ? (view ?? 'pool') : 'mine';
        // 注:schema 的诊所过滤字段是 targetClinicId(不是 clinicId);以前 cast 成 any 传 clinicId
        // 被静默忽略。这里类型化构造,过滤真正生效。
        const query: ListPlansQueryDto = {
          view: effectiveView,
          sort: sort ?? 'priority_desc',
          page: 1,
          pageSize: limit ?? 20,
          ...(clinicId ? { targetClinicId: clinicId } : {}),
          ...(personaTags ? { personaTags } : {}),
          ...(scenario ? { scenario } : {}),
          ...(status ? { status } : {}),
          ...(keyword ? { keyword } : {}),
          ...(phoneVerified !== undefined ? { phoneVerified } : {}),
        };
        return jsonResult(await this.plans.list(scope, query, permissions));
      },
    );

    server.registerTool(
      'recall_queue_stats',
      {
        description:
          '召回池数字概览:总量 + 优先级分档(高≥70 / 中 40-69 / 低<40)+ 病种分布。' +
          '"今日推荐"先用它给摘要(如"今天 320 条,缺牙 80 / 牙周 60,高优 45"),再用 list_recall_queue 取明细。' +
          '支持同样的 view / personaTags / scenario / clinicId 圈定范围。',
        inputSchema: {
          view: z.enum(['pool', 'mine']).optional().describe('pool=召回池(默认) / mine=我名下'),
          personaTags: z.string().optional().describe(PERSONA_TAGS_DESC),
          scenario: z.string().optional(),
          clinicId: z.string().optional(),
        },
      },
      async ({ view, personaTags, scenario, clinicId }) => {
        // 同 list_recall_queue:没有看全池的权限就只统计自己的(否则总数本身就泄漏了池子规模)
        const canSeePool = permissions.includes(Permission.PLAN_VIEW_ALL);
        const query: ListPlansQueryDto = {
          view: view === 'mine' ? 'mine' : canSeePool ? (view ?? 'pool') : 'mine',
          sort: 'priority_desc',
          page: 1,
          pageSize: 1, // stats 不取明细行
          ...(clinicId ? { targetClinicId: clinicId } : {}),
          ...(personaTags ? { personaTags } : {}),
          ...(scenario ? { scenario } : {}),
        };
        return jsonResult(await this.plans.queueStats(scope, query, permissions));
      },
    );

    // ═══════════════════════════════════════════════════════════
    // 主管专属工具 —— **条件注册**:没有 plan:dispatch 的人连工具清单里都看不到
    // ═══════════════════════════════════════════════════════════
    //
    // ⚠️ 为什么是"不注册"而不是"注册了再在 handler 里拒":
    //   模型看得见的工具就会去试,试了被拒它会自己编解释("可能是权限问题,要不你换个账号"),
    //   对客服来说这是纯噪声。不注册则它压根不知道有这回事,行为自然收敛。
    // ⚠️ 这条依赖 `McpClientService.listTools` 的**能力分桶缓存**(mcp-client.service.ts)——
    //   缓存不分桶的话,进程重启后第一个进来的人的清单会被全公司复用,当场串号。
    if (permissions.includes(Permission.PLAN_DISPATCH)) {
      server.registerTool(
        'get_agents',
        {
          description:
            '某诊所的在岗客服名册 + 各自在手负载。分配前用它看"有哪些人、谁手上空"。' +
            '\n⚠️ 在岗按「近 N 月有回访记录」近似判定,**不代表系统确认在职**;' +
            '名册外的客服也可以指定(用 include 传 userId)。' +
            '\n⚠️ 容量上限是**默认值**不是实测,返回里带 capacityRange 与 inHand,' +
            '**不要替主管做减法说"还能吃 N 个"** —— 他知道谁在休假,你不知道。',
          inputSchema: {
            clinicId: z.string().describe('诊所 id(必填,名册天然是诊所维度的)'),
            months: z.number().int().min(1).max(36).optional().describe('在岗窗口月数,默认 12'),
            include: z
              .array(z.string())
              .optional()
              .describe('额外带上这些 userId(主管点名的人,即使不在名册)'),
          },
        },
        async ({ clinicId, months, include }) =>
          jsonResult(await this.roster.list(scope, clinicId, { months, extraUserIds: include })),
      );

      // ⛔ **`propose_assignment` 刻意不在这里注册** —— 它是 assistant 的**本地工具**。
      //   原因:确认单载荷含**几百个 planId**,MCP 工具的返回值会原样回灌进模型上下文
      //   (实测一批 850 人 ≈ 12k token),而模型对它唯一要做的事是"转述一句话"。
      //   本地工具可以走**侧信道**把肥载荷直接推给前端渲染,只回给模型一句短话。
      //   见 assistant.service 的 propose_assignment。
      server.registerTool(
        'list_assignment_batches',
        {
          description:
            '我分过的批次列表 + 每批汇总(分了多少 / 还在手 / 已退回 / 涉及几个客服)。' +
            '回答"我分的那些批,哪批出问题了"。要看某批细节再用 get_assignment_detail。',
          inputSchema: {
            mine: z.boolean().optional().describe('只看自己发起的,默认看本范围全部'),
          },
        },
        async ({ mine }) =>
          jsonResult(await this.assignments.list(scope, mine ? scope.userId : undefined)),
      );

      server.registerTool(
        'get_assignment_detail',
        {
          description:
            '单个批次的全貌:按客服拆 + 退回原因分布 + 未动过的条数。' +
            '\n⚠️ 退回率**永远给两个数**:「退回 5 / 已处置 40 = 12.5%(另有 60 条未动)」——' +
            '"没人动"和"动了但退回"是完全不同的信号,只报一个百分比会让主管把前者误读成后者。' +
            '\n⚠️ 分母小的时候(如 <50)直接说"样本量不足",**不要输出百分比、不要画图**。',
          inputSchema: { assignmentId: z.string() },
        },
        async ({ assignmentId }) => jsonResult(await this.assignments.detail(scope, assignmentId)),
      );
    }

    return server;
  }

  /** 越权防护:确认该 patientId 属当前租户(persona.getCurrent 等不带 scope 的读之前必调)。 */
  private async assertPatientInScope(scope: TenantScopeContext, patientId: string): Promise<void> {
    const p = await this.prisma.patient.findFirst({
      // MCP 走 @Public 无 ALS 上下文 → 纵深防御不兜,品牌隔离全靠这里显式过滤
      where: {
        id: patientId,
        hostId: scope.hostId,
        tenantId: scope.tenantId,
        ...(scope.sourceUnits.length ? { sourceUnit: { in: scope.sourceUnits } } : {}),
      },
      select: { id: true },
    });
    if (!p) throw new Error(`patient ${patientId} 不在当前租户范围内`);
  }

  private async activeRecallPlan(scope: TenantScopeContext, patientId: string) {
    const plan = await this.prisma.followupPlan.findFirst({
      where: {
        hostId: scope.hostId,
        tenantId: scope.tenantId,
        patientId,
        ...(scope.sourceUnits.length ? { patient: { sourceUnit: { in: scope.sourceUnits } } } : {}),
        status: { in: ['active', 'assigned'] },
        supersededAt: null,
      },
      orderBy: { priorityScore: 'desc' },
      select: {
        id: true,
        status: true,
        priorityScore: true,
        targetClinicId: true,
        assigneeUserId: true,
        snoozedUntil: true,
      },
    });
    if (!plan) return null;
    const reasons = await this.prisma.planReason.findMany({
      where: { planId: plan.id },
      select: { scenario: true, priorityScore: true, reason: true },
    });
    return {
      planId: plan.id,
      status: plan.status,
      priorityScore: plan.priorityScore,
      targetClinicId: plan.targetClinicId,
      assigned: !!plan.assigneeUserId,
      snoozedUntil: plan.snoozedUntil ? plan.snoozedUntil.toISOString() : null,
      reasons,
    };
  }
}
