/**
 * 分组测试（对应设计文档 §16 阶段 3 与 §6.1 的分组区域）。
 *
 * 分组语义：相邻行键值相同即同组，不改变行顺序。
 */
import { describe, expect, it } from "vitest"
import {
  createDocument,
  createTableElement,
  type ReportDocument,
  type ReportSection,
} from "@report/core"
import { createEstimateMeasurer, createPassthroughFontResolver } from "../src/measurer.js"
import { layoutDocument } from "../src/engine.js"
import { computeGroups, collectGroupLevels, isSameGroupKey } from "../src/group.js"
import type { GroupLevelSpec } from "../src/group.js"
import { walkLayoutNodes } from "../src/layout-document.js"
import type { RenderContext } from "../src/context.js"

const measurer = createEstimateMeasurer()
const fontResolver = createPassthroughFontResolver()

async function layout(doc: ReportDocument, context: RenderContext) {
  return layoutDocument(doc, context, { textMeasurer: measurer, fontResolver })
}

const ROWS = [
  { region: "华北", city: "北京", amount: 100 },
  { region: "华北", city: "天津", amount: 200 },
  { region: "华东", city: "上海", amount: 300 },
  { region: "华东", city: "杭州", amount: 400 },
  { region: "华南", city: "广州", amount: 500 },
]

function baseDoc(): ReportDocument {
  const doc = createDocument({ name: "分组报表" })
  doc.datasets = { sales: { id: "sales" } }
  doc.sections.find((s) => s.kind === "detail")!.children.push(
    createTableElement("tbl", { x: 0, y: 0, width: 180, height: 20 }, "sales", [
      { id: "c1", width: 60, header: "地区", binding: { field: "region" } },
      { id: "c2", width: 60, header: "城市", binding: { field: "city" } },
      { id: "c3", width: 60, header: "金额", binding: { field: "amount" }, align: "right" },
    ]),
  )
  return doc
}

/** 插入一个分组区域。 */
function addGroupSection(
  doc: ReportDocument,
  kind: "group-header" | "group-footer",
  children: ReportSection["children"],
  extra: Partial<ReportSection> = {},
): ReportSection {
  const section: ReportSection = {
    id: `grp-${kind}`,
    kind,
    children,
    groupExpression: "row.region",
    groupLevel: 1,
    ...extra,
  }
  // 插在 detail 之前（组头）或之后（组脚）
  const detailIndex = doc.sections.findIndex((s) => s.kind === "detail")
  const insertAt = kind === "group-header" ? detailIndex : detailIndex + 1
  doc.sections.splice(insertAt, 0, section)
  return section
}

describe("isSameGroupKey", () => {
  it("相同标量为同组", () => {
    expect(isSameGroupKey("a", "a")).toBe(true)
    expect(isSameGroupKey(1, 1)).toBe(true)
  })

  it("不同标量不同组", () => {
    expect(isSameGroupKey("a", "b")).toBe(false)
    expect(isSameGroupKey(1, 2)).toBe(false)
  })

  it("数字与字符串等价（避免 1 与 '1' 被拆成两组）", () => {
    expect(isSameGroupKey(1, "1")).toBe(true)
  })

  it("null 与 undefined 视为同组", () => {
    expect(isSameGroupKey(null, undefined)).toBe(true)
    expect(isSameGroupKey(null, null)).toBe(true)
    expect(isSameGroupKey(null, 0)).toBe(false)
  })
})

