import { loadDocumentFont } from '../../../packages/document-fonts'
import { reactive } from 'vue'

import {
  consumeSigningToken,
  fetchSigningContext,
  saveSigningForm,
  uploadSigningSignature,
} from '@/api'
import type {
  SignDeliveryChannel,
  PatientAnswer,
  SignatureUploadResponse,
  SigningContextResponse,
} from '@/api/types'
import { DEMO_DOCUMENT_HTML, DEMO_PATIENT_FIELD_ID, DEMO_STAFF_ANSWERS } from '@/mock/demo-document'
import { DEMO_NARCOTIC_HTML, DEMO_NARCOTIC_STAFF_ANSWERS } from '@/mock/demo-narcotic'
import type { SignerRelation, SignFlowState } from '@/types/signing'
import {
  readPendingSigningUpload,
  removePendingSigningUpload,
  savePendingSigningUpload,
} from '@/utils/signing-vault'
import { buildSignaturePngMetadata } from '@/utils/signing-png'

/**
 * 本地会话（sessionStorage）。
 *
 * 为什么需要它：`EntryView` 会在请求前把 `token` 从地址栏清掉（防外泄，必要），
 * 但清掉之后患者只要**下拉刷新 / 切后台被系统回收 / 误触返回**，就再也进不来了 ——
 * 表现成「链接失效」，而链接其实还是好的。
 *
 * 所以消费成功后把投递凭证与上下文缓存到 sessionStorage（关掉标签页即失效，
 * 不写 localStorage 是为了不在这台设备上长期留患者信息）。
 */
const SESSION_KEY = 'medical-sign:patient-session'

interface PersistedSession {
  taskId: string | null
  taskNo: string
  deliveryId: string | null
  uploadToken: string | null
  channel: SignDeliveryChannel | ''
  expiresAt: string | null
  savedAt: number
  /** 保存于首次 consume 之前；响应丢失后使用同一 token 和 key 安全重试。 */
  pendingToken: string | null
  consumeIdempotencyKey: string | null
  uploadIdempotencyKey: string | null
  /** 连上下文一起缓存：刷新后没有 token 可再用，重拉不了 */
  context: SigningContextResponse | null
}

const initialState: SignFlowState = {
  mode: 'mock',
  status: 'idle',
  taskStatus: '',
  patientName: '张*',
  sex: '',
  age: '',
  visitNo: 'MZ20260827018',
  department: '',
  documentFontFamily: '',
  documentFontReady: false,
  documentTitle: '儿科急诊特殊检查知情同意书',
  templateVersion: 'v1.0.0',
  documentContentHtml: '',
  contentSha256: '',
  staffAnswers: {},
  form: null,
  formSaving: false,
  formError: '',
  fields: [],
  signatureFields: [],
  documentLoaded: false,
  documentError: '',
  taskNo: 'CT-20260827-001',
  taskId: '',
  deliveryId: '',
  uploadToken: '',
  channel: '',
  consentAccepted: false,
  signerType: '',
  signerName: '',
  relation: '',
  signatureCaptured: false,
  submittedAt: '',
  backendStatus: '',
  pipelineId: '',
  uploadResult: null,
  errorMessage: '',
}

export const signingState = reactive<SignFlowState>({ ...initialState })

/** 最近一次拿到的上下文，只用于写本地缓存 */
let lastContext: SigningContextResponse | null = null
let sessionExpiresAt: string | null = null
let pendingToken: string | null = null
let consumeIdempotencyKey: string | null = null
let uploadIdempotencyKey: string | null = null

let formQueue: Promise<void> = Promise.resolve()

export function updatePatientAnswer(id: string, value: PatientAnswer) {
  const form = signingState.form
  const proof = currentProof()
  if (!form?.editable || !proof || signingState.status === 'submitting' || signingState.formError)
    return
  if (!form.fields.some((field) => field.id === id && field.editable)) return
  form.answers = { ...form.answers, [id]: value }
  const answers = JSON.parse(JSON.stringify(form.answers)) as Record<string, PatientAnswer>
  signingState.formSaving = true
  formQueue = formQueue.then(async () => {
    if (signingState.form !== form || signingState.formError) return
    try {
      const saved = await saveSigningForm(proof, form.revision, answers)
      form.revision = saved.revision
    } catch {
      signingState.formError = '填写内容保存失败，请重新加载并核对后再签署。'
    }
  })
  const current = formQueue
  void current.finally(() => {
    if (current === formQueue) signingState.formSaving = false
  })
}

