/**
 * 飞书模式自动填写处理逻辑（适配 feishu.cn 域名的飞书招聘平台）
 * 基于通用模式复制而来，后续在此基础上添加飞书平台特有的表单组件处理逻辑
 *
 * 【规范】所有填充操作必须走 fillMatchedField 统一入口，
 * 选择器检测必须走 detectPickerField 统一入口，
 * 不要在此文件中自行编写选择器操作逻辑，必须引用 lib 中已封装的方法。
 */

import { fillMatchedField, isSearchPickerField, fillSearchPickerField, isTimePeriodField, isTimeSingleField, fillTimePeriodField, fillTimeSingleField } from "~lib/autofill"
import { delay } from "~utils/delay"
import { extractDomStructure, detectPageLanguage, isJobApplicationForm, buildSelector } from "~lib/dom"
import { matchFormFieldsInRange, matchMainFields } from "~lib/formMatcher"
import { detectPickerField } from "~lib/pickerDetector"
import { detectAndUploadResume } from "~lib/resumeUpload"
import { getMockResumeData2, JOB_FORM_LABELS } from "~lib/constants"
import { fillDatePicker } from "~lib/datePicker"
import { getResumeFieldValue } from "~lib/resumeDataHelper"
import { locateExperienceSections, expandExperienceSections, sortExperienceByTime, relocateSegmentContainer, getAllPageTitles, findAddButton, clickAddButton } from "~lib/experienceSection"
import type { ExperienceSectionLocateResult } from "~lib/experienceSection"
import type { MatchedFormField, ResumeData, ExperienceSection, JobInfo, UnmatchedFormField } from "~lib/types"
import { setFieldHighlight, isRequiredField } from "~lib/formStyle"
import { get as storageGet, set as storageSet } from "~utils/storage"
import { findLabelForInput } from "~lib/labelFinder"

/** 飞书模式自动填写的参数 */
export interface AutoFillFeishuParams {
  /** 简历数据（接口获取的） */
  resumeData: ResumeData | null
  /** 岗位信息 */
  jobInfo: JobInfo | null
}

/** 飞书模式自动填写的返回结果 */
export interface AutoFillFeishuResult {
  /** 填写成功数 */
  success: number
  /** 填写失败数 */
  failed: number
  /** 跳过数 */
  skipped: number
  /** 检测到的页面语言 */
  lang: "zh" | "en"
  /** 是否为表单页 */
  isFormPage: boolean
  /** 使用的简历数据（可能是接口数据或 mock 数据） */
  resumeData: ResumeData | null
  /** 匹配到的非经历区域字段 */
  formFields: MatchedFormField[]
  /** 收集到的待填写空白字段 */
  unmatchedFields: UnmatchedFormField[]
  /** 经历段落定位结果（用于 fillStats 分段展示） */
  sectionResults: ExperienceSectionLocateResult[]
  /** 经历段落展开结果（用于 fillStats 分段展示） */
  expandedResults: ExperienceSectionLocateResult[]
}

/**
 * 飞书模式自动填写主流程（基于通用模式，适配 feishu.cn 域名的飞书招聘平台）
 * 流程：提取 DOM → 检测语言 → 判断是否表单页 → 上传简历 → 匹配+填写经历 → 匹配+填写非经历 → 收集空白字段
 *
 * 【待适配】飞书平台特殊表单组件：
 *  - TODO: 飞书自定义单选组（如有特殊类名需在此处理）
 *  - TODO: 飞书级联选择器（地区、学校等多级联动）
 *  - TODO: 飞书日期选择器（如有自定义日期组件需特殊处理）
 *  - TODO: 飞书文件上传组件（简历附件上传的特殊逻辑）
 */
