// Fabrikanalyse-Export (Demo-067 E, KAR-984) — Markdown. Same content/order
// as assessment-docx.ts's buildFabrikanalyseCopilotDocx, consuming the exact
// same AssessmentDocxInput contract — only the markup changes (Markdown
// headings/pipe-tables instead of docx Paragraph/Table). Kept a fully
// separate builder rather than refactoring assessment-docx.ts to share a
// content model (task scope: "Wiederverwendung statt Refactor", DOCX
// builders stay untouched) — RATING_LABEL/deText/toResponseDraftMap are
// therefore duplicated 1:1 from assessment-docx.ts, same rationale that
// file already documents for its own duplication of toResponseDraftMap from
// components/assessment/assessment-dashboard.tsx: small, pure, and
// duplicating them costs less than adding a cross-builder dependency for
// ~15 lines.
//
// Pure function of its inputs — no Supabase/DB access, no async work (unlike
// the DOCX/XLSX builders, there is no pack/serialize step, so this returns a
// plain string, not a Promise).

import type { AssessmentResponse, QuestionWithCategories, ResponseDraft } from '@/lib/assessment-types'
import { computeMainCategoryStats, computeOverallStats } from '@/lib/assessment-analytics'
import { buildAiInstructionBlock } from './ai-instruction-block'
import { formatNumberDe, formatPercentDe } from './docx-shared'
import { joinMdBlocks, mdBold, mdH1, mdH2, mdH3, mdItalic, mdKvTable, mdTable, mdTitle, renderAiInstructionBlockMd } from './md-shared'
import type { AssessmentDocxInput } from './assessment-docx'

const RATING_LABEL: Record<number, string> = {
  1: 'Nicht erfüllt',
  2: 'Teilweise',
  3: 'Erfüllt',
  4: 'Best Practice',
}

function deText(base: string, localized: string | null | undefined): string {
  return localized && localized.trim() !== '' ? localized : base
}

/** Same reshape as assessment-docx.ts's toResponseDraftMap (duplicated, not
 * imported — see module header). */
function toResponseDraftMap(
  questions: QuestionWithCategories[],
  responses: AssessmentResponse[],
): Record<string, ResponseDraft> {
  const byQ = new Map(responses.map((r) => [r.question_id, r]))
  const map: Record<string, ResponseDraft> = {}
  for (const q of questions) {
    const r = byQ.get(q.id)
    map[q.id] = {
      dbId: r?.id ?? null,
      is_relevant: r?.is_relevant ?? true,
      is_flagged: r?.is_flagged ?? false,
      selected_rating: r?.selected_rating ?? null,
      comment: r?.comment ?? '',
    }
  }
  return map
}