export async function flushPatientAnswers() {
  await formQueue
  if (signingState.formError) throw new Error(signingState.formError)
  const form = signingState.form
  if (!form) return
  for (const field of form.fields) {
    if (!field.editable || !field.required) continue
    const value = form.answers[field.id]
    if (
      value === undefined ||
      value === false ||
      (typeof value === 'string' && !value.trim()) ||
      (Array.isArray(value) && !value.length)
    ) {
      throw new Error(`请完成必填项：${field.label}`)
    }
  }
}

export function resetSignFlow() {
  Object.assign(signingState, {
    ...initialState,
    staffAnswers: {},
    fields: [],
    signatureFields: [],
    uploadResult: null,
  })
  lastContext = null
  sessionExpiresAt = null
  pendingToken = null
  consumeIdempotencyKey = null
  uploadIdempotencyKey = null
}

function getErrorMessage(error: unknown) {
  return error instanceof Error ? error.message : '签署链接验证失败，请联系现场医务人员。'
}

/* ---------------- 本地会话 ---------------- */

function readPersistedSession(): PersistedSession | null {
  try {
    const raw = sessionStorage.getItem(SESSION_KEY)

    if (!raw) {
      return null
    }

    const parsed = JSON.parse(raw) as PersistedSession

    if (
      !parsed ||
      (!parsed.pendingToken && (!parsed.taskId || !parsed.deliveryId || !parsed.uploadToken))
    ) {
      return null
    }

    return parsed
  } catch {
    return null
  }
}

function createIdempotencyKey() {
  if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
    return `patient-h5-${crypto.randomUUID()}`
  }

  return `patient-h5-${Date.now()}-${Math.random().toString(36).slice(2)}`
}

function persistSession() {
  if (
    !pendingToken &&
    (!signingState.taskId || !signingState.deliveryId || !signingState.uploadToken)
  ) {
    return
  }

  try {
    const payload: PersistedSession = {
      taskId: signingState.taskId || null,
      taskNo: signingState.taskNo,
      deliveryId: signingState.deliveryId || null,
      uploadToken: signingState.uploadToken || null,
      channel: signingState.channel,
      expiresAt: sessionExpiresAt,
      savedAt: Date.now(),
      pendingToken,
      consumeIdempotencyKey,
      uploadIdempotencyKey,
      context: lastContext,
    }

    sessionStorage.setItem(SESSION_KEY, JSON.stringify(payload))
  } catch {
    throw new Error('浏览器无法保存本次签署恢复凭证，请检查隐私或存储设置后重新打开链接。')
  }
}

export function clearPersistedSession() {
  try {
    sessionStorage.removeItem(SESSION_KEY)
  } catch {
    // 同上
  }
}

function isSessionExpired(session: PersistedSession) {
  const expiresAt = session.expiresAt ? new Date(session.expiresAt).getTime() : Number.NaN

  if (!Number.isNaN(expiresAt)) {
    return expiresAt <= Date.now()
  }

  // A response without an explicit expiry is still bounded to the service's 48h signing window.
  return Date.now() - session.savedAt > 48 * 60 * 60 * 1000
}

/** 用本地会话恢复现场。恢复不了返回 false，由调用方走「链接无效」分支 */
function restoreSession() {
  const session = readPersistedSession()

  if (!session) {
    return false
  }

  if (isSessionExpired(session)) {
    clearPersistedSession()
    return false
  }

  signingState.mode = 'real'
  signingState.taskId = session.taskId ?? ''
  signingState.taskNo = session.taskNo || session.taskId || ''
  signingState.deliveryId = session.deliveryId ?? ''
  signingState.uploadToken = session.uploadToken ?? ''
  signingState.channel = session.channel
  sessionExpiresAt = session.expiresAt
  pendingToken = session.pendingToken
  consumeIdempotencyKey = session.consumeIdempotencyKey
  uploadIdempotencyKey = session.uploadIdempotencyKey

  if (session.context) {
    applyContext(session.context)
  }

  signingState.status = session.pendingToken ? 'loading' : 'ready'
  return true
}

/* ---------------- 上下文 ---------------- */

/**
 * 把 `context` 响应铺进页面状态。
 *
 * 逐字段判空再覆盖（而不是整体替换）：后端可能只补了一部分字段，
 * 缺的字段应该保留原值，不能把患者姓名冲成空串。
 */