export async function handleAutoFillFeishu(params: AutoFillFeishuParams): Promise<AutoFillFeishuResult> {
  const result: AutoFillFeishuResult = {
    success: 0, failed: 0, skipped: 0,
    lang: "zh", isFormPage: false,
    resumeData: params.resumeData,
    formFields: [],
    unmatchedFields: [],
    sectionResults: [],
    expandedResults: [],
  }

  // 1. 提取 DOM 结构
  const domStructure = extractDomStructure()
  console.log("===== OfferPie: 完整 DOM 树结构 =====")
  console.log(domStructure)
  console.log(`===== OfferPie: 结构总长度 ${domStructure.length} 字符 =====`)

  // 2. 检测页面语言
  const lang = detectPageLanguage(domStructure)
  result.lang = lang
  console.log(`===== OfferPie: 页面语言检测结果 = ${lang} =====`)

  // 3. 判断是否为职位申请表单页面
  const isForm = isJobApplicationForm(document.body, lang)
  result.isFormPage = isForm
  console.log(`===== OfferPie: 是否为职位申请表单页面 = ${isForm} =====`)

  if (!isForm) {
    console.log("===== OfferPie: 当前页面不是职位申请表单，跳过字段匹配 =====")
    return result
  }

  // 4. 获取简历数据（优先使用接口数据，无接口数据时 fallback 到 mock）
  const currentResumeData = params.resumeData || getMockResumeData2()
  result.resumeData = currentResumeData
  console.log(`===== OfferPie: 已加载简历数据，教育${currentResumeData.education.length}段 工作${currentResumeData.work.length}段 实习${currentResumeData.internship.length}段 项目${currentResumeData.project.length}段 竞赛${currentResumeData.competition.length}段 =====`)





  // 4.1 检测并上传简历文件
  // const resumeUrl = "https://offerpie.oss-cn-guangzhou.aliyuncs.com/%E5%AE%BE%E5%A4%95%E6%B3%95%E5%B0%BC%E4%BA%9A%E5%A4%A7%E5%AD%A6_%E4%B8%81%E5%B1%B9%E6%B6%B5.pdf"
  // const uploaded = await detectAndUploadResume(resumeUrl)
  // console.log(`===== OfferPie: 简历上传 ${uploaded ? "成功" : "跳过（未找到上传按钮或失败）"} =====`)
  // if (uploaded) await delay("high") // 等待网站解析简历

  // 4.5 定位经历区块并统计已展开段数
  const sectionResults = locateExperienceSections(document.body, lang)
  // 4.6 对比简历数据段数，点击添加按钮补足不够的段数
  const expandedResults = await expandExperienceSections(sectionResults, currentResumeData, lang)

  // 存入 result 供外部使用（如 fillStats 分段展示）
  result.sectionResults = sectionResults
  result.expandedResults = expandedResults

  // 4.65 【预匹配+标绿】经历段落添加完成后，一次性预匹配所有有简历数据的字段并标绿背景
  // 使用临时 usedInputs，不影响后续正式流程的匹配
  {
    const tempUsedInputs = new Set<Element>()
    // 预匹配经历区域字段
    for (const expResult of expandedResults) {
      if (!expResult.titleElement || expResult.expandedCount === 0) continue
      const section = expResult.section as ExperienceSection
      const sectionData = currentResumeData[section] as { startDate?: string; endDate?: string }[]
      if (!sectionData || sectionData.length === 0) continue

      const sortedIndices = sortExperienceByTime(sectionData)
      const segments = expResult.segmentRanges
      const fillCount = Math.min(sortedIndices.length, segments.length)

      for (let segIdx = 0; segIdx < fillCount; segIdx++) {
        const dataIdx = sortedIndices[segIdx]
        const segment = segments[segIdx]
        const segStartEl = segment.startElement
        const nextSegment = segIdx < segments.length - 1 ? segments[segIdx + 1] : null
        const allTitles = expandedResults.filter((r) => r.titleElement)
        const currentIdx = allTitles.findIndex((r) => r.titleElement === expResult.titleElement)
        const nextExpResult = currentIdx >= 0 && currentIdx < allTitles.length - 1 ? allTitles[currentIdx + 1] : null
        const segEndEl = nextSegment?.startElement || nextExpResult?.titleElement || null

        const segFields = matchFormFieldsInRange(lang, section, dataIdx, segStartEl, segEndEl, tempUsedInputs, segment.containerElement)
        for (const f of segFields) {
          const value = getResumeFieldValue(currentResumeData, f.section, dataIdx, f.resumeField)
          if (value && f.inputElement) {
            setFieldHighlight(f.inputElement, "green")
          }
        }
      }
    }
    // 预匹配非经历区域字段（main section）
    const tempExcludeRanges: { start: Element; end: Element | null }[] = []
    for (const expResult of expandedResults) {
      if (!expResult.titleElement) continue
      const titleEl = expResult.titleElement
      const allTitles = expandedResults.filter((r) => r.titleElement)
      const currentIdx = allTitles.findIndex((r) => r.titleElement === titleEl)
      const nextExpResult = currentIdx >= 0 && currentIdx < allTitles.length - 1 ? allTitles[currentIdx + 1] : null
      tempExcludeRanges.push({ start: titleEl, end: nextExpResult?.titleElement || null })
    }
    const tempMainFields = matchMainFields(document.body, lang, tempExcludeRanges, tempUsedInputs)
    for (const f of tempMainFields) {
      const value = getResumeFieldValue(currentResumeData, f.section, f.sectionIndex, f.resumeField)
      if (value && f.inputElement) {
        setFieldHighlight(f.inputElement, "green")
      }
    }
    console.log("===== OfferPie: 预匹配完成，已对有简历数据的字段标绿 =====")
  }

  // 4.7 检测第一段经历是否已被网站自动填写（上传简历后网站可能自动解析填入）
  let skipPhaseA = false
  for (const expResult of expandedResults) {
    if (!expResult.titleElement || expResult.expandedCount === 0) continue
    const section = expResult.section as ExperienceSection
    const segments = expResult.segmentRanges
    if (segments.length === 0) continue

    // 检查第一段经历的核心字段（学校/公司/项目名称）是否已有值
    const firstSeg = segments[0]
    if (firstSeg.containerElement) {
      const inputs = firstSeg.containerElement.querySelectorAll(
        "input:not([type='hidden']):not([type='submit']):not([type='button']):not([type='checkbox']):not([type='radio']):not([type='file']):not([disabled]), textarea:not([disabled])"
      )
      for (const inp of Array.from(inputs)) {
        const inputEl = inp as HTMLInputElement | HTMLTextAreaElement
        if (inputEl.value && inputEl.value.trim().length > 0) {
          skipPhaseA = true
          console.log(`===== OfferPie: 检测到第一段经历[${section}]已有数据（"${inputEl.value.trim().substring(0, 20)}"），跳过阶段A =====`)
          break
        }
      }
    }
    if (skipPhaseA) break
  }

  // 5. 经历数据按时间排序 + 经历区域字段匹配与填写（阶段A）
  console.log("===== OfferPie: 阶段A - 经历区域填写 =====")
  const usedInputs = new Set<Element>() // 全局已使用的 input 集合
  const excludeRanges: { start: Element; end: Element | null }[] = [] // 经历区域范围（用于阶段B排除）
  let lastTextInput: HTMLInputElement | HTMLTextAreaElement | null = null
  let lastTextInputIsPicker = false
  /** 阶段A已处理字段收集（用于末尾统计） */
  const phaseAFields: { labelText: string; inputElement: Element | null; filled: boolean; fillValue: string; section: string; segmentIndex: number }[] = []

  // 如果网站已自动填写经历，跳过阶段A，只记录排除范围
  if (skipPhaseA) {
    console.log("===== OfferPie: 阶段A 已跳过（网站已自动填写经历） =====")
    for (const expResult of expandedResults) {
      if (!expResult.titleElement) continue
      const titleEl = expResult.titleElement
      const allTitles = expandedResults.filter((r) => r.titleElement)
      const currentIdx = allTitles.findIndex((r) => r.titleElement === titleEl)
      const nextExpResult = currentIdx >= 0 && currentIdx < allTitles.length - 1 ? allTitles[currentIdx + 1] : null
      excludeRanges.push({ start: titleEl, end: nextExpResult?.titleElement || null })
    }
  } else {

  for (const expResult of expandedResults) {
    if (!expResult.titleElement || expResult.expandedCount === 0) continue
    const section = expResult.section as ExperienceSection
    const sectionData = currentResumeData[section] as { startDate?: string; endDate?: string }[]
    if (!sectionData || sectionData.length === 0) continue

    // 5.1 对该经历数据按时间排序（最新的在前面）
    const sortedIndices = sortExperienceByTime(sectionData)
    console.log(`  [${section}] 排序后索引: [${sortedIndices.join(",")}]`)

    // 5.2 记录经历区域范围（用于阶段B排除）
    const titleEl = expResult.titleElement
    const allTitles = expandedResults.filter((r) => r.titleElement)
    const currentIdx = allTitles.findIndex((r) => r.titleElement === titleEl)
    const nextExpResult = currentIdx >= 0 && currentIdx < allTitles.length - 1 ? allTitles[currentIdx + 1] : null
    excludeRanges.push({ start: titleEl, end: nextExpResult?.titleElement || null })

    // 5.3 逐段匹配并填写
    const segments = expResult.segmentRanges
    const fillCount = Math.min(sortedIndices.length, segments.length)

    for (let segIdx = 0; segIdx < fillCount; segIdx++) {
      const dataIdx = sortedIndices[segIdx]
      const segment = segments[segIdx]

      const segStartEl = segment.startElement
      const nextSegment = segIdx < segments.length - 1 ? segments[segIdx + 1] : null
      const segEndEl = nextSegment?.startElement || nextExpResult?.titleElement || null

      // 在该段范围内匹配字段
      const segFields = matchFormFieldsInRange(lang, section, dataIdx, segStartEl, segEndEl, usedInputs, segment.containerElement)
      console.log(`  [${section}] 第${segIdx + 1}段（数据索引${dataIdx}）匹配到 ${segFields.length} 个字段`)

      // 逐个填写
      for (let fIdx = 0; fIdx < segFields.length; fIdx++) {
        let f = segFields[fIdx]
        const value = getResumeFieldValue(currentResumeData, f.section, dataIdx, f.resumeField)
        if (value) f.fillValue = value

        // 【核心】如果 input 已脱离 DOM（React 重新渲染导致），用 locator 重新定位
        if (f.inputElement && !f.inputElement.isConnected) {
          console.log(`  [重新定位] "${f.labelText}" input 已脱离DOM (isConnected=false)`)
          let activeContainer: Element | null = null
          if (segment.locator) {
            activeContainer = relocateSegmentContainer(segment.locator)
          }
          if (activeContainer) {
            const freshInputs = activeContainer.querySelectorAll(
              "input:not([type='hidden']):not([type='submit']):not([type='button']):not([type='checkbox']):not([type='radio']):not([type='file']):not([disabled]), textarea:not([disabled])"
            )
            const ph = f.inputElement.getAttribute("placeholder") || ""
            let found: HTMLInputElement | HTMLTextAreaElement | null = null
            for (const inp of Array.from(freshInputs)) {
              const inputEl = inp as HTMLInputElement | HTMLTextAreaElement
              if (usedInputs.has(inp)) continue
              if (inputEl.value && inputEl.value.length > 0) continue
              if (inp.getAttribute("placeholder") === ph) { found = inputEl; break }
            }
            if (found) {
              f.inputElement = found
              usedInputs.add(found)
              console.log(`  [重新定位] "${f.labelText}" ✅ 已通过 locator 重新定位 (placeholder="${ph}")`)
            } else {
              console.log(`  [重新定位] "${f.labelText}" ❌ 容器内未找到 placeholder="${ph}" 的空 input`)
            }
          } else {
            console.log(`  [重新定位] "${f.labelText}" ❌ locator 重新定位容器失败`)
          }
        }

        // 【补充】如果 labelElement 也脱离了 DOM，重新定位
        if (f.labelElement && !f.labelElement.isConnected && segment.locator) {
          const activeContainer = relocateSegmentContainer(segment.locator)
          if (activeContainer) {
            const allLabels = activeContainer.querySelectorAll("label, span, div, td, th, p, legend, dt")
            for (const el of Array.from(allLabels)) {
              const directText = Array.from(el.childNodes)
                .filter((n) => n.nodeType === Node.TEXT_NODE)
                .map((n) => n.textContent?.trim())
                .filter(Boolean)
                .join("")
              if (directText && directText.includes(f.labelText) && directText.length < f.labelText.length + 20) {
                f.labelElement = el
                console.log(`  [重新定位] "${f.labelText}" labelElement ✅ 已重新定位`)
                break
              }
            }
          }
        }

        // 根据字段类型选择对应的填充方法（全部走已封装的统一入口）
        if (isTimePeriodField(f.key)) {
          const startDateVal = getResumeFieldValue(currentResumeData, f.section, dataIdx, "startDate")
          const endDateVal = getResumeFieldValue(currentResumeData, f.section, dataIdx, "endDate")
          let ok = await fillTimePeriodField(f, startDateVal, endDateVal, usedInputs)
          if (!ok) {
            f.fillValue = startDateVal
            await detectPickerField(f, lang)
            ok = await fillMatchedField(f)
          }
          if (ok) { result.success++ } else { result.failed++ }
        } else if (isTimeSingleField(f.key)) {
          if (!f.fillValue) { phaseAFields.push({ labelText: f.labelText, inputElement: f.inputElement, filled: false, fillValue: "", section: f.section, segmentIndex: segIdx }); result.skipped++; continue }
          let ok = await fillTimeSingleField(f, f.fillValue, usedInputs)
          if (!ok) {
            await detectPickerField(f, lang)
            ok = await fillMatchedField(f)
          }
          if (ok) { result.success++ } else { result.failed++ }
        } else if (!f.fillValue) {
          phaseAFields.push({ labelText: f.labelText, inputElement: f.inputElement, filled: false, fillValue: "", section: f.section, segmentIndex: segIdx }); result.skipped++; continue
        } else if (isSearchPickerField(f.key)) {
          const ok = await fillSearchPickerField(f)
          if (ok) { result.success++ } else { result.failed++ }
          phaseAFields.push({ labelText: f.labelText, inputElement: f.inputElement, filled: ok, fillValue: f.fillValue, section: f.section, segmentIndex: segIdx })
          await delay("mid")
          continue
        } else {
          await detectPickerField(f, lang)
          const ok = await fillMatchedField(f)
          if (ok) { result.success++ } else { result.failed++ }
        }

        // 收集阶段A已处理字段（用于末尾統計）
        phaseAFields.push({ labelText: f.labelText, inputElement: f.inputElement, filled: !!f.fillValue, fillValue: f.fillValue, section: f.section, segmentIndex: segIdx })

        // 关闭残留弹窗
        if (lastTextInput && !lastTextInputIsPicker) {
          ;(lastTextInput as HTMLElement).click()
          lastTextInput.focus()
          await delay("low")
          lastTextInput.blur()
        } else {
          if (document.activeElement instanceof HTMLElement) {
            document.activeElement.dispatchEvent(
              new KeyboardEvent("keydown", { key: "Escape", code: "Escape", keyCode: 27, bubbles: true })
            )
            document.activeElement.blur()
          }
          document.body.click()
        }
        await delay("mid")

        if (!f.isPicker && f.inputElement && !isTimePeriodField(f.key) && !isTimeSingleField(f.key)) {
          lastTextInput = f.inputElement
          lastTextInputIsPicker = false
        } else {
          lastTextInputIsPicker = true
        }
      }
    }
  }
  console.log(`===== OfferPie: 阶段A完成 成功${result.success} 失败${result.failed} 跳过${result.skipped} =====`)

  } // end of else (skipPhaseA)

  // 6. 非经历区域字段匹配与填写（阶段B）
  console.log("===== OfferPie: 阶段B - 非经历区域填写 =====")
  const mainFields = matchMainFields(document.body, lang, excludeRanges, usedInputs)
  console.log(`  匹配到 ${mainFields.length} 个非经历字段`)

  for (const f of mainFields) {
    const value = getResumeFieldValue(currentResumeData, f.section, f.sectionIndex, f.resumeField)
    if (value) f.fillValue = value

    // 检测该字段是否已被网站自动填入值
    if (f.inputElement && f.inputElement.value && f.inputElement.value.trim().length > 0) {
      console.log(`  [${f.key}] "${f.labelText}" 已有值="${f.inputElement.value.trim()}"，跳过`)
      result.skipped++
      continue
    }

    if (!f.fillValue) { result.skipped++; continue }

    await detectPickerField(f, lang)

    console.log(
      `  [${f.key}] "${f.labelText}" → type: ${f.inputType}` +
      ` | isPicker: ${f.isPicker}` +
      ` | fillValue: "${f.fillValue}"`
    )

    const ok = await fillMatchedField(f)
    if (ok) { result.success++ } else { result.failed++ }

    if (lastTextInput) {
      ;(lastTextInput as HTMLElement).click()
      lastTextInput.focus()
      await delay("low")
      lastTextInput.blur()
    } else {
      if (document.activeElement instanceof HTMLElement) {
        document.activeElement.dispatchEvent(
          new KeyboardEvent("keydown", { key: "Escape", code: "Escape", keyCode: 27, bubbles: true })
        )
        document.activeElement.blur()
      }
      document.body.click()
    }
    await delay("mid")

    if (!f.isPicker && f.inputElement) lastTextInput = f.inputElement
  }

  result.formFields = [...mainFields]
  console.log(`===== OfferPie: 阶段B完成 总计成功${result.success} 失败${result.failed} 跳过${result.skipped} =====`)

  // 6.5 阶段B2 - 从缓存填写之前保存的 unfilledFormData 有值字段
  // 【独立步骤】注释下面这段即可禁用阶段B2
  {
    const resumeName = currentResumeData?.main?.resumeName || currentResumeData?.main?.name || ""
    // 构建阶段B中简历无值未填写的非经历字段映射（标签文字→input元素），传给B2作为 fallback 定位
    const unfilledMainFieldMap = new Map<string, HTMLInputElement | HTMLTextAreaElement>()
    for (const f of mainFields) {
      if (!f.fillValue && f.inputElement && !usedInputs.has(f.inputElement)) {
        unfilledMainFieldMap.set(f.labelText, f.inputElement)
      }
    }
    const b2Result = await handleFillCachedData({
      lang, resumeName, usedInputs, expandedResults, sectionResults, unfilledMainFieldMap,
    })
    result.success += b2Result.success
    result.failed += b2Result.failed
    result.skipped += b2Result.skipped
  }

  // 7. 阶段C - 收集剩余空白输入框
  console.log("===== OfferPie: 阶段C - 收集剩余空白字段 =====")

  // 需要过滤的标签文字（这些不是有效标签）
  const EXCLUDE_LABEL_TEXTS = ["请输入", "输入", ":", "：", "请选择", "选择", "*", "必填"]

  // 收集非经历区域内所有空白输入框
  const allInputsOnPage = document.body.querySelectorAll(
    "input:not([type='hidden']):not([type='submit']):not([type='button']):not([type='checkbox']):not([type='radio']):not([type='file']):not([disabled]), textarea:not([disabled])"
  )

  for (const inp of Array.from(allInputsOnPage)) {
    const inputEl = inp as HTMLInputElement | HTMLTextAreaElement
    if (usedInputs.has(inp)) continue
    if (inputEl.value && inputEl.value.trim().length > 0) continue
    // 跳过在经历区域范围内的 input
    let inExcludeRange = false
    for (const range of excludeRanges) {
      const afterStart = range.start === inp || (range.start.compareDocumentPosition(inp) & Node.DOCUMENT_POSITION_FOLLOWING)
      const beforeEnd = !range.end || (range.end.compareDocumentPosition(inp) & Node.DOCUMENT_POSITION_PRECEDING)
      if (afterStart && beforeEnd) { inExcludeRange = true; break }
    }
    if (inExcludeRange) continue

    // 向上查找最近的标签文字
    let labelText = ""
    let labelElement: Element | null = null

    // 策略1：查找 input 所在表单项容器内的标签
    const formItemSelectors = [
      ".form-item", ".form-group", ".form-field",
      ".el-form-item", ".ant-form-item", ".ant-row",
      ".arco-form-item", ".t-form-item", ".n-form-item",
      "[class*='form-item']", "[class*='form-group']", "[class*='formItem']",
    ]
    let container: Element | null = null
    for (const sel of formItemSelectors) {
      container = inp.closest(sel)
      if (container) break
    }
    if (container) {
      const labelEls = container.querySelectorAll("label, span, div, td, th, p, legend, dt")
      for (const el of Array.from(labelEls)) {
        const directText = Array.from(el.childNodes)
          .filter((n) => n.nodeType === Node.TEXT_NODE)
          .map((n) => n.textContent?.trim())
          .filter(Boolean)
          .join("")
        if (!directText || directText.length > 30) continue
        if (EXCLUDE_LABEL_TEXTS.some((ex) => directText === ex)) continue
        if (el.compareDocumentPosition(inp) & Node.DOCUMENT_POSITION_FOLLOWING) {
          labelText = directText
          labelElement = el
          break
        }
      }
    }

    // 策略2：向前查找兄弟/父级中的标签
    if (!labelText) {
      let prev: Element | null = inp.previousElementSibling
      for (let i = 0; i < 3 && prev; i++) {
        const text = prev.textContent?.trim() || ""
        if (text && text.length <= 20 && !EXCLUDE_LABEL_TEXTS.some((ex) => text === ex)) {
          labelText = text
          labelElement = prev
          break
        }
        prev = prev.previousElementSibling
      }
    }

    if (!labelText || !labelElement) continue

    // 确定表单类型
    let formType: UnmatchedFormField["formType"] = "input"
    if (inputEl.tagName === "TEXTAREA") {
      formType = "textarea"
    } else if (inputEl.hasAttribute("readonly") || inputEl.closest("[class*='select']") || inputEl.closest("[class*='picker']")) {
      formType = "select"
    }

    result.unmatchedFields.push({
      labelText,
      labelElement,
      inputElement: inputEl,
      radioContainer: null,
      formType,
      isPicker: formType === "select",
      fillValue: "",
      alreadyFilled: false,
    })
    usedInputs.add(inp)
  }

  console.log(`  收集到 ${result.unmatchedFields.length} 个待填写的空白字段`)
  for (const uf of result.unmatchedFields) {
    console.log(`  [待填写] "${uf.labelText}" | formType: ${uf.formType} | isPicker: ${uf.isPicker}`)
  }
  console.log(`===== OfferPie: 阶段C完成 收集到 ${result.unmatchedFields.length} 个空白字段 =====`)

  // 8. 【标红/标黄】+ 9.【统计打印】
  // 全面扫描页面所有大标题范围内的输入框，对未被阶段A/B/C处理的字段也纳入统计和高亮
  // 经历类型区块按段分组，标记段落索引
  {
    // 先对阶段C已收集的字段标红/标黄
    for (const uf of result.unmatchedFields) {
      const required = isRequiredField(uf.labelElement, uf.inputElement)
      if (required) {
        setFieldHighlight(uf.inputElement, "red")
      } else {
        setFieldHighlight(uf.inputElement, "yellow")
      }
    }

    const allTitles = getAllPageTitles(sectionResults)
    if (allTitles.length > 0) {
      console.log("===== OfferPie: 填写结果统计（按大标题分组） =====")

      const processedInputs = new Set<Element>()

      type FieldStat = {
        labelText: string
        inputElement: Element | null
        color: "green" | "red" | "yellow"
        filled: boolean
        source: "A" | "B" | "C" | "D"
        segmentIndex: number
      }

      // 阶段A字段（带段落索引）
      const allFieldStats: FieldStat[] = []
      for (const f of phaseAFields) {
        allFieldStats.push({ labelText: f.labelText, inputElement: f.inputElement, color: "green", filled: f.filled, source: "A", segmentIndex: f.segmentIndex })
        if (f.inputElement) processedInputs.add(f.inputElement)
      }
      // 阶段B字段（只有简历数据非空的才标绿，否则走红/黄判断）
      for (const f of mainFields) {
        const hasResumeValue = !!f.fillValue
        const filled = !!(f.fillValue && f.inputElement?.value)
        if (hasResumeValue) {
          allFieldStats.push({ labelText: f.labelText, inputElement: f.inputElement, color: "green", filled, source: "B", segmentIndex: 0 })
        } else {
          // 简历数据为空的字段，走必填检测标红/标黄，并补上背景色
          const required = isRequiredField(f.labelElement, f.inputElement)
          const color = required ? "red" : "yellow"
          setFieldHighlight(f.inputElement, color)
          allFieldStats.push({ labelText: f.labelText, inputElement: f.inputElement, color, filled: false, source: "B", segmentIndex: 0 })
        }
        if (f.inputElement) processedInputs.add(f.inputElement)
      }
      // 阶段C字段
      for (const uf of result.unmatchedFields) {
        const required = isRequiredField(uf.labelElement, uf.inputElement)
        allFieldStats.push({ labelText: uf.labelText, inputElement: uf.inputElement, color: required ? "red" : "yellow", filled: false, source: "C", segmentIndex: 0 })
        if (uf.inputElement) processedInputs.add(uf.inputElement)
      }

      // 常量
      const STAT_EXCLUDE_LABEL_TEXTS = ["请输入", "输入", ":", "：", "请选择", "选择", "*", "必填"]
      const INPUT_SEL_STAT = "input:not([type='hidden']):not([type='submit']):not([type='button']):not([type='checkbox']):not([type='radio']):not([type='file']):not([disabled]), textarea:not([disabled])"
      const FORM_ITEM_SELS = [
        ".form-item", ".form-group", ".form-field",
        ".el-form-item", ".ant-form-item", ".ant-row",
        ".arco-form-item", ".t-form-item", ".n-form-item",
        "[class*='form-item']", "[class*='form-group']", "[class*='formItem']",
      ]

      /** 5大经历类型的 section 名集合（用于判断是否能从 expandedResults 取段落信息） */
      const FIVE_EXP_SECTIONS = new Set(["education", "work", "internship", "project", "competition"])

      /**
       * 对非5大经历的其他经历类型区块，通过标签重复次数检测段数
       * 思路：一段经历里标签是一组固定模式（如名称+开始时间+结束时间+描述），
       * 统计范围内每个标签文字出现的次数，出现次数的最大公约数就是段数
       * 用重复次数最多的标签文字作为分段标记，按 DOM 顺序划分段落
       */
      function detectSegmentsForOtherExp(
        titleEl: Element,
        nextTitleEl: Element | null,
        fieldsInRange: FieldStat[]
      ): { segmentCount: number; fieldSegMap: Map<Element, number> } {
        // 统计每个标签文字出现的次数
        const labelCounts = new Map<string, number>()
        const labelElements = new Map<string, Element[]>() // 每个标签文字对应的所有 inputElement（按 DOM 顺序）

        for (const f of fieldsInRange) {
          if (!f.inputElement) continue
          const count = labelCounts.get(f.labelText) || 0
          labelCounts.set(f.labelText, count + 1)
          const arr = labelElements.get(f.labelText) || []
          arr.push(f.inputElement)
          labelElements.set(f.labelText, arr)
        }

        // 找出出现次数最多的标签 → 作为段数依据
        let maxCount = 1
        let markerLabel = ""
        for (const [label, count] of labelCounts) {
          if (count > maxCount) {
            maxCount = count
            markerLabel = label
          }
        }

        if (maxCount <= 1) {
          // 所有标签只出现1次 → 只有1段经历
          const fieldSegMap = new Map<Element, number>()
          for (const f of fieldsInRange) {
            if (f.inputElement) fieldSegMap.set(f.inputElement, 0)
          }
          return { segmentCount: 1, fieldSegMap }
        }

        // 用 markerLabel 的出现位置来划分段落边界
        const markerInputs = labelElements.get(markerLabel) || []
        // markerInputs 按 DOM 顺序排列，每个 markerInput 标记一段经历的开始
        const fieldSegMap = new Map<Element, number>()

        for (const f of fieldsInRange) {
          if (!f.inputElement) continue
          // 找到离这个 input 最近的前一个 marker（或和它属于同一段）
          let segIdx = 0
          for (let i = markerInputs.length - 1; i >= 0; i--) {
            const markerPos = markerInputs[i].compareDocumentPosition(f.inputElement)
            // f.inputElement 在 markerInputs[i] 之后或就是它本身
            if ((markerPos & Node.DOCUMENT_POSITION_FOLLOWING) || markerInputs[i] === f.inputElement) {
              segIdx = i
              break
            }
          }
          fieldSegMap.set(f.inputElement, segIdx)
        }

        return { segmentCount: maxCount, fieldSegMap }
      }

      /**
       * 查找标签文字的辅助函数
       */
      function findLabelForInput(inp: Element): { labelText: string; labelElement: Element | null } {
        let labelText = ""
        let labelElement: Element | null = null
        let container: Element | null = null
        for (const sel of FORM_ITEM_SELS) {
          container = inp.closest(sel)
          if (container) break
        }
        if (container) {
          const labelEls = container.querySelectorAll("label, span, div, td, th, p, legend, dt")
          for (const el of Array.from(labelEls)) {
            const directText = Array.from(el.childNodes)
              .filter((n) => n.nodeType === Node.TEXT_NODE)
              .map((n) => n.textContent?.trim())
              .filter(Boolean)
              .join("")
            if (!directText || directText.length > 30) continue
            if (STAT_EXCLUDE_LABEL_TEXTS.some((ex) => directText === ex)) continue
            if (el.compareDocumentPosition(inp) & Node.DOCUMENT_POSITION_FOLLOWING) {
              labelText = directText
              labelElement = el
              break
            }
          }
        }
        if (!labelText) {
          let prev: Element | null = inp.previousElementSibling
          for (let i = 0; i < 3 && prev; i++) {
            const text = prev.textContent?.trim() || ""
            if (text && text.length <= 20 && !STAT_EXCLUDE_LABEL_TEXTS.some((ex) => text === ex)) {
              labelText = text
              labelElement = prev
              break
            }
            prev = prev.previousElementSibling
          }
        }
        if (!labelText) labelText = (inp as HTMLInputElement).getAttribute("placeholder") || "(未知字段)"
        return { labelText, labelElement }
      }

      // 按大标题分组统计
      for (let tIdx = 0; tIdx < allTitles.length; tIdx++) {
        const titleEl = allTitles[tIdx].element
        const titleText = allTitles[tIdx].text
        const nextTitleEl = tIdx < allTitles.length - 1 ? allTitles[tIdx + 1].element : null

        // 判断是否为5大经历区块（直接从 expandedResults 取段落信息）
        const expResult = expandedResults.find((r) => r.titleElement === titleEl)
        const isFiveExp = !!expResult && FIVE_EXP_SECTIONS.has(expResult.section)

        // 找出已处理字段中属于此标题范围内的
        const fieldsInSection: FieldStat[] = allFieldStats.filter((f) => {
          if (!f.inputElement) return false
          const afterTitle = titleEl === f.inputElement || !!(titleEl.compareDocumentPosition(f.inputElement) & Node.DOCUMENT_POSITION_FOLLOWING)
          const beforeNext = !nextTitleEl || !!(nextTitleEl.compareDocumentPosition(f.inputElement) & Node.DOCUMENT_POSITION_PRECEDING)
          return afterTitle && beforeNext
        })

        // 【补扫】在此标题范围内查找未被任何阶段处理的 input
        const allInputsInRange = document.body.querySelectorAll(INPUT_SEL_STAT)
        for (const inp of Array.from(allInputsInRange)) {
          if (processedInputs.has(inp)) continue
          const afterTitle = titleEl === inp || !!(titleEl.compareDocumentPosition(inp) & Node.DOCUMENT_POSITION_FOLLOWING)
          const beforeNext = !nextTitleEl || !!(nextTitleEl.compareDocumentPosition(inp) & Node.DOCUMENT_POSITION_PRECEDING)
          if (!afterTitle || !beforeNext) continue

          const inputEl = inp as HTMLInputElement | HTMLTextAreaElement
          const alreadyHasValue = !!(inputEl.value && inputEl.value.trim().length > 0)
          const { labelText, labelElement } = findLabelForInput(inp)

          let color: "green" | "red" | "yellow"
          if (alreadyHasValue) {
            color = "green"
          } else {
            const required = isRequiredField(labelElement, inputEl)
            color = required ? "red" : "yellow"
            setFieldHighlight(inputEl, color)
          }

          fieldsInSection.push({ labelText, inputElement: inp, color, filled: alreadyHasValue, source: "D", segmentIndex: 0 })
          processedInputs.add(inp)
        }

        if (fieldsInSection.length === 0) {
          console.log(`  📂 "${titleText}" — 无匹配字段`)
          continue
        }

        // 确定经历类型和段数
        let isExpType = false
        let segmentCount = 0

        if (isFiveExp && expResult) {
          // 5大经历：直接用 expandedResults 的 segmentRanges
          isExpType = true
          segmentCount = expResult.segmentRanges.length
          // 更新阶段D补扫字段的 segmentIndex（用 containerElement.contains 判断归属）
          for (const f of fieldsInSection) {
            if (!f.inputElement) continue
            if (f.source === "D" || f.source === "C") {
              for (let sIdx = 0; sIdx < expResult.segmentRanges.length; sIdx++) {
                const seg = expResult.segmentRanges[sIdx]
                if (seg.containerElement && seg.containerElement.contains(f.inputElement)) {
                  f.segmentIndex = sIdx
                  break
                }
              }
            }
          }
        } else {
          // 非5大经历：先检测是否有"添加"按钮，有添加按钮才是经历类型
          const addBtnKeywords = ["添加", "新增", "Add", "增加"]
          const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_ELEMENT)
          let wNode: Node | null = walker.nextNode()
          let hasAddBtn = false
          while (wNode) {
            const el = wNode as Element
            const afterT = !!(titleEl.compareDocumentPosition(el) & Node.DOCUMENT_POSITION_FOLLOWING)
            const beforeN = !nextTitleEl || !!(nextTitleEl.compareDocumentPosition(el) & Node.DOCUMENT_POSITION_PRECEDING)
            if (afterT && beforeN) {
              const directText = Array.from(el.childNodes)
                .filter((n) => n.nodeType === Node.TEXT_NODE)
                .map((n) => n.textContent?.trim())
                .filter(Boolean)
                .join("")
              if (directText && directText.length < 20 && addBtnKeywords.some((k) => directText.includes(k))) {
                hasAddBtn = true
                break
              }
            }
            wNode = walker.nextNode()
          }

          if (hasAddBtn) {
            // 有添加按钮 → 是经历类型，通过标签重复次数确定段数
            isExpType = true
            const { segmentCount: detectedCount, fieldSegMap } = detectSegmentsForOtherExp(titleEl, nextTitleEl, fieldsInSection)
            segmentCount = detectedCount
            for (const f of fieldsInSection) {
              if (f.inputElement && fieldSegMap.has(f.inputElement)) {
                f.segmentIndex = fieldSegMap.get(f.inputElement)!
              }
            }
          }
          // 没有添加按钮 → 不是经历类型，isExpType 保持 false
        }

        const greenCount = fieldsInSection.filter((f) => f.color === "green").length
        const redCount = fieldsInSection.filter((f) => f.color === "red").length
        const yellowCount = fieldsInSection.filter((f) => f.color === "yellow").length
        const filledCount = fieldsInSection.filter((f) => f.filled).length

        const expLabel = isExpType ? ` | 📑经历类型（${segmentCount}段）` : ""
        console.log(`  📂 "${titleText}" — 总计 ${fieldsInSection.length} 个字段 | 已填 ${filledCount} | 🟢简历有数据 ${greenCount} | 🔴必填未填 ${redCount} | 🟡非必填未填 ${yellowCount}${expLabel}`)

        // 打印字段详情
        if (isExpType && segmentCount > 0) {
          for (let sIdx = 0; sIdx < segmentCount; sIdx++) {
            const segFields = fieldsInSection.filter((f) => f.segmentIndex === sIdx)
            if (segFields.length === 0) continue
            console.log(`    --- 第${sIdx + 1}段 ---`)
            for (const f of segFields) {
              const colorIcon = f.color === "green" ? "🟢" : f.color === "red" ? "🔴" : "🟡"
              const filledStr = f.filled ? "✅已填" : "⬜未填"
              const sourceLabel = f.source === "A" ? "经历填写" : f.source === "B" ? "基础信息填写" : f.source === "C" ? "空白字段收集" : "补扫发现"
              console.log(`      ${colorIcon} "${f.labelText}" | ${filledStr} | 来源: ${sourceLabel}`)
            }
          }
        } else {
          for (const f of fieldsInSection) {
            const colorIcon = f.color === "green" ? "🟢" : f.color === "red" ? "🔴" : "🟡"
            const filledStr = f.filled ? "✅已填" : "⬜未填"
            const sourceLabel = f.source === "A" ? "经历填写" : f.source === "B" ? "基础信息填写" : f.source === "C" ? "空白字段收集" : "补扫发现"
            console.log(`    ${colorIcon} "${f.labelText}" | ${filledStr} | 来源: ${sourceLabel}`)
          }
        }
      }

      console.log("===== OfferPie: 统计打印完毕 =====")
    }
  }

  // 10. 【生成未填字段 JSON】按大标题顺序，收集简历数据格式之外的未填字段
  // 排除阶段A/B（简历数据格式内的字段），只收集阶段C/D中未填写的字段
  {
    const allTitles = getAllPageTitles(sectionResults)
    const FIVE_EXP_SECTIONS_JSON = new Set(["education", "work", "internship", "project", "competition"])

    // 从简历数据中提取所有值，构建排除集合（避免将已填值误认为标签）
    const excludeTexts = new Set<string>()
    if (currentResumeData) {
      const main = currentResumeData.main
      if (main) {
        for (const val of Object.values(main)) {
          if (typeof val === "string" && val.trim()) excludeTexts.add(val.trim())
          if (Array.isArray(val)) val.forEach((v) => { if (typeof v === "string" && v.trim()) excludeTexts.add(v.trim()) })
        }
      }
      const expKeys: ("education" | "work" | "internship" | "project" | "competition")[] = ["education", "work", "internship", "project", "competition"]
      for (const sec of expKeys) {
        const items = currentResumeData[sec]
        if (!Array.isArray(items)) continue
        for (const item of items) {
          for (const val of Object.values(item as Record<string, any>)) {
            if (typeof val === "string" && val.trim()) excludeTexts.add(val.trim())
          }
        }
      }
    }

    /** 判断某个字段是否属于简历数据格式（JOB_FORM_LABELS 里 resumeField 非空的） */
    const resumeFormatInputs = new Set<Element>()
    // 阶段A和B的所有 input 都是简历格式字段
    for (const f of phaseAFields) { if (f.inputElement) resumeFormatInputs.add(f.inputElement) }
    for (const f of mainFields) { if (f.inputElement) resumeFormatInputs.add(f.inputElement) }

    type UnfilledSection = {
      title: string
      isExperience: boolean
      formItems: { label: string; value: string }[] | { label: string; value: string }[][]
    }

    const unfilledFormData: UnfilledSection[] = []

    if (allTitles.length > 0) {
      const INPUT_SEL_JSON = "input:not([type='hidden']):not([type='submit']):not([type='button']):not([type='checkbox']):not([type='radio']):not([type='file']):not([disabled]), textarea:not([disabled])"
      
      const JSON_EXCLUDE_LABELS = ["请输入", "输入", ":", "：", "请选择", "选择", "*", "必填"]

      for (let tIdx = 0; tIdx < allTitles.length; tIdx++) {
        const titleEl = allTitles[tIdx].element
        const titleText = allTitles[tIdx].text
        const nextTitleEl = tIdx < allTitles.length - 1 ? allTitles[tIdx + 1].element : null

        // 判断是否为经历类型（5大经历 或 有添加按钮的非5大经历）
        const expResult = expandedResults.find((r) => r.titleElement === titleEl)
        const isFiveExp = !!expResult && FIVE_EXP_SECTIONS_JSON.has(expResult.section)
        let isExpType = isFiveExp

        // 非5大经历检测添加按钮
        if (!isFiveExp) {
          const addBtnKeywords = ["添加", "新增", "Add", "增加"]
          const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_ELEMENT)
          let wNode: Node | null = walker.nextNode()
          while (wNode) {
            const el = wNode as Element
            const afterT = !!(titleEl.compareDocumentPosition(el) & Node.DOCUMENT_POSITION_FOLLOWING)
            const beforeN = !nextTitleEl || !!(nextTitleEl.compareDocumentPosition(el) & Node.DOCUMENT_POSITION_PRECEDING)
            if (afterT && beforeN) {
              const directText = Array.from(el.childNodes)
                .filter((n) => n.nodeType === Node.TEXT_NODE)
                .map((n) => n.textContent?.trim())
                .filter(Boolean)
                .join("")
              if (directText && directText.length < 20 && addBtnKeywords.some((k) => directText.includes(k))) {
                isExpType = true
                break
              }
            }
            wNode = walker.nextNode()
          }
        }

        // 收集范围内的 input
        const allInputs = document.body.querySelectorAll(INPUT_SEL_JSON)
        type FieldItem = { label: string; value: string; inputEl: Element }
        const collectedFields: FieldItem[] = []

        // 构建当前大标题范围内所有已填 input 的值集合
        // 用于排除误将已填值（如"香港理工大学"、"硕士"、"2026"等）当作标签的情况
        const filledInputValues = new Set<string>()
        for (const inp of Array.from(allInputs)) {
          const afterT = !!(titleEl.compareDocumentPosition(inp) & Node.DOCUMENT_POSITION_FOLLOWING)
          const beforeN = !nextTitleEl || !!(nextTitleEl.compareDocumentPosition(inp) & Node.DOCUMENT_POSITION_PRECEDING)
          if (!afterT || !beforeN) continue
          const val = (inp as HTMLInputElement | HTMLTextAreaElement).value?.trim()
          if (val) filledInputValues.add(val)
        }

        for (const inp of Array.from(allInputs)) {
          // 范围检查
          const afterTitle = !!(titleEl.compareDocumentPosition(inp) & Node.DOCUMENT_POSITION_FOLLOWING)
          const beforeNext = !nextTitleEl || !!(nextTitleEl.compareDocumentPosition(inp) & Node.DOCUMENT_POSITION_PRECEDING)
          if (!afterTitle || !beforeNext) continue

          const inputEl = inp as HTMLInputElement | HTMLTextAreaElement

          // 非经历类型：跳过阶段A/B已成功填充的字段（绿色背景标记）
          // greenTwo（#b7ffc6）是阶段B2填的unfilledFormData字段，不跳过，可以收集
          if (!isExpType) {
            if (resumeFormatInputs.has(inp)) continue
            const bgColor = inputEl.style.backgroundColor
            if (bgColor === "#b7ffc5" || bgColor === "rgb(183, 255, 197)") continue
          }

          // 查找标签（使用统一封装的 labelFinder）
          const titleElementSet = new Set<Element>(allTitles.map((t) => t.element))
          const { labelText: detectedLabel } = findLabelForInput(inp, titleElementSet, excludeTexts)
          const labelText = detectedLabel?.trim()

          // 跳过无效标签：空、纯数字、已知排除词、或检测到的"标签"实际是某个已填 input 的值
          if (!labelText || /^\d+$/.test(labelText) || JSON_EXCLUDE_LABELS.some((ex) => labelText === ex)) continue
          if (filledInputValues.has(labelText)) continue

          // 非经历类型：跳过简历格式字段
          // 【注意】简历格式字段通过 resumeFormatInputs（阶段A/B实际匹配到的input元素集合）精确跳过
          // 不用标签文字匹配跳过，因为同一标签名可能出现在不同大标题下（如"最高学历"在个人信息 vs 教育经历）
          // resumeFormatInputs 已在上方 if(!isExpType) 块中判断，此处无需重复

          collectedFields.push({ label: labelText, value: inputEl.value?.trim() || "", inputEl: inp })
        }

        if (collectedFields.length === 0) continue

        // 按经历类型分组
        if (isExpType) {
          let segmentCount = 1

          if (isFiveExp && expResult) {
            // 5大经历用 containerElement 分段
            segmentCount = expResult.segmentRanges.length || 1
            const segments: { label: string; value: string }[][] = []
            for (let sIdx = 0; sIdx < segmentCount; sIdx++) {
              const seg = expResult.segmentRanges[sIdx]
              const segFields = seg?.containerElement
                ? collectedFields.filter((f) => seg.containerElement!.contains(f.inputEl))
                : collectedFields
              segments.push(segFields.map((f) => ({ label: f.label, value: f.value })))
            }
            const nonEmptySegments = segments.filter((s) => s.length > 0)
            if (nonEmptySegments.length > 0) {
              unfilledFormData.push({ title: titleText, isExperience: true, formItems: nonEmptySegments })
            }
          } else {
            // 非5大经历用标签重复计数分段
            const labelCounts = new Map<string, number>()
            for (const f of collectedFields) {
              labelCounts.set(f.label, (labelCounts.get(f.label) || 0) + 1)
            }
            let maxCount = 1
            let markerLabel = ""
            for (const [label, count] of labelCounts) {
              if (count > maxCount) { maxCount = count; markerLabel = label }
            }
            segmentCount = maxCount

            if (segmentCount <= 1) {
              unfilledFormData.push({ title: titleText, isExperience: true, formItems: [collectedFields.map((f) => ({ label: f.label, value: f.value }))] })
            } else {
              const markerPositions = collectedFields
                .map((f, idx) => f.label === markerLabel ? idx : -1)
                .filter((idx) => idx >= 0)
              const segments: { label: string; value: string }[][] = []
              for (let i = 0; i < markerPositions.length; i++) {
                const start = markerPositions[i]
                const end = i < markerPositions.length - 1 ? markerPositions[i + 1] : collectedFields.length
                segments.push(collectedFields.slice(start, end).map((f) => ({ label: f.label, value: f.value })))
              }
              unfilledFormData.push({ title: titleText, isExperience: true, formItems: segments })
            }
          }
        } else {
          // 非经历类型：只存未填字段
          unfilledFormData.push({
            title: titleText,
            isExperience: false,
            formItems: collectedFields.map((f) => ({ label: f.label, value: f.value })),
          })
        }
      }
    }

    console.log("===== OfferPie: 网站未填表单字段数据（JSON） =====")
    // console.log(JSON.stringify(unfilledFormData, null, 2))
    console.log("===== OfferPie: JSON 输出完毕 =====")

    // 存 chrome.storage 缓存，包含简历名字和未填字段数据（跨域名共享，按简历名区分）
    const resumeName = currentResumeData?.main?.resumeName || currentResumeData?.main?.name || ""
    try {
      const existing = await storageGet<any>("offerpie_unfilled_form")
      let cacheData: any = null

      if (existing && existing.resumeName === resumeName && existing.unfilledFormData) {
        // 同一份简历，按字段级合并（非空值才更新，保留旧缓存中已有的非空值不被覆盖）
        const oldSections = existing.unfilledFormData as any[]
        const newSections = unfilledFormData as any[]

        for (const newSec of newSections) {
          const oldSecIdx = oldSections.findIndex((s: any) => s.title === newSec.title)
          if (oldSecIdx < 0) {
            oldSections.push(newSec)
          } else {
            const oldSec = oldSections[oldSecIdx]
            if (newSec.isExperience && oldSec.isExperience) {
              // 经历类型：按段合并，保留旧字段
              const oldSegments = oldSec.formItems as any[][]
              const newSegments = newSec.formItems as any[][]
              for (let sIdx = 0; sIdx < newSegments.length; sIdx++) {
                if (sIdx >= oldSegments.length) {
                  oldSegments.push(newSegments[sIdx])
                } else {
                  const oldFields = oldSegments[sIdx]
                  const newFields = newSegments[sIdx]
                  for (const nf of newFields) {
                    const of_ = oldFields.find((f: any) => f.label === nf.label)
                    if (of_) {
                      if (nf.value) of_.value = nf.value
                    } else {
                      oldFields.push(nf)
                    }
                  }
                }
              }
            } else if (!newSec.isExperience && !oldSec.isExperience) {
              // 非经历类型：按字段合并，只有非空值才更新，旧值不丢失
              const oldFields = oldSec.formItems as any[]
              const newFields = newSec.formItems as any[]
              for (const nf of newFields) {
                const of_ = oldFields.find((f: any) => f.label === nf.label)
                if (of_) {
                  if (nf.value) of_.value = nf.value
                } else {
                  oldFields.push(nf)
                }
              }
            } else {
              // 类型变化（经历↔非经历），直接替换
              oldSections[oldSecIdx] = newSec
            }
          }
        }

        existing.unfilledFormData = oldSections
        existing.timestamp = Date.now()
        cacheData = existing
      }

      // 没有已有缓存或不是同一份简历 → 新建
      if (!cacheData) {
        cacheData = {
          resumeName,
          unfilledFormData,
          timestamp: Date.now(),
        }
      }

      await storageSet("offerpie_unfilled_form", cacheData)
      console.log(`===== OfferPie: 已缓存未填字段数据（简历: "${resumeName}"） =====`)
    } catch (e) {
      console.warn("OfferPie: chrome.storage 缓存失败", e)
    }
  }

  return result
}