describe("computeGroups", () => {
  it("按相邻行切分", () => {
    const levels: GroupLevelSpec[] = [{ level: 1, expression: "row.region" }]
    const tree = computeGroups(ROWS, levels, [])
    expect(tree.groups).toHaveLength(3)
    expect(tree.groups[0]?.key).toBe("华北")
    expect(tree.groups[1]?.key).toBe("华东")
    expect(tree.groups[2]?.key).toBe("华南")
  })

  it("记录每组的行区间", () => {
    const tree = computeGroups(ROWS, [{ level: 1, expression: "row.region" }], [])
    expect(tree.groups[0]?.start).toBe(0)
    expect(tree.groups[0]?.end).toBe(2)
    expect(tree.groups[1]?.start).toBe(2)
    expect(tree.groups[1]?.end).toBe(4)
    expect(tree.groups[2]?.start).toBe(4)
    expect(tree.groups[2]?.end).toBe(5)
  })

  it("每组携带该组行数据", () => {
    const tree = computeGroups(ROWS, [{ level: 1, expression: "row.region" }], [])
    expect(tree.groups[0]?.rows).toHaveLength(2)
    expect(tree.groups[0]?.rows[0]?.city).toBe("北京")
  })

  it("标记首组与末组", () => {
    const tree = computeGroups(ROWS, [{ level: 1, expression: "row.region" }], [])
    expect(tree.groups[0]?.isFirst).toBe(true)
    expect(tree.groups[0]?.isLast).toBe(false)
    expect(tree.groups[2]?.isLast).toBe(true)
  })

  it("相同键不相邻时视为不同组（不排序）", () => {
    const rows = [
      { region: "A" },
      { region: "B" },
      { region: "A" },
    ]
    const tree = computeGroups(rows, [{ level: 1, expression: "row.region" }], [])
    // 相邻切分：A / B / A 共 3 组
    expect(tree.groups).toHaveLength(3)
  })

  it("空数据集不产生分组", () => {
    const tree = computeGroups([], [{ level: 1, expression: "row.region" }], [])
    expect(tree.groups).toHaveLength(0)
  })

  it("无分组定义时不产生分组", () => {
    const tree = computeGroups(ROWS, [], [])
    expect(tree.groups).toHaveLength(0)
  })

  it("坏表达式产生诊断而非抛异常", () => {
    const diagnostics: import("@report/core").Diagnostic[] = []
    const tree = computeGroups(ROWS, [{ level: 1, expression: "row." }], diagnostics)
    expect(tree.groups).toHaveLength(0)
    expect(diagnostics.some((d) => d.code === "expression.parse-error")).toBe(true)
  })

  it("支持多级分组", () => {
    const rows = [
      { region: "华北", city: "北京" },
      { region: "华北", city: "北京" },
      { region: "华北", city: "天津" },
      { region: "华东", city: "上海" },
    ]
    const tree = computeGroups(
      rows,
      [
        { level: 1, expression: "row.region" },
        { level: 2, expression: "row.city" },
      ],
      [],
    )
    // L1: 华北(0-3), 华东(3-4)；L2: 北京(0-2), 天津(2-3), 上海(3-4)
    const l1 = tree.groups.filter((g) => g.level === 1)
    const l2 = tree.groups.filter((g) => g.level === 2)
    expect(l1).toHaveLength(2)
    expect(l2).toHaveLength(3)
  })

  it("多级分组中各级区间相互独立", () => {
    const rows = [
      { region: "A", city: "x" },
      { region: "A", city: "y" },
      { region: "B", city: "z" },
    ]
    const tree = computeGroups(
      rows,
      [
        { level: 1, expression: "row.region" },
        { level: 2, expression: "row.city" },
      ],
      [],
    )
    const l2 = tree.groups.filter((g) => g.level === 2)
    expect(l2[0]?.rows).toHaveLength(1)
    expect(l2[1]?.rows).toHaveLength(1)
  })

  it("分组结果按出现位置排序", () => {
    const tree = computeGroups(ROWS, [{ level: 1, expression: "row.region" }], [])
    const starts = tree.groups.map((g) => g.start)
    expect([...starts].sort((a, b) => a - b)).toEqual(starts)
  })
})

describe("collectGroupLevels", () => {
  it("从区域收集分组级别", () => {
    const doc = baseDoc()
    addGroupSection(doc, "group-header", [])
    addGroupSection(doc, "group-footer", [])
    const levels = collectGroupLevels(doc.sections, [])
    expect(levels).toHaveLength(1)
    expect(levels[0]?.expression).toBe("row.region")
    expect(levels[0]?.headerSection).toBeDefined()
    expect(levels[0]?.footerSection).toBeDefined()
  })

  it("缺少 groupExpression 时产生诊断", () => {
    const diagnostics: import("@report/core").Diagnostic[] = []
    const section: ReportSection = {
      id: "g1",
      kind: "group-header",
      children: [],
    }
    collectGroupLevels([section], diagnostics)
    expect(diagnostics.some((d) => d.message.includes("缺少 groupExpression"))).toBe(true)
  })

  it("同级别表达式不一致时告警", () => {
    const diagnostics: import("@report/core").Diagnostic[] = []
    const sections: ReportSection[] = [
      { id: "h", kind: "group-header", children: [], groupExpression: "row.a", groupLevel: 1 },
      { id: "f", kind: "group-footer", children: [], groupExpression: "row.b", groupLevel: 1 },
    ]
    collectGroupLevels(sections, diagnostics)
    expect(diagnostics.some((d) => d.message.includes("不同的"))).toBe(true)
  })

  it("多级别按 level 升序返回", () => {
    const sections: ReportSection[] = [
      { id: "h2", kind: "group-header", children: [], groupExpression: "row.b", groupLevel: 2 },
      { id: "h1", kind: "group-header", children: [], groupExpression: "row.a", groupLevel: 1 },
    ]
    const levels = collectGroupLevels(sections, [])
    expect(levels.map((l) => l.level)).toEqual([1, 2])
  })
})