function applyContext(context: SigningContextResponse) {
  lastContext = context

  const patient = context.patient ?? undefined

  if (patient?.name?.trim()) {
    signingState.patientName = patient.name.trim()
  }

  if (patient?.sex) {
    signingState.sex = patient.sex
  }

  if (patient?.age !== null && patient?.age !== undefined) {
    signingState.age = String(patient.age)
  }

  if (patient?.visitNo) {
    signingState.visitNo = patient.visitNo
  }

  if (patient?.department) {
    signingState.department = patient.department
  }

  // 签署人由医生在医护端填好，患者端只展示 —— 取不到就退回患者本人
  const signer = context.signer ?? undefined

  if (signer?.type) {
    signingState.signerType = signer.type
  }

  if (signer?.name?.trim()) {
    signingState.signerName = signer.name.trim()
  }

  if (signer?.relation) {
    signingState.relation = signer.relation as SignerRelation
  }

  const template = context.template ?? undefined

  if (template?.name?.trim()) {
    signingState.documentTitle = template.name.trim()
  }

  if (template?.versionNo) {
    signingState.templateVersion = template.versionNo
  }

  if (context.document) {
    signingState.documentContentHtml = context.document.contentHtml ?? ''
    signingState.contentSha256 = context.document.contentSha256 ?? ''
  }

  if (context.staffAnswers) {
    signingState.staffAnswers = { ...context.staffAnswers }
  }

  signingState.form = context.form
    ? { ...context.form, answers: { ...context.form.answers } }
    : null
  if (context.form) signingState.documentContentHtml = context.form.contentHtml
  signingState.formError = ''

  if (context.fields) {
    signingState.fields = [...context.fields]
  }

  if (context.signatureFields) {
    const patientField = context.signatureFields.find((field) => field.id === 'signature')
    signingState.signatureFields = patientField
      ? [patientField]
      : context.signatureFields.length === 1
        ? [...context.signatureFields]
        : []
  }

  if (context.status) {
    signingState.taskStatus = context.status
  }

  if (context.channel) {
    signingState.channel = context.channel
  }

  if (context.deliveryId) {
    signingState.deliveryId = context.deliveryId
  }

  if (context.uploadResult) {
    signingState.uploadResult = context.uploadResult
    signingState.pipelineId = context.uploadResult.pipelineId
  }

  signingState.backendStatus = context.status ?? signingState.backendStatus
  signingState.signatureCaptured = Boolean(
    context.uploadResult ||
    context.status === 'GENERATING' ||
    context.status === 'WAITING_CONFIRM' ||
    context.status === 'SIGNED',
  )

  if (context.uploadResult?.completedAt) {
    signingState.submittedAt = context.uploadResult.completedAt
  } else if (context.signedAt) {
    signingState.submittedAt = context.signedAt
  }

  if (context.expiresAt) {
    sessionExpiresAt = context.expiresAt
  }

  const hasPatientSignatureField = signingState.signatureFields.length > 0
  signingState.documentLoaded =
    Boolean(signingState.documentContentHtml) && hasPatientSignatureField
  signingState.documentError = signingState.documentLoaded
    ? ''
    : signingState.documentContentHtml
      ? '本文书尚未配置有效的患者 PDF 签名位置，请联系医务人员。'
      : '暂未读取到本次签署的文书正文，无法展示正式文书。'
}

function getHttpStatus(error: unknown) {
  if (typeof error !== 'object' || error === null || !('response' in error)) {
    return undefined
  }

  const response = (error as { response?: { status?: unknown } }).response
  return typeof response?.status === 'number' ? response.status : undefined
}

function isRejectedProof(error: unknown) {
  const status = getHttpStatus(error)
  return status === 401 || status === 403 || status === 404 || status === 410 || status === 422
}

function currentProof() {
  if (!signingState.taskId || !signingState.deliveryId || !signingState.uploadToken) {
    return null
  }

  return {
    taskId: signingState.taskId,
    deliveryId: signingState.deliveryId,
    uploadToken: signingState.uploadToken,
  }
}

function isPostUploadStatus(status: string) {
  return status === 'GENERATING' || status === 'WAITING_CONFIRM' || status === 'SIGNED'
}