// ============================================================
// 阶段B2：从 localStorage 缓存填写 unfilledFormData 有值字段
// 【独立模块】可以通过注释 handleAutoFillFeishu 中的调用行来禁用
// ============================================================



/** 阶段B2 input 选择器 */
const B2_INPUT_SEL = "input:not([type='hidden']):not([type='submit']):not([type='button']):not([type='checkbox']):not([type='radio']):not([type='file']):not([disabled]), textarea:not([disabled])"

/** 阶段B2 排除的标签文字 */
const B2_EXCLUDE_LABELS = ["请输入", "输入", ":", "：", "请选择", "选择", "*", "必填"]

/** 阶段B2 5大简历经历的 section 名集合 */
const B2_FIVE_EXP_SECTIONS = new Set<string>(["education", "work", "internship", "project", "competition"])

/** 阶段B2 参数 */
interface FillCachedDataParams {
  lang: "zh" | "en"
  resumeName: string
  usedInputs: Set<Element>
  expandedResults: ExperienceSectionLocateResult[]
  sectionResults: ExperienceSectionLocateResult[]
  /** 阶段B中简历无值未填写的非经历字段（标签→input映射），B2用缓存值填写这些字段 */
  unfilledMainFieldMap?: Map<string, HTMLInputElement | HTMLTextAreaElement>
}