export function buildFabrikanalyseCopilotMd(input: AssessmentDocxInput): string {
  const { assessment, questions, generatedAtLabel } = input
  const responses = toResponseDraftMap(questions, input.responses)

  const overall = computeOverallStats(questions, responses)
  const mainStats = computeMainCategoryStats(questions, responses)

  const dateStr = assessment.conducted_at ? new Date(assessment.conducted_at).toLocaleDateString('de-DE') : null

  const aiBlock = buildAiInstructionBlock({
    exportTitle: 'Fabrikanalyse-Export',
    aboutText:
      'Dieses Dokument ist der Export einer Fabrikanalyse (FA) — einer werksweiten, strukturierten ' +
      'Bewertung über mehrere Kategorien und Unterkategorien. Es enthält die Bewertungen (Skala 1–4), ' +
      'Kommentare und eine Kategorien-Übersicht, so wie sie zum Exportzeitpunkt im System standen.',
    usageHints: [
      'Erstelle eine Management Summary pro Hauptkategorie und hebe kritische Bereiche (Bewertung 1–2) hervor.',
      'Formuliere konkrete, priorisierte Handlungsempfehlungen aus den Kommentaren zu niedrig bewerteten Fragen.',
      'Zitiere bei Kernaussagen die betroffene Frage (Nummer + Kategorie), damit die Aussage nachvollziehbar bleibt.',
    ],
    isDemo: assessment.is_demo === true,
  })

  const blocks: string[] = [
    mdTitle('Fabrikanalyse-Export'),
    mdBold(`${assessment.title} — ${assessment.supplier_name ?? '—'}${dateStr ? ` — ${dateStr}` : ''}`),
    ...renderAiInstructionBlockMd(aiBlock),

    mdH1('Steckbrief'),
    mdKvTable([
      ['Titel', assessment.title],
      ['Zulieferer', assessment.supplier_name ?? '—'],
      ['Standort', assessment.location ?? '—'],
      ['Assessment-Nr.', assessment.assessment_number ?? '—'],
      ['Datum', dateStr ?? '—'],
      ['Status', assessment.status],
      ['Erzeugt am', generatedAtLabel],
    ]),

    mdH1('Gesamtübersicht'),
    mdKvTable([
      ['Gesamtbewertung', overall.score !== null ? `${formatNumberDe(overall.score)} / 4,00` : '— (nicht bewertet)'],
      ['Fortschritt', `${overall.answered}/${overall.totalRelevant} Fragen (${formatPercentDe(overall.progress / 100, 0)})`],
      ['Markiert', String(overall.flagged)],
      ['Kommentiert', String(overall.commented)],
    ]),

    mdH1('Kategorien-Übersicht'),
    mdTable(
      ['Hauptkategorie', 'Ø Bewertung', 'Beantwortet', 'Fortschritt'],
      mainStats.map((m) => [
        m.label,
        m.avg !== null ? formatNumberDe(m.avg) : '—',
        `${m.answered}/${m.total}`,
        formatPercentDe(m.progress / 100, 0),
      ]),
    ),
  ]

  // ── Detail: main category -> sub category -> question (mirrors
  // assessment-docx.ts's grouping/sort exactly). ──────────────────────────
  const mainMap = new Map<
    string,
    { label: string; sortOrder: number; subs: Map<string, { label: string; sortOrder: number; qs: QuestionWithCategories[] }> }
  >()
  for (const q of [...questions].sort((a, b) => a.index_number - b.index_number)) {
    const mainLabel = deText(q.main_category.label, q.main_category.label_de)
    const subLabel = deText(q.sub_category.label, q.sub_category.label_de)
    if (!mainMap.has(q.main_category_id)) {
      mainMap.set(q.main_category_id, { label: mainLabel, sortOrder: q.main_category.sort_order, subs: new Map() })
    }
    const m = mainMap.get(q.main_category_id)!
    if (!m.subs.has(q.sub_category_id)) {
      m.subs.set(q.sub_category_id, { label: subLabel, sortOrder: q.sub_category.sort_order, qs: [] })
    }
    m.subs.get(q.sub_category_id)!.qs.push(q)
  }

  blocks.push(mdH1('Fragen im Detail'))
  for (const [, main] of [...mainMap.entries()].sort((a, b) => a[1].sortOrder - b[1].sortOrder)) {
    blocks.push(mdH2(main.label))
    for (const [, sub] of [...main.subs.entries()].sort((a, b) => a[1].sortOrder - b[1].sortOrder)) {
      blocks.push(mdH3(sub.label))
      const relevantQs = sub.qs.filter((q) => responses[q.id]?.is_relevant !== false)
      if (relevantQs.length === 0) {
        blocks.push(mdItalic('Keine relevanten Fragen in dieser Unterkategorie.'))
        continue
      }
      for (const q of relevantQs) {
        const r = responses[q.id]
        const rating = r?.selected_rating ?? null
        const comment = r?.comment?.trim() ?? ''
        const qText = deText(q.question_text, q.question_text_de)
        const lines: string[] = [mdBold(`Frage ${q.index_number}: ${qText}`)]
        if (rating !== null) {
          const answerCol = [q.answer_text_1, q.answer_text_2, q.answer_text_3, q.answer_text_4][rating - 1]
          const answerColDe = [q.answer_text_1_de, q.answer_text_2_de, q.answer_text_3_de, q.answer_text_4_de][rating - 1]
          const aText = deText(answerCol, answerColDe) || RATING_LABEL[rating]
          lines.push(`Bewertung: ${rating} — ${RATING_LABEL[rating]} (${aText})`)
        } else {
          lines.push('Bewertung: — (nicht bewertet)')
        }
        if (comment) lines.push(`Kommentar: ${comment}`)
        blocks.push(lines.join('\n'))
      }
    }
  }

  return joinMdBlocks(blocks)
}