async function loadSigningContext(): Promise<SigningContextResponse | null> {
  const proof = currentProof()

  if (!proof) {
    signingState.documentLoaded = false
    signingState.documentError = '签署凭证不完整，请重新打开签署链接。'
    return null
  }

  try {
    const context = await fetchSigningContext(proof)
    applyContext(context)
    signingState.documentFontReady = false
    signingState.documentFontFamily = await loadDocumentFont(
      context.document?.font ?? null,
      import.meta.env.VITE_API_BASE_URL || '/api',
    )
    signingState.documentFontReady = true
    persistSession()
    return context
  } catch (error) {
    if (isRejectedProof(error)) {
      clearPersistedSession()
      await removePendingSigningUpload(signingState.taskId).catch(() => undefined)
      signingState.taskId = ''
      signingState.deliveryId = ''
      signingState.uploadToken = ''
    }
    signingState.documentLoaded = false
    signingState.documentError = isRejectedProof(error)
      ? '签署凭证已失效或被撤销，请联系现场医务人员重新发起。'
      : '暂时无法读取本次签署的文书内容，请检查网络后重试。'
    return null
  }
}

/**
 * 演示模式的上下文。
 *
 * 与真实模式走**同一条渲染路径**（`DocumentPaper` 读的是同样的字段），
 * 只是数据是内置的 —— 演示与真实共用一套代码，才不会出现
 * 「演示模式下好好的、真实模式一片空白」这种最难查的偏差。
 */
function applyDemoContext() {
  // `?demo=narcotic` 切到精麻同意书：它是演示文库（clinical-web）里唯一真实存在的模板，
  // 字段也最多（代办人 / 身份核验 / 用药信息），最能压出占位符渲染的问题
  const useNarcotic = new URLSearchParams(window.location.search).get('demo') === 'narcotic'

  signingState.documentTitle = useNarcotic
    ? '麻醉药品、精神药品知情同意书'
    : 'CT 增强扫描知情同意书'
  signingState.templateVersion = 'v1.0.0'
  signingState.documentContentHtml = useNarcotic ? DEMO_NARCOTIC_HTML : DEMO_DOCUMENT_HTML
  signingState.staffAnswers = {
    ...(useNarcotic ? DEMO_NARCOTIC_STAFF_ANSWERS : DEMO_STAFF_ANSWERS),
  }
  signingState.fields = [
    { id: DEMO_PATIENT_FIELD_ID, label: '患者签名', kind: 'signature', required: true },
  ]
  signingState.documentFontReady = true
  signingState.documentLoaded = true
  signingState.documentError = ''
  signingState.taskStatus = 'WAITING_SIGN'
  signingState.signerName = signingState.signerName || signingState.patientName
  signingState.relation = signingState.relation || '本人'
}

/* ---------------- 流程 ---------------- */

export async function initializeSignFlow(token?: string) {
  resetSignFlow()

  const candidate = token?.trim()

  // 地址栏没有 token 时恢复：若上次消费响应丢失，按原 key 重放；若已经拿到 proof，重取上下文。
  if (!candidate && restoreSession()) {
    if (pendingToken && consumeIdempotencyKey) {
      return consumeAndLoad(pendingToken, consumeIdempotencyKey)
    }
    const context = await loadSigningContext()
    signingState.status = context ? 'ready' : 'error'
    signingState.errorMessage = context ? '' : signingState.documentError
    return Boolean(context)
  }

  const shouldUseRealFlow = Boolean(candidate) || import.meta.env.VITE_USE_MOCK === 'false'

  signingState.mode = shouldUseRealFlow ? 'real' : 'mock'

  if (!shouldUseRealFlow) {
    // 演示模式也要给一份带占位符的正文，否则「医生填了什么、患者该签哪里」根本验不了
    applyDemoContext()
    signingState.status = 'ready'
    return true
  }

  if (!candidate) {
    signingState.status = 'blocked'
    signingState.errorMessage = '请使用短信或二维码中的有效签署链接进入。'
    return false
  }

  signingState.status = 'loading'
  pendingToken = candidate
  consumeIdempotencyKey = createIdempotencyKey()
  // Store before the network call so a response lost after server commit can be replayed safely.
  persistSession()
  return consumeAndLoad(candidate, consumeIdempotencyKey)
}

async function consumeAndLoad(token: string, idempotencyKey: string) {
  signingState.status = 'loading'
  try {
    const session = await consumeSigningToken({ token }, idempotencyKey)
    signingState.taskId = session.taskId
    signingState.taskNo = session.taskId
    signingState.deliveryId = session.deliveryId
    signingState.uploadToken = session.uploadToken
    signingState.channel = session.channel
    pendingToken = null
    signingState.status = 'ready'
    persistSession()

    const context = await loadSigningContext()
    if (!context) {
      signingState.status = 'error'
      signingState.errorMessage = signingState.documentError
      return false
    }

    // The server status is authoritative after response loss; do not ask the patient to sign twice.
    if (isPostUploadStatus(context.status ?? '')) {
      signingState.signatureCaptured = true
      signingState.status = 'submitted'
    }
    return true
  } catch (error) {
    signingState.status = 'error'
    signingState.errorMessage = getErrorMessage(error)
    return false
  }
}