/** 阶段B2 结果 */
interface FillCachedDataResult {
  success: number
  failed: number
  skipped: number
}

/**
 * 阶段B2：在指定大标题范围内，通过标签文字查找对应的 input 元素
 * 使用 findLabelForInput 统一标签定位（和缓存收集时一致），不依赖容器类名
 */
function b2FindInputByLabel(
  labelText: string,
  titleEl: Element,
  nextTitleEl: Element | null,
  usedInputs: Set<Element>
): HTMLInputElement | HTMLTextAreaElement | null {
  const allInputs = document.body.querySelectorAll(B2_INPUT_SEL)
  for (const inp of Array.from(allInputs)) {
    if (usedInputs.has(inp)) continue
    const afterTitle = !!(titleEl.compareDocumentPosition(inp) & Node.DOCUMENT_POSITION_FOLLOWING)
    const beforeNext = !nextTitleEl || !!(nextTitleEl.compareDocumentPosition(inp) & Node.DOCUMENT_POSITION_PRECEDING)
    if (!afterTitle || !beforeNext) continue

    // 用 findLabelForInput 获取该 input 对应的标签文字，和缓存收集时逻辑一致
    const { labelText: detectedLabel } = findLabelForInput(inp)
    if (detectedLabel && detectedLabel.trim() === labelText) {
      return inp as HTMLInputElement | HTMLTextAreaElement
    }
  }
  return null
}