describe("分组布局输出", () => {
  it("组头渲染到输出中", async () => {
    const doc = baseDoc()
    addGroupSection(doc, "group-header", [
      {
        id: "gh",
        type: "text",
        frame: { x: 0, y: 0, width: 100, height: 8 },
        binding: { expression: "'地区：' + row.region" },
      },
    ])
    const result = await layout(doc, { data: { sales: ROWS }, parameters: {} })

    const texts: string[] = []
    walkLayoutNodes(result, (node) => {
      if (node.content?.kind === "text") texts.push(node.content.text)
    })
    // 三个地区各输出一次组头
    expect(texts.filter((t) => t.startsWith("地区："))).toHaveLength(3)
    expect(texts).toContain("地区：华北")
    expect(texts).toContain("地区：华东")
    expect(texts).toContain("地区：华南")
  })

  it("组脚按组聚合（sum）", async () => {
    const doc = baseDoc()
    addGroupSection(doc, "group-footer", [
      {
        id: "gf",
        type: "text",
        frame: { x: 0, y: 0, width: 100, height: 8 },
        binding: { expression: "sum(group.amount) + ' / ' + group.count + ' 笔'" },
      },
    ])
    const result = await layout(doc, { data: { sales: ROWS }, parameters: {} })

    const texts: string[] = []
    walkLayoutNodes(result, (node) => {
      if (node.content?.kind === "text") texts.push(node.content.text)
    })
    // 华北 100+200=300（2 笔），华东 300+400=700（2 笔），华南 500（1 笔）
    expect(texts).toContain("300 / 2 笔")
    expect(texts).toContain("700 / 2 笔")
    expect(texts).toContain("500 / 1 笔")
  })

  it("组脚可用 avg 聚合", async () => {
    const doc = baseDoc()
    addGroupSection(doc, "group-footer", [
      {
        id: "gf",
        type: "text",
        frame: { x: 0, y: 0, width: 100, height: 8 },
        binding: { expression: "avg(group.amount)" },
      },
    ])
    const result = await layout(doc, { data: { sales: ROWS }, parameters: {} })
    const texts: string[] = []
    walkLayoutNodes(result, (node) => {
      if (node.content?.kind === "text") texts.push(node.content.text)
    })
    // 华北均值 150，华东 350，华南 500
    expect(texts).toContain("150")
    expect(texts).toContain("350")
  })

  it("组脚可访问 group.key", async () => {
    const doc = baseDoc()
    addGroupSection(doc, "group-footer", [
      {
        id: "gf",
        type: "text",
        frame: { x: 0, y: 0, width: 100, height: 8 },
        binding: { expression: "string(group.key)" },
      },
    ])
    const result = await layout(doc, { data: { sales: ROWS }, parameters: {} })
    const texts: string[] = []
    walkLayoutNodes(result, (node) => {
      if (node.content?.kind === "text") texts.push(node.content.text)
    })
    expect(texts).toContain("华北")
    expect(texts).toContain("华南")
  })

  it("详细行全部保留（分组不丢行）", async () => {
    const doc = baseDoc()
    addGroupSection(doc, "group-header", [
      { id: "gh", type: "text", frame: { x: 0, y: 0, width: 100, height: 8 }, props: { text: "组" } },
    ])
    const result = await layout(doc, { data: { sales: ROWS }, parameters: {} })

    let rowCount = 0
    walkLayoutNodes(result, (node) => {
      if (node.role === "table-row" && node.content?.kind === "table") rowCount += 1
    })
    expect(rowCount).toBe(ROWS.length)
  })

  it("分组后行顺序不变", async () => {
    const doc = baseDoc()
    addGroupSection(doc, "group-header", [
      { id: "gh", type: "text", frame: { x: 0, y: 0, width: 100, height: 8 }, props: { text: "组" } },
    ])
    const result = await layout(doc, { data: { sales: ROWS }, parameters: {} })

    const cities: string[] = []
    walkLayoutNodes(result, (node) => {
      if (node.content?.kind === "table" && node.role === "table-row") {
        const cell = node.content.rows[0]?.cells[1]
        if (cell) cities.push(cell.text)
      }
    })
    expect(cities).toEqual(["北京", "天津", "上海", "杭州", "广州"])
  })

  it("组头在详细行之前、组脚之后", async () => {
    const doc = baseDoc()
    addGroupSection(doc, "group-header", [
      { id: "gh", type: "text", frame: { x: 0, y: 0, width: 100, height: 10 }, props: { text: "组头" } },
    ])
    addGroupSection(doc, "group-footer", [
      { id: "gf", type: "text", frame: { x: 0, y: 0, width: 100, height: 10 }, props: { text: "组脚" } },
    ])
    const result = await layout(doc, { data: { sales: ROWS }, parameters: {} })

    const order: string[] = []
    walkLayoutNodes(result, (node) => {
      if (node.id === "gh") order.push("H")
      if (node.id === "gf") order.push("F")
      if (node.role === "table-row") order.push("R")
    })
    // 期望：H R R F H R R F H R F（3 组）
    expect(order.join("")).toBe("HRRFHRRFHRF")
  })

  it("无数据时不输出分组区域", async () => {
    const doc = baseDoc()
    addGroupSection(doc, "group-footer", [
      { id: "gf", type: "text", frame: { x: 0, y: 0, width: 100, height: 8 }, props: { text: "组脚" } },
    ])
    const result = await layout(doc, { data: { sales: [] }, parameters: {} })
    const texts: string[] = []
    walkLayoutNodes(result, (node) => {
      if (node.content?.kind === "text") texts.push(node.content.text)
    })
    expect(texts).not.toContain("组脚")
    expect(result.diagnostics.some((d) => d.code === "data.dataset-missing")).toBe(true)
  })

  it("没有分组定义时行为与之前一致", async () => {
    const doc = baseDoc()
    const result = await layout(doc, { data: { sales: ROWS }, parameters: {} })
    let rowCount = 0
    walkLayoutNodes(result, (node) => {
      if (node.role === "table-row") rowCount += 1
    })
    expect(rowCount).toBe(ROWS.length)
  })

  it("表头仍每页重复（分组不影响）", async () => {
    const doc = baseDoc()
    addGroupSection(doc, "group-header", [
      { id: "gh", type: "text", frame: { x: 0, y: 0, width: 100, height: 6 }, props: { text: "组" } },
    ])
    // 用大量数据迫使多页
    const manyRows = Array.from({ length: 200 }, (_, i) => ({
      region: `地区${Math.floor(i / 20)}`,
      city: `城市${i}`,
      amount: i,
    }))
    const result = await layout(doc, { data: { sales: manyRows }, parameters: {} })
    expect(result.pages.length).toBeGreaterThan(1)
    for (const page of result.pages) {
      expect(page.nodes.some((n) => n.role === "table-header")).toBe(true)
    }
  })

  it("分组跨页时组脚仍输出", async () => {
    const doc = baseDoc()
    addGroupSection(doc, "group-footer", [
      {
        id: "gf",
        type: "text",
        frame: { x: 0, y: 0, width: 100, height: 8 },
        binding: { expression: "sum(group.amount)" },
      },
    ])
    const manyRows = Array.from({ length: 200 }, (_, i) => ({
      region: `地区${Math.floor(i / 20)}`,
      city: `城市${i}`,
      amount: 1,
    }))
    const result = await layout(doc, { data: { sales: manyRows }, parameters: {} })

    const totals: string[] = []
    walkLayoutNodes(result, (node) => {
      if (node.id === "gf" && node.content?.kind === "text") totals.push(node.content.text)
    })
    // 10 个组，每组 20 行 × 1 = 20
    expect(totals).toHaveLength(10)
    expect(totals.every((t) => t === "20")).toBe(true)
  })

  it("组头不与组内首行分离（keepWithNext）", async () => {
    const doc = baseDoc()
    addGroupSection(doc, "group-header", [
      { id: "gh", type: "text", frame: { x: 0, y: 0, width: 100, height: 8 }, props: { text: "组头" } },
    ])
    // 大量行迫使多页；每个组头后面一定紧跟数据行
    const manyRows = Array.from({ length: 200 }, (_, i) => ({
      region: `地区${Math.floor(i / 20)}`,
      city: `城市${i}`,
      amount: i,
    }))
    const result = await layout(doc, { data: { sales: manyRows }, parameters: {} })

    // 逐页检查：任何一页里，组头 gh 之后必然存在至少一个数据行
    for (const page of result.pages) {
      const ids: string[] = []
      walkLayoutNodes({ ...result, pages: [page] }, (node) => {
        if (node.id === "gh") ids.push("H")
        else if (node.role === "table-row") ids.push("R")
      })
      // 若本页有组头，则其后必须有数据行（组头不孤立）
      const headerPos = ids.indexOf("H")
      if (headerPos >= 0) {
        expect(ids.slice(headerPos + 1)).toContain("R")
      }
    }
  })

  it("组脚不与组内末行分离（keepWithPrevious）", async () => {
    const doc = baseDoc()
    addGroupSection(doc, "group-footer", [
      { id: "gf", type: "text", frame: { x: 0, y: 0, width: 100, height: 8 }, props: { text: "组脚" } },
    ])
    const manyRows = Array.from({ length: 200 }, (_, i) => ({
      region: `地区${Math.floor(i / 20)}`,
      city: `城市${i}`,
      amount: i,
    }))
    const result = await layout(doc, { data: { sales: manyRows }, parameters: {} })

    // 逐页检查：任何一页里，组脚 gf 之前必然存在数据行（组脚不孤立）
    for (const page of result.pages) {
      const ids: string[] = []
      walkLayoutNodes({ ...result, pages: [page] }, (node) => {
        if (node.id === "gf") ids.push("F")
        else if (node.role === "table-row") ids.push("R")
      })
      const footerPos = ids.lastIndexOf("F")
      if (footerPos >= 0) {
        expect(ids.slice(0, footerPos)).toContain("R")
      }
    }
  })

  it("组脚不丢失（跨页后每组的组脚都在）", async () => {
    const doc = baseDoc()
    addGroupSection(doc, "group-footer", [
      { id: "gf", type: "text", frame: { x: 0, y: 0, width: 100, height: 8 }, props: { text: "组脚" } },
    ])
    const manyRows = Array.from({ length: 60 }, (_, i) => ({
      region: `地区${Math.floor(i / 6)}`,
      city: `城市${i}`,
      amount: 1,
    }))
    const result = await layout(doc, { data: { sales: manyRows }, parameters: {} })

    const footers: string[] = []
    walkLayoutNodes(result, (node) => {
      if (node.id === "gf" && node.content?.kind === "text") footers.push(node.content.text)
    })
    // 10 个组，每个组的组脚都必须出现一次
    expect(footers).toHaveLength(10)
    expect(footers.every((t) => t === "组脚")).toBe(true)
  })

  it("pageBreakBefore 使每组独占一页起始", async () => {
    const doc = baseDoc()
    addGroupSection(
      doc,
      "group-header",
      [{ id: "gh", type: "text", frame: { x: 0, y: 0, width: 100, height: 8 }, props: { text: "组头" } }],
      { pageBreakBefore: true },
    )
    // 3 组，每组若干行，组头声明 pageBreakBefore
    const rows = Array.from({ length: 30 }, (_, i) => ({
      region: `地区${Math.floor(i / 10)}`,
      city: `城市${i}`,
      amount: i,
    }))
    const result = await layout(doc, { data: { sales: rows }, parameters: {} })

    // 每个组头应落在其所在页的主体顶部（即该页第一个主体块）
    const pageHeaders: string[][] = []
    for (const page of result.pages) {
      const ids: string[] = []
      walkLayoutNodes({ ...result, pages: [page] }, (node) => {
        if (node.id === "gh") ids.push("H")
        else if (node.role === "table-row") ids.push("R")
        else if (node.role === "table-header") ids.push("T")
      })
      pageHeaders.push(ids)
    }

    // 至少应有多页；每个含组头的页，组头应是首个非表头块
    const pagesWithHeader = pageHeaders.filter((ids) => ids.includes("H"))
    expect(pagesWithHeader.length).toBe(3)
    for (const ids of pagesWithHeader) {
      // 去掉前导表头后，第一个主体块应是组头
      const firstBody = ids.find((x) => x !== "T")
      expect(firstBody).toBe("H")
    }
  })
})