export async function submitRealSignature(input: {
  file: Blob
  consentAccepted: boolean
}): Promise<SignatureUploadResponse | null> {
  if (signingState.mode !== 'real') {
    throw new Error('当前是演示签署流程')
  }

  if (
    !signingState.taskId ||
    !signingState.deliveryId ||
    !signingState.uploadToken ||
    !input.consentAccepted ||
    !signingState.documentLoaded ||
    !signingState.documentFontReady
  ) {
    throw new Error('签署凭证或知情确认状态无效，请重新打开签署链接。')
  }

  signingState.status = 'submitting'
  signingState.errorMessage = ''

  try {
    const signatureField = signingState.signatureFields[0]
    if (!signatureField) {
      throw new Error('当前文书未配置患者签名位置，请联系现场医务人员。')
    }
    const signerType = signingState.signerType.toUpperCase() === 'FAMILY' ? 'FAMILY' : 'SELF'
    const signerName = signingState.signerName.trim() || signingState.patientName.trim()
    const relation = signingState.relation || '本人'
    if (!signerName) {
      throw new Error('签署人信息不完整，请联系现场医务人员。')
    }
    const observedSignedAt = new Date().toISOString()
    const metadata = await buildSignaturePngMetadata(input.file, signatureField)
    const pending = await readPendingSigningUpload(signingState.taskId)
    const idempotencyKey = pending?.idempotencyKey ?? uploadIdempotencyKey ?? createIdempotencyKey()
    uploadIdempotencyKey = idempotencyKey
    if (!pending) await flushPatientAnswers()
    const signer = {
      answerRevision: signingState.form?.revision,
      type: signerType,
      name: signerName,
      relation,
      consentAccepted: true as const,
      observedSignedAt,
    }

    // Preserve the exact PNG and idempotency key before upload; response loss can then retry
    // without asking the patient to redraw or creating a second pipeline.
    await savePendingSigningUpload({
      taskId: signingState.taskId,
      deliveryId: signingState.deliveryId,
      expiresAt: sessionExpiresAt,
      file: input.file,
      metadata: pending?.metadata ?? metadata,
      signer: pending?.signer ?? signer,
      idempotencyKey,
      savedAt: Date.now(),
    })

    const payload = await readPendingSigningUpload(signingState.taskId)
    if (!payload) {
      throw new Error('签署恢复信息已过期，请联系现场医务人员重新发起。')
    }
    const result = await uploadSigningSignature({
      taskId: signingState.taskId,
      deliveryId: signingState.deliveryId,
      uploadToken: signingState.uploadToken,
      file: payload.file,
      metadata: payload.metadata,
      signer: payload.signer,
      idempotencyKey: payload.idempotencyKey,
    })

    signingState.signatureCaptured = true
    signingState.submittedAt = result.completedAt ?? new Date().toLocaleString('zh-CN')
    signingState.backendStatus = result.status
    signingState.pipelineId = result.pipelineId
    signingState.uploadResult = result
    // 保留短期 proof 以便结果页刷新时安全读取状态；服务端只允许它读上下文，不能重复上传。
    signingState.status = 'submitted'
    await removePendingSigningUpload(signingState.taskId)
    persistSession()
    return result
  } catch (error) {
    const refreshedContext = await loadSigningContext().catch(() => null)
    if (refreshedContext && isPostUploadStatus(refreshedContext.status ?? '')) {
      signingState.signatureCaptured = true
      signingState.status = 'submitted'
      signingState.backendStatus = refreshedContext.status ?? ''
      signingState.submittedAt = refreshedContext.signedAt ?? new Date().toISOString()
      await removePendingSigningUpload(signingState.taskId).catch(() => undefined)
      persistSession()
      return null
    }
    if ([400, 409, 422].includes(getHttpStatus(error) ?? 0)) {
      await removePendingSigningUpload(signingState.taskId).catch(() => undefined)
      uploadIdempotencyKey = null
    }
    signingState.status = 'ready'
    signingState.errorMessage = getErrorMessage(error)
    throw error
  }
}