/**
 * 阶段B2：在指定容器内，通过标签文字查找对应的 input 元素
 * 使用 findLabelForInput 统一标签定位（和缓存收集时一致），不依赖容器类名
 */
function b2FindInputByLabelInContainer(
  labelText: string,
  containerEl: Element,
  usedInputs: Set<Element>
): HTMLInputElement | HTMLTextAreaElement | null {
  const allInputs = containerEl.querySelectorAll(B2_INPUT_SEL)
  for (const inp of Array.from(allInputs)) {
    if (usedInputs.has(inp)) continue
    // 用 findLabelForInput 获取该 input 对应的标签文字，和缓存收集时逻辑一致
    const { labelText: detectedLabel } = findLabelForInput(inp)
    if (detectedLabel && detectedLabel.trim() === labelText) {
      return inp as HTMLInputElement | HTMLTextAreaElement
    }
  }
  return null
}

/**
 * 阶段B2：构造 MatchedFormField 并填写单个字段
 * 【规范】走 detectPickerField + fillMatchedField 统一入口
 */
async function b2FillSingleField(
  inputEl: HTMLInputElement | HTMLTextAreaElement,
  labelText: string,
  fillValue: string,
  lang: "zh" | "en"
): Promise<boolean> {
  if (inputEl.value && inputEl.value.trim().length > 0) return false

  const field: MatchedFormField = {
    key: "", section: "main", resumeField: "",
    sectionIndex: 0, labelText,
    labelElement: inputEl.previousElementSibling || inputEl.parentElement || inputEl,
    labelSelector: "",
    inputElement: inputEl,
    inputSelector: buildSelector(inputEl),
    buttonElement: null, buttonSelector: "",
    inputType: inputEl.tagName === "TEXTAREA" ? "textarea" : "text",
    radioContainer: null,
    isPicker: false,
    pickerDropdownElement: null, pickerDropdownSelector: "",
    fillValue,
  }

  await detectPickerField(field, lang)
  return await fillMatchedField(field)
}

/** 时间/日期相关的标签关键字 */
const B2_DATE_TIME_KEYWORDS = ["时间", "日期", "日期时间", "开始", "结束", "起始", "截止", "入职", "离职", "毕业"]

/**
 * 判断标签名是否为时间/日期类字段
 * 标签文字中包含时间/日期相关关键字即认为是时间字段
 */
function b2IsDateTimeLabel(label: string): boolean {
  return B2_DATE_TIME_KEYWORDS.some((kw) => label.includes(kw))
}

/**
 * 阶段B2：填写时间/日期字段
 * 走和阶段A同款的流程：直接点击 input → fillDatePicker
 * 不经过 detectPickerField（避免方式3主动点击导致 toggle 问题）
 * 不经过 fillPickerField（避免步骤1-2再次点击关闭弹出层）
 *
 * 引用方式和阶段A的 fillTimePeriodField 情况A2 一致：
 *   input.focus() → input.click() → delay → fillDatePicker(field)
 */
async function b2FillDateTimeField(
  inputEl: HTMLInputElement | HTMLTextAreaElement,
  labelText: string,
  fillValue: string
): Promise<boolean> {
  // 构造 MatchedFormField（和阶段A一样，isPicker=true，不设 pickerDropdownElement）
  const field: MatchedFormField = {
    key: "", section: "main", resumeField: "",
    sectionIndex: 0, labelText,
    labelElement: inputEl.previousElementSibling || inputEl.parentElement || inputEl,
    labelSelector: "",
    inputElement: inputEl,
    inputSelector: buildSelector(inputEl),
    buttonElement: null, buttonSelector: "",
    inputType: "text",
    radioContainer: null,
    isPicker: true,
    pickerDropdownElement: null, pickerDropdownSelector: "",
    fillValue,
  }

  // 和阶段A同样的方式：点击 input 展开日期面板，然后直接调 fillDatePicker
  inputEl.focus()
  ;(inputEl as HTMLElement).click()
  await delay("mid")

  const ok = await fillDatePicker(field)
  if (ok) {
    console.log(`OfferPie: ✅ [B2-时间字段] "${labelText}" = "${fillValue}" 填写成功`)
  } else {
    console.log(`OfferPie: ❌ [B2-时间字段] "${labelText}" = "${fillValue}" 填写失败`)
  }
  return ok
}

/**
 * 阶段B2 主流程：从缓存读取 unfilledFormData，填写有值的字段
 */
async function handleFillCachedData(params: FillCachedDataParams): Promise<FillCachedDataResult> {
  const { lang, resumeName, usedInputs, expandedResults, sectionResults, unfilledMainFieldMap } = params
  const result: FillCachedDataResult = { success: 0, failed: 0, skipped: 0 }

  const cacheData = await storageGet<any>("offerpie_unfilled_form")
  if (!cacheData) {
    console.log("===== OfferPie: 阶段B2 - 无缓存数据，跳过 =====")
    return result
  }

  if (cacheData.resumeName !== resumeName) {
    console.log(`===== OfferPie: 阶段B2 - 缓存简历名"${cacheData.resumeName}"与当前"${resumeName}"不匹配，跳过 =====`)
    return result
  }

  const unfilledFormData = cacheData.unfilledFormData as {
    title: string
    isExperience: boolean
    formItems: { label: string; value: string }[] | { label: string; value: string }[][]
  }[]

  if (!unfilledFormData || unfilledFormData.length === 0) {
    console.log("===== OfferPie: 阶段B2 - 缓存中无字段数据，跳过 =====")
    return result
  }

  console.log("===== OfferPie: 阶段B2 - 填写缓存数据 =====")

  const allTitles = getAllPageTitles(sectionResults)
  if (allTitles.length === 0) {
    console.log("  ❌ 未找到页面大标题，跳过")
    return result
  }

  for (const sectionData of unfilledFormData) {
    const titleInfo = allTitles.find((t) => t.text === sectionData.title)
    if (!titleInfo) {
      console.log(`  [B2] "${sectionData.title}" 未在页面找到对应大标题，跳过`)
      continue
    }
    const titleEl = titleInfo.element
    const titleIdx = allTitles.indexOf(titleInfo)
    const nextTitleEl = titleIdx < allTitles.length - 1 ? allTitles[titleIdx + 1].element : null

    const expResult = expandedResults.find((r) => r.titleElement === titleEl)
    const isFiveExp = !!expResult && B2_FIVE_EXP_SECTIONS.has(expResult.section)

    if (sectionData.isExperience) {
      const segments = sectionData.formItems as { label: string; value: string }[][]

      if (isFiveExp && expResult) {
        console.log(`  [B2] "${sectionData.title}" (5大经历) 缓存${segments.length}段`)
        for (let sIdx = 0; sIdx < segments.length; sIdx++) {
          const seg = expResult.segmentRanges[sIdx]
          if (!seg || !seg.containerElement) continue
          const fields = segments[sIdx]
          for (const field of fields) {
            if (!field.value) { result.skipped++; continue }
            const inputEl = b2FindInputByLabelInContainer(field.label, seg.containerElement, usedInputs)
            if (!inputEl) { result.skipped++; continue }
            // 时间/日期字段走阶段A同款流程：直接点击 input → fillDatePicker，不经过 detectPickerField
            if (b2IsDateTimeLabel(field.label)) {
              const ok = await b2FillDateTimeField(inputEl, field.label, field.value)
              if (ok) { result.success++; usedInputs.add(inputEl); setFieldHighlight(inputEl, "greenTwo") } else { result.failed++ }
            } else {
              const ok = await b2FillSingleField(inputEl, field.label, field.value, lang)
              if (ok) { result.success++; usedInputs.add(inputEl); setFieldHighlight(inputEl, "greenTwo") } else { result.failed++ }
            }
            await delay("mid")
          }
        }
      } else {
        console.log(`  [B2] "${sectionData.title}" (其他经历) 缓存${segments.length}段`)

        // 检测当前页面已有几段（通过统计同名标签出现次数判断段数）
        const allInputsInRange = document.body.querySelectorAll(B2_INPUT_SEL)
        const labelsInRange: string[] = []
        for (const inp of Array.from(allInputsInRange)) {
          const afterTitle = !!(titleEl.compareDocumentPosition(inp) & Node.DOCUMENT_POSITION_FOLLOWING)
          const beforeNext = !nextTitleEl || !!(nextTitleEl.compareDocumentPosition(inp) & Node.DOCUMENT_POSITION_PRECEDING)
          if (!afterTitle || !beforeNext) continue
          // 用 findLabelForInput 获取标签文字，和缓存收集时逻辑一致
          const { labelText: detectedLabel } = findLabelForInput(inp)
          if (detectedLabel && detectedLabel.trim() && !B2_EXCLUDE_LABELS.some((ex) => detectedLabel.trim() === ex)) {
            labelsInRange.push(detectedLabel.trim())
          }
        }
        const labelCounts = new Map<string, number>()
        for (const l of labelsInRange) labelCounts.set(l, (labelCounts.get(l) || 0) + 1)
        let currentSegCount = 1
        for (const count of labelCounts.values()) { if (count > currentSegCount) currentSegCount = count }

        const needAdd = segments.length - currentSegCount
        if (needAdd > 0) {
          const tempConfig = {
            section: "project" as ExperienceSection,
            zh: [sectionData.title],
            en: [sectionData.title],
            coreFieldKey: "",
            addButtonZh: ["添加", "新增", "增加"],
            addButtonEn: ["Add", "New"],
          }
          for (let i = 0; i < needAdd; i++) {
            const addBtn = findAddButton(titleEl, nextTitleEl, tempConfig, lang)
            if (!addBtn) { console.log(`  [B2] "${sectionData.title}" 未找到添加按钮`); break }
            const beforeCount = Array.from(document.body.querySelectorAll(B2_INPUT_SEL)).filter((inp) => {
              const after = !!(titleEl.compareDocumentPosition(inp) & Node.DOCUMENT_POSITION_FOLLOWING)
              const before = !nextTitleEl || !!(nextTitleEl.compareDocumentPosition(inp) & Node.DOCUMENT_POSITION_PRECEDING)
              return after && before
            }).length
            const clicked = await clickAddButton(addBtn, titleEl, nextTitleEl, beforeCount)
            if (!clicked) { console.log(`  [B2] "${sectionData.title}" 点击添加按钮无效`); break }
            await delay("mid")
          }
        }

        for (let sIdx = 0; sIdx < segments.length; sIdx++) {
          const fields = segments[sIdx]
          for (const field of fields) {
            if (!field.value) { result.skipped++; continue }
            const inputEl = b2FindInputByLabel(field.label, titleEl, nextTitleEl, usedInputs)
            if (!inputEl) { result.skipped++; continue }
            // 时间/日期字段走阶段A同款流程：直接点击 input → fillDatePicker，不经过 detectPickerField
            if (b2IsDateTimeLabel(field.label)) {
              const ok = await b2FillDateTimeField(inputEl, field.label, field.value)
              if (ok) { result.success++; usedInputs.add(inputEl); setFieldHighlight(inputEl, "greenTwo") } else { result.failed++ }
            } else {
              const ok = await b2FillSingleField(inputEl, field.label, field.value, lang)
              if (ok) { result.success++; usedInputs.add(inputEl); setFieldHighlight(inputEl, "greenTwo") } else { result.failed++ }
            }
            await delay("mid")
          }
        }
      }
    } else {
      const fields = sectionData.formItems as { label: string; value: string }[]
      console.log(`  [B2] "${sectionData.title}" (非经历) 缓存${fields.length}个字段`)
      for (const field of fields) {
        if (!field.value) { result.skipped++; continue }
        let inputEl = b2FindInputByLabel(field.label, titleEl, nextTitleEl, usedInputs)
        // fallback：如果 b2FindInputByLabel 找不到，从阶段B传入的未填简历字段映射中查找
        if (!inputEl && unfilledMainFieldMap) {
          const fallbackEl = unfilledMainFieldMap.get(field.label)
          if (fallbackEl && !usedInputs.has(fallbackEl)) {
            inputEl = fallbackEl
            console.log(`  [B2] "${field.label}" 通过 unfilledMainFieldMap fallback 定位到 input`)
          }
        }
        if (!inputEl) { result.skipped++; continue }
        // 时间/日期字段走阶段A同款流程：直接点击 input → fillDatePicker，不经过 detectPickerField
        if (b2IsDateTimeLabel(field.label)) {
          const ok = await b2FillDateTimeField(inputEl, field.label, field.value)
          if (ok) { result.success++; usedInputs.add(inputEl); setFieldHighlight(inputEl, "greenTwo") } else { result.failed++ }
        } else {
          const ok = await b2FillSingleField(inputEl, field.label, field.value, lang)
          if (ok) { result.success++; usedInputs.add(inputEl); setFieldHighlight(inputEl, "greenTwo") } else { result.failed++ }
        }
        await delay("mid")
      }
    }
  }

  console.log(`===== OfferPie: 阶段B2完成 成功${result.success} 失败${result.failed} 跳过${result.skipped} =====`)
  return result
}