import { describe, expect, it } from 'vitest'
import {
  assertTemplateEnvelope,
  bioTemplatePresetControlValuesToOptions,
  createBioTemplatePackCollection,
  createBioTemplatePresetCollection,
  createBioTemplatePresetCollectionFromControls,
  createAssayMatrixTemplate,
  createCalibrationCurveTemplate,
  createDoseResponseTemplate,
  createElisaAssayCollection,
  createFlowCytometryAssayCollection,
  createFlowCytometryPanelTemplate,
  createInstrumentRunTemplate,
  createLcmsBatchCollection,
  createPlateMapTemplate,
  createProtocolStepsTemplate,
  createQpcrExpressionCollection,
  createQpcrPlateTemplate,
  createReagentListTemplate,
  createSampleSheetTemplate,
  createSamplePrepTemplate,
  createTargetedMetabolomicsCollection,
  createDefaultBioTemplate,
  createTemplateCollection,
  createTimeCourseTemplate,
  createWellPlateScreenCollection,
  createWesternBlotAssayCollection,
  ensureTemplateEnvelope,
  ensureTemplateFromCollection,
  extractTemplateCollection,
  getBioTemplateComponentBindings,
  getBioTemplateComponentProps,
  getBioTemplateControlDefaults,
  getBioTemplateControlSchema,
  getBioTemplatePackInfo,
  getBioTemplatePresetInfo,
  getBioTemplateInfo,
  listBioTemplateCatalog,
  listBioTemplateComponentBindings,
  listBioTemplateControlSchemas,
  listBioTemplatePacks,
  listBioTemplatePresets,
  searchBioTemplatePacks,
  searchBioTemplateCatalog,
  searchBioTemplatePresets,
  toBioTemplateComponentBindings,
  toBioTemplateComponentBindingsById,
  toBioTemplateComponentImports,
  toBioTemplateComponentProps,
  toBioTemplateComponentPropsByComponent,
  toBioTemplateComponentPropsById,
  toBioTemplateComponentSnippets,
  toBioTemplateComponentUsage,
  toAssayMatrixColumns,
  toAssayMatrixDataFrame,
  toAssayMatrixRows,
  toAssayMatrixSampleOptions,
  toCalibrationCurveDataFrame,
  toCalibrationCurveRows,
  toDoseConditions,
  toDoseLayoutState,
  toFlowPanelDataFrame,
  toFlowPanelRows,
  toInstrumentRunDataFrame,
  toInstrumentRunRows,
  toInstrumentRunScheduleEvents,
  toInstrumentRunSteps,
  racksFromPlateState,
  toPlateMapEditorState,
  toProtocolDataFrame,
  toProtocolSteps,
  toQpcrDataFrame,
  toQpcrRows,
  toQpcrWellPlateWells,
  toReagentDataFrame,
  toReagentListItems,
  toSampleColumns,
  toSampleDataFrame,
  toSampleOptions,
  toSamplePrepDataFrame,
  toSamplePrepRows,
  toSampleRows,
  toTemplateDataFrame,
  toTimeCourseDataFrame,
  toTimeCourseRows,
  toTimeCourseSteps,
  toWellPlateWells,
  TEMPLATE_COLLECTION_KEY,
} from '../../templates'
import bioTemplateCatalogContract from '../../../../bio-template-catalog.contract.json'
import bioTemplatePacksContract from '../../../../bio-template-packs.contract.json'
import bioTemplatePresetsContract from '../../../../bio-template-presets.contract.json'
import type {
  AssayMatrixTemplate,
  DoseResponseTemplate,
  FlowCytometryPanelTemplate,
  InstrumentRunTemplate,
  PlateMapTemplate,
  ProtocolStepsTemplate,
  QpcrPlateTemplate,
  ReagentListTemplate,
  SampleSheetTemplate,
} from '../../templates'
import doseResponseFixture from '../fixtures/templates/dose-response.json'
import plateMapFixture from '../fixtures/templates/plate-map.json'
import qpcrPlateFixture from '../fixtures/templates/qpcr-plate.json'
import sampleSheetFixture from '../fixtures/templates/sample-sheet.json'

describe('bio data templates', () => {
  it('exposes a discoverable template catalog', () => {
    const catalog = listBioTemplateCatalog()

    expect(catalog.map(entry => entry.name)).toEqual([
      'plate-map',
      'sample-sheet',
      'sample-prep',
      'dose-response',
      'calibration-curve',
      'time-course',
      'protocol-steps',
      'assay-matrix',
      'reagent-list',
      'flow-cytometry-panel',
      'instrument-run',
      'qpcr-plate',
    ])
    expect(getBioTemplateInfo('wellplate')?.template_id).toBe('plate-map')
    expect(getBioTemplateInfo('sample preparation')?.template_id).toBe('sample-prep')
    expect(getBioTemplateInfo('dose design')?.template_id).toBe('dose-response')
    expect(getBioTemplateInfo('dose-design')?.template_id).toBe('dose-response')
    expect(getBioTemplateInfo('dose calculator')?.template_id).toBe('dose-response')
    expect(getBioTemplateInfo('dose_calculator')?.template_id).toBe('dose-response')
    expect(getBioTemplateInfo('protocol')?.template_id).toBe('protocol-steps')
    expect(getBioTemplateInfo('standard curve')?.template_id).toBe('calibration-curve')
    expect(getBioTemplateInfo('omics matrix')?.template_id).toBe('assay-matrix')
    expect(getBioTemplateInfo('antibodies')?.template_id).toBe('reagent-list')
    expect(getBioTemplateInfo('facs panel')?.template_id).toBe('flow-cytometry-panel')
    expect(getBioTemplateInfo('run queue')?.template_id).toBe('instrument-run')
    expect(getBioTemplateInfo('gene expression')?.template_id).toBe('qpcr-plate')
    expect(searchBioTemplateCatalog('DoseCalculator')[0].name).toBe('dose-response')
  })

  it('matches the shared Python/frontend catalog contract', () => {
    expect(listBioTemplateCatalog()).toEqual(bioTemplateCatalogContract)
  })

  it('exposes discoverable template collection packs', () => {
    const packs = listBioTemplatePacks()

    expect(packs.map(entry => entry.name)).toEqual([
      'cell-culture-screen',
      'omics-assay',
      'longitudinal-study',
      'molecular-assay',
    ])
    expect(getBioTemplatePackInfo('cell culture')?.templates).toEqual([
      'sample-sheet',
      'sample-prep',
      'plate-map',
      'reagent-list',
      'protocol-steps',
      'dose-response',
      'flow-cytometry-panel',
    ])
    expect(getBioTemplatePackInfo('metabolomics')?.name).toBe('omics-assay')
    expect(getBioTemplatePackInfo('metabolism')?.name).toBe('omics-assay')
    expect(getBioTemplatePackInfo('metabolite profiling')?.name).toBe('omics-assay')
    expect(getBioTemplatePackInfo('metabolomics')?.components).toContain('ExperimentTimeline')
    expect(getBioTemplatePackInfo('longitudinal')?.add_command).toBe('mint add data-template-pack longitudinal-study --page')
    expect(getBioTemplatePackInfo('gene expression')?.templates.at(-1)).toBe('qpcr-plate')
    expect(getBioTemplatePackInfo('gene-expression')?.templates.at(-1)).toBe('qpcr-plate')
    expect(searchBioTemplatePacks('WellPlate').map(entry => entry.name)).toEqual([
      'cell-culture-screen',
      'omics-assay',
      'molecular-assay',
    ])
  })

  it('matches the shared Python/frontend pack contract', () => {
    expect(listBioTemplatePacks()).toEqual(bioTemplatePacksContract)
  })

  it('creates default template collections from curated packs', () => {
    const plate = createDefaultBioTemplate('wellplate') as PlateMapTemplate
    const pack = createBioTemplatePackCollection('cell culture')
    const templates = extractTemplateCollection(pack)

    expect(plate.template_id).toBe('plate-map')
    expect(pack.metadata?.pack).toBe('cell-culture-screen')
    expect(Object.keys(templates)).toEqual([
      'sample-sheet',
      'sample-prep',
      'plate-map',
      'reagent-list',
      'protocol-steps',
      'dose-response',
      'flow-cytometry-panel',
    ])
    expect(toPlateMapEditorState(templates['plate-map'] as PlateMapTemplate).samples).toHaveLength(2)
    expect(toDoseConditions(templates['dose-response'] as DoseResponseTemplate)[0].label).toBe('Compound A')
    expect(getBioTemplateControlSchema('cell-culture-screen')?.sampleSheetSampleCount.default).toBe(2)
    expect(getBioTemplateComponentBindings('cell-culture-screen').map(binding => binding.component)).toContain('DoseCalculator')
    expect(() => createBioTemplatePackCollection('missing-pack')).toThrow("Unknown template pack 'missing-pack'.")
  })

  it('exposes discoverable template collection presets', () => {
    const presets = listBioTemplatePresets()

    expect(presets.map(entry => entry.name)).toEqual([
      'wellplate-screen',
      'qpcr-expression',
      'lcms-batch',
      'targeted-metabolomics',
      'elisa-assay',
      'flow-cytometry-assay',
      'western-blot-assay',
    ])
    expect(getBioTemplatePresetInfo('wellplate')?.name).toBe('wellplate-screen')
    expect(getBioTemplatePresetInfo('dose planner')?.name).toBe('wellplate-screen')
    expect(getBioTemplatePresetInfo('dose-planner')?.name).toBe('wellplate-screen')
    expect(getBioTemplatePresetInfo('gene expression')?.templates).toEqual([
      'sample-sheet',
      'qpcr-plate',
    ])
    expect(searchBioTemplatePresets('run queue')[0].name).toBe('lcms-batch')
    expect(getBioTemplatePresetInfo('metabolomics')?.name).toBe('lcms-batch')
    expect(getBioTemplatePresetInfo('metabolism')?.name).toBe('lcms-batch')
    expect(getBioTemplatePresetInfo('metabolite profiling')?.name).toBe('lcms-batch')
    expect(getBioTemplatePresetInfo('targeted metabolomics')?.name).toBe('targeted-metabolomics')
    expect(searchBioTemplatePresets('internal standards')[0].name).toBe('targeted-metabolomics')
    expect(getBioTemplatePresetInfo('immunoassay')?.templates).toEqual([
      'plate-map',
      'sample-sheet',
      'calibration-curve',
      'assay-matrix',
    ])
    expect(getBioTemplatePresetInfo('facs')?.templates).toEqual([
      'sample-sheet',
      'flow-cytometry-panel',
      'assay-matrix',
    ])
    expect(getBioTemplatePresetInfo('immunoblot')?.templates).toEqual([
      'sample-sheet',
      'reagent-list',
      'protocol-steps',
      'assay-matrix',
    ])
  })

  it('matches the shared Python/frontend preset contract', () => {
    expect(listBioTemplatePresets()).toEqual(bioTemplatePresetsContract)
  })

  it('should not recommend AutoGroupModal when it is scheduled for removal', () => {
    const components = listBioTemplateCatalog().flatMap(entry => entry.components)

    expect(components).not.toContain('AutoGroupModal')
  })

  it('prefers generic dataframe adapters in catalog entries', () => {
    const dataframeTemplates = listBioTemplateCatalog().filter(entry =>
      entry.components.includes('DataFrame')
    )

    expect(dataframeTemplates.map(entry => entry.name)).toEqual([
      'sample-sheet',
      'sample-prep',
      'calibration-curve',
      'time-course',
      'protocol-steps',
      'assay-matrix',
      'reagent-list',
      'flow-cytometry-panel',
      'instrument-run',
      'qpcr-plate',
    ])
    for (const entry of dataframeTemplates) {
      expect(entry.frontend_adapters[0]).toBe('toTemplateDataFrame')
      expect(entry.frontend_import).toContain('toTemplateDataFrame')
    }
  })

  it('exposes control schemas for built-in templates and presets', () => {
    const schemas = listBioTemplateControlSchemas()
    const plateSchema = getBioTemplateControlSchema('wellplate')
    const presetSchema = getBioTemplateControlSchema('wellplate-screen')
    const defaults = getBioTemplateControlDefaults('lcms-batch')
    const targetedDefaults = getBioTemplateControlDefaults('targeted-metabolomics')
    const elisaDefaults = getBioTemplateControlDefaults('elisa-assay')
    const flowDefaults = getBioTemplateControlDefaults('flow-cytometry-assay')
    const westernDefaults = getBioTemplateControlDefaults('western-blot-assay')

    expect(Object.keys(schemas)).toContain('plate-map')
    expect(plateSchema?.plateFormat.default).toBe(96)
    expect(presetSchema?.replicates.default).toBe(3)
    expect(defaults.instrument).toBe('LC-MS')
    expect(defaults.featureNames).toEqual(['Glucose', 'Lactate'])
    expect(targetedDefaults.metaboliteNames).toEqual(['Glucose', 'Lactate', 'Pyruvate'])
    expect(targetedDefaults.internalStandards).toEqual(['Stable isotope internal standard mix'])
    expect(targetedDefaults.method).toBe('Targeted metabolomics')
    expect(elisaDefaults.analyte).toBe('Analyte')
    expect(elisaDefaults.standardConcentrations).toEqual(['1000', '100', '10', '1'])
    expect(flowDefaults.markers).toEqual(['CD3', 'CD4', 'CD8'])
    expect(flowDefaults.includeDefaultControls).toBe(true)
    expect(westernDefaults.targets).toEqual(['Target protein'])
    expect(westernDefaults.loadingControl).toBe('ACTB')
  })

  it('exposes component bindings for template-driven frontend rendering', () => {
    const bindings = listBioTemplateComponentBindings()
    const wellplateBindings = getBioTemplateComponentBindings('wellplate-screen')
    const qpcrBindings = getBioTemplateComponentBindings('gene expression')
    const elisaBindings = getBioTemplateComponentBindings('elisa-assay')
    const flowBindings = getBioTemplateComponentBindings('flow-cytometry-assay')
    const lcmsBindings = getBioTemplateComponentBindings('lcms-batch')
    const targetedBindings = getBioTemplateComponentBindings('targeted-metabolomics')
    const westernBindings = getBioTemplateComponentBindings('western-blot-assay')
    const wellplateImports = toBioTemplateComponentImports('wellplate-screen')

    expect(bindings['plate-map'].map(binding => binding.component)).toEqual(['PlateEditor', 'WellPlate'])
    expect(wellplateBindings.map(binding => binding.component)).toContain('DoseCalculator')
    expect(wellplateBindings.map(binding => binding.component)).toContain('WellPlate')
    expect(qpcrBindings.map(binding => binding.component)).toContain('WellPlate')
    expect(qpcrBindings.map(binding => binding.component)).toContain('DataFrame')
    expect(elisaBindings.map(binding => binding.component)).toContain('PlateEditor')
    expect(elisaBindings.map(binding => binding.component)).toContain('DataFrame')
    expect(lcmsBindings.map(binding => binding.component)).toContain('ScheduleCalendar')
    expect(lcmsBindings.map(binding => binding.component)).toContain('ExperimentTimeline')
    expect(targetedBindings.map(binding => binding.component)).toContain('ReagentList')
    expect(targetedBindings.map(binding => binding.component)).toContain('DataFrame')
    expect(targetedBindings.map(binding => binding.component)).toContain('ScheduleCalendar')
    expect(flowBindings.map(binding => binding.template_id)).toEqual([
      'sample-sheet',
      'sample-sheet',
      'flow-cytometry-panel',
      'assay-matrix',
      'assay-matrix',
    ])
    expect(westernBindings.map(binding => binding.component)).toContain('ReagentList')
    expect(westernBindings.map(binding => binding.component)).toContain('ExperimentTimeline')
    expect(wellplateImports).toEqual([
      {
        importPath: '@morscherlab/mint-sdk',
        components: ['PlateEditor', 'WellPlate', 'DataFrame', 'SampleSelector', 'DoseCalculator'],
        statement: "import { PlateEditor, WellPlate, DataFrame, SampleSelector, DoseCalculator } from '@morscherlab/mint-sdk'",
      },
    ])
  })

  it('creates plate-map envelopes and adapts them to plate editor state', () => {
    const template = createPlateMapTemplate({
      name: 'Drug screen plate',
      samples: ['DMSO', 'Drug A'],
    })
    const state = toPlateMapEditorState(template)

    expect(template.template_id).toBe('plate-map')
    expect(state.activePlateId).toBe('plate-1')
    expect(state.plates[0].format).toBe(96)
    expect(state.samples[1].id).toBe('drug-a')
  })

  it('should convert plate-map state into PlateEditor racks', () => {
    const state = toPlateMapEditorState(createPlateMapTemplate({ samples: ['DMSO'] }))

    expect(racksFromPlateState(state)[0]).toMatchObject({ id: 'plate-1', format: 96, slot: 'R' })
  })

  it('loads the shared plate-map fixture', () => {
    const state = toPlateMapEditorState(plateMapFixture as PlateMapTemplate)
    const wells = toWellPlateWells(plateMapFixture as PlateMapTemplate)
    const componentProps = toBioTemplateComponentProps(plateMapFixture as PlateMapTemplate)
    const componentBindings = toBioTemplateComponentBindings(plateMapFixture as PlateMapTemplate)
    const componentPropsById = toBioTemplateComponentPropsById(plateMapFixture as PlateMapTemplate)
    const componentBindingsById = toBioTemplateComponentBindingsById(plateMapFixture as PlateMapTemplate)
    const wellPlate = componentProps.find(binding => binding.component === 'WellPlate')
    const wellPlateBinding = componentBindings.find(binding => binding.component === 'WellPlate')

    expect(state.plates[0].name).toBe('Drug screen plate')
    expect(wells.A2.sampleType).toBe('drug-a')
    expect(wellPlate?.propsObject.format).toBe(96)
    expect((wellPlate?.propsObject.wells as Record<string, { sampleType?: string }>).A2.sampleType).toBe('drug-a')
    expect(wellPlateBinding?.props.format).toBe(96)
    expect(wellPlateBinding?.propNames).toContain('wells')
    expect(componentPropsById['plate-map:WellPlate']).toEqual(wellPlate?.propsObject)
    expect(componentBindingsById['plate-map:WellPlate'].component).toBe('WellPlate')
    expect(componentBindingsById['plate-map:WellPlate'].props).toEqual(wellPlate?.propsObject)
    expect((componentPropsById['plate-map:WellPlate'].wells as Record<string, { sampleType?: string }>).A2.sampleType).toBe('drug-a')
  })

  it('returns component props keyed by stable template component id', () => {
    const collection = createWellPlateScreenCollection({
      samples: ['Control', 'Treatment'],
      compounds: { 'Drug A': [10, 1] },
    })
    const propsById = toBioTemplateComponentPropsById(collection)
    const bindingsById = toBioTemplateComponentBindingsById(collection)
    const propsByComponent = toBioTemplateComponentPropsByComponent(collection)
    const doseCalculatorProps = getBioTemplateComponentProps(collection, 'DoseCalculator')
    const doseWellPlateProps = getBioTemplateComponentProps(collection, 'WellPlate', {
      templateId: 'dose-response',
    })

    expect(Object.keys(propsById)).toEqual([
      'plate-map:PlateEditor',
      'plate-map:WellPlate',
      'sample-sheet:DataFrame',
      'sample-sheet:SampleSelector',
      'dose-response:DoseCalculator',
      'dose-response:WellPlate',
    ])
    expect(propsById['dose-response:DoseCalculator'].mode).toBe('serial')
    expect(bindingsById['dose-response:DoseCalculator'].props.mode).toBe('serial')
    expect(bindingsById['dose-response:DoseCalculator'].propNames).toContain('mode')
    expect(propsById['plate-map:WellPlate'].wells).toBeDefined()
    expect(propsById['dose-response:WellPlate'].wells).toBeDefined()
    expect(propsByComponent.WellPlate).toHaveLength(2)
    expect(propsByComponent.DoseCalculator[0].mode).toBe('serial')
    expect(doseCalculatorProps?.mode).toBe('serial')
    expect(doseWellPlateProps?.wells).toBeDefined()
    expect(getBioTemplateComponentProps(collection, 'MissingWidget')).toBeUndefined()
  })

  it('creates ELISA assay preset collections with plate, standards, and readout matrix', () => {
    const collection = createElisaAssayCollection({
      samples: ['Control', 'Treatment'],
      analyte: 'IL-6',
      standardConcentrations: [1000, 100, 10, 1],
      unit: 'pg/mL',
    })
    const templates = extractTemplateCollection(collection)
    const componentPropsById = toBioTemplateComponentPropsById(collection)

    expect(Object.keys(templates)).toEqual([
      'plate-map',
      'sample-sheet',
      'calibration-curve',
      'assay-matrix',
    ])
    expect(collection.metadata?.preset).toBe('elisa-assay')
    expect(templates['calibration-curve'].data).toMatchObject({
      analyte: 'IL-6',
      model: 'four-parameter-logistic',
      xUnit: 'pg/mL',
      responseUnit: 'OD450',
    })
    expect(templates['assay-matrix'].data).toMatchObject({
      features: [{ id: 'il-6', name: 'IL-6', type: 'protein', unit: 'OD450', metadata: {} }],
    })
    expect(componentPropsById['plate-map:WellPlate'].wells).toBeDefined()
    expect(componentPropsById['calibration-curve:DataFrame'].data).toBeDefined()
    expect(componentPropsById['assay-matrix:DataFrame'].columns).toBeDefined()
    expect(componentPropsById['assay-matrix:SampleSelector'].samples).toEqual(['Control', 'Treatment'])
  })

  it('generates Vue snippets for concrete template component props', () => {
    const snippets = toBioTemplateComponentSnippets(plateMapFixture as PlateMapTemplate, {
      propsVariable: 'bindings',
    })

    expect(snippets.map(snippet => snippet.component)).toEqual(['PlateEditor', 'WellPlate'])
    expect(snippets.map(snippet => snippet.propsName)).toEqual([
      'plateMapPlateEditorProps',
      'plateMapWellPlateProps',
    ])
    expect(snippets[0].propsExpression).toBe('bindings[0].propsObject')
    expect(snippets[0].template).toBe('<PlateEditor v-bind="bindings[0].propsObject" />')
    expect(snippets[1].template).toBe('<WellPlate v-bind="bindings[1].propsObject" />')
  })

  it('generates a Vue usage bundle for concrete template component props', () => {
    const usage = toBioTemplateComponentUsage(plateMapFixture as PlateMapTemplate, {
      propsVariable: 'bindings',
      targetExpression: 'plateMap',
    })

    expect(usage.imports[0].statement).toBe(
      "import { PlateEditor, WellPlate } from '@morscherlab/mint-sdk'"
    )
    expect(usage.componentProps).toHaveLength(2)
    expect(usage.propsDeclarations).toEqual([
      'const plateMapPlateEditorProps = bindings[0].propsObject',
      'const plateMapWellPlateProps = bindings[1].propsObject',
    ])
    expect(usage.scriptSetup).toBe([
      'const bindings = toBioTemplateComponentProps(plateMap)',
      'const plateMapPlateEditorProps = bindings[0].propsObject',
      'const plateMapWellPlateProps = bindings[1].propsObject',
    ].join('\n'))
    expect(usage.template).toBe([
      '<PlateEditor v-bind="plateMapPlateEditorProps" />',
      '<WellPlate v-bind="plateMapWellPlateProps" />',
    ].join('\n'))
  })

  it('generates a complete Vue SFC for concrete template component props', () => {
    const usage = toBioTemplateComponentUsage(plateMapFixture as PlateMapTemplate)

    expect(usage.scriptSetup).toContain(
      'const props = defineProps<{ templateCollection: BioTemplateEnvelope<unknown> | TemplateCollectionEnvelope }>()'
    )
    expect(usage.sfc).toContain("import { PlateEditor, WellPlate } from '@morscherlab/mint-sdk'")
    expect(usage.sfc).toContain("import { toBioTemplateComponentProps } from '@morscherlab/mint-sdk/templates'")
    expect(usage.sfc).toContain('defineProps<{ templateCollection: BioTemplateEnvelope<unknown> | TemplateCollectionEnvelope }>()')
    expect(usage.sfc).toContain('<PlateEditor v-bind="plateMapPlateEditorProps" />')
    expect(usage.sfc).toContain('<WellPlate v-bind="plateMapWellPlateProps" />')
    expect(usage.sfc).toMatch(/^<script setup lang="ts">[\s\S]*<\/template>$/)
  })

  it('rejects mismatched template envelopes', () => {
    expect(() => assertTemplateEnvelope(plateMapFixture, 'sample-sheet')).toThrow(
      "Expected template_id 'sample-sheet'"
    )
  })

  it('returns validated typed template envelopes', () => {
    const template = ensureTemplateEnvelope<PlateMapTemplate>(plateMapFixture, 'plate-map')

    expect(template.data.plates[0].id).toBe('plate-1')
    expect(() => ensureTemplateEnvelope<SampleSheetTemplate>(plateMapFixture, 'sample-sheet')).toThrow(
      "Expected template_id 'sample-sheet'"
    )
  })

  it('builds and reads template collections', () => {
    const plate = createPlateMapTemplate({
      name: 'Drug screen plate',
      samples: ['DMSO', 'Drug A'],
    })
    const sampleSheet = createSampleSheetTemplate({
      samples: [
        { sampleId: 'S001', name: 'Control 1', group: 'Control' },
      ],
    })
    const collection = createTemplateCollection([plate, sampleSheet], { source: 'unit-test' })
    const extracted = extractTemplateCollection(collection)
    const typedPlate = ensureTemplateFromCollection<PlateMapTemplate>(collection, 'plate-map')

    expect(Object.keys(collection[TEMPLATE_COLLECTION_KEY])).toEqual(['plate-map', 'sample-sheet'])
    expect(collection.metadata?.source).toBe('unit-test')
    expect(extracted['sample-sheet'].template_id).toBe('sample-sheet')
    expect(typedPlate.data.plates[0].name).toBe('Drug screen plate')
    expect(extractTemplateCollection(plate)['plate-map'].template_id).toBe('plate-map')
    expect(() => ensureTemplateFromCollection<SampleSheetTemplate>(collection, 'sample-prep')).toThrow(
      "Template 'sample-prep' was not found"
    )
    expect(() => extractTemplateCollection({ templates: { 'sample-sheet': plate } })).toThrow(
      'does not match envelope template_id'
    )
    expect(() => createTemplateCollection([plate, plate])).toThrow('Duplicate template_id')
  })

  it('creates ready-to-save template preset collections', () => {
    const wellplate = createWellPlateScreenCollection({
      samples: ['Control', 'Treatment'],
      compounds: { 'Drug A': [10, 1, 0.1] },
      unit: 'uM',
    })
    const qpcr = createQpcrExpressionCollection({
      samples: [{ sampleId: 'S001', name: 'Control', group: 'Control' }],
      targets: ['ACTB'],
    })
    const lcms = createLcmsBatchCollection({
      samples: ['S001', 'S002'],
      features: ['Glucose'],
      instrument: 'LC-MS',
    })
    const targeted = createTargetedMetabolomicsCollection({
      samples: ['S001', 'S002'],
      metabolites: ['Glucose', 'Lactate'],
      internalStandards: ['13C Glucose'],
      standardConcentrations: [0.1, 1, 10],
      instrument: 'Orbitrap',
    })
    const flow = createFlowCytometryAssayCollection({
      samples: ['Control', 'Treatment'],
      markers: ['CD3', 'CD4'],
      instrument: 'BD LSRFortessa',
    })
    const western = createWesternBlotAssayCollection({
      samples: ['Control', 'Treatment'],
      targets: ['pERK', 'ERK'],
      loadingControl: 'ACTB',
    })

    const wellplateTemplates = extractTemplateCollection(wellplate)
    const qpcrTemplates = extractTemplateCollection(qpcr)
    const lcmsTemplates = extractTemplateCollection(lcms)
    const targetedTemplates = extractTemplateCollection(targeted)
    const flowTemplates = extractTemplateCollection(flow)
    const westernTemplates = extractTemplateCollection(western)
    const wellplateComponentProps = toBioTemplateComponentProps(wellplate)

    expect(Object.keys(wellplateTemplates)).toEqual(['plate-map', 'sample-sheet', 'dose-response'])
    expect(wellplate.metadata?.preset).toBe('wellplate-screen')
    expect(toPlateMapEditorState(wellplateTemplates['plate-map'] as PlateMapTemplate).samples[1].id).toBe('treatment')
    expect(toDoseConditions(wellplateTemplates['dose-response'] as DoseResponseTemplate)[0].label).toBe('Drug A')
    expect(wellplateComponentProps.map(binding => binding.component)).toContain('PlateEditor')
    expect(wellplateComponentProps.map(binding => binding.component)).toContain('DoseCalculator')
    expect(Object.keys(qpcrTemplates)).toEqual(['sample-sheet', 'qpcr-plate'])
    expect(toQpcrRows(qpcrTemplates['qpcr-plate'] as QpcrPlateTemplate)[0].sampleId).toBe('S001')
    expect(Object.keys(lcmsTemplates)).toEqual(['sample-sheet', 'instrument-run', 'assay-matrix'])
    expect(toInstrumentRunRows(lcmsTemplates['instrument-run'] as InstrumentRunTemplate)[0].kind).toBe('blank')
    expect(toInstrumentRunRows(lcmsTemplates['instrument-run'] as InstrumentRunTemplate)[2].sampleId).toBe('s001')
    expect(toTemplateDataFrame(lcmsTemplates['assay-matrix']).columns.map(column => column.key)).toContain('glucose')
    expect(toAssayMatrixSampleOptions(lcmsTemplates['assay-matrix'] as AssayMatrixTemplate).map(option => option.label)).toEqual(['S001', 'S002'])
    expect(Object.keys(targetedTemplates)).toEqual([
      'sample-sheet',
      'sample-prep',
      'reagent-list',
      'instrument-run',
      'calibration-curve',
      'assay-matrix',
    ])
    expect(targeted.metadata?.preset).toBe('targeted-metabolomics')
    expect(toReagentDataFrame(targetedTemplates['reagent-list'] as ReagentListTemplate).data[0].kind).toBe('compound')
    expect(toTemplateDataFrame(targetedTemplates['calibration-curve']).data[0].role).toBe('blank')
    expect(toInstrumentRunRows(targetedTemplates['instrument-run'] as InstrumentRunTemplate).map(row => row.kind)).toEqual([
      'blank',
      'standard',
      'standard',
      'standard',
      'qc',
      'qc',
      'sample',
      'sample',
    ])
    expect(toTemplateDataFrame(targetedTemplates['assay-matrix']).columns.map(column => column.key)).toContain('lactate')
    expect(Object.keys(flowTemplates)).toEqual(['sample-sheet', 'flow-cytometry-panel', 'assay-matrix'])
    expect(flow.metadata?.preset).toBe('flow-cytometry-assay')
    expect(flowTemplates['flow-cytometry-panel'].data).toMatchObject({
      instrument: 'BD LSRFortessa',
      markers: [
        { id: 'cd3', marker: 'CD3' },
        { id: 'cd4', marker: 'CD4' },
      ],
    })
    expect(toTemplateDataFrame(flowTemplates['assay-matrix']).columns.map(column => column.key)).toContain('cd4')
    expect(Object.keys(westernTemplates)).toEqual(['sample-sheet', 'reagent-list', 'protocol-steps', 'assay-matrix'])
    expect(western.metadata?.preset).toBe('western-blot-assay')
    expect(toReagentDataFrame(westernTemplates['reagent-list'] as ReagentListTemplate).data[0].kind).toBe('antibody')
    expect(toProtocolDataFrame(westernTemplates['protocol-steps'] as ProtocolStepsTemplate).data[2].name).toBe('Transfer to membrane')
    expect(toTemplateDataFrame(westernTemplates['assay-matrix']).columns.map(column => column.key)).toContain('actb')

    const aliasCollection = createBioTemplatePresetCollection('wellplate', {
      samples: ['Control', 'Treatment'],
      compounds: { 'Drug A': [10, 1] },
    })
    expect(aliasCollection.metadata?.preset).toBe('wellplate-screen')
    expect(Object.keys(extractTemplateCollection(aliasCollection))).toEqual(['plate-map', 'sample-sheet', 'dose-response'])
    expect(createBioTemplatePresetCollection('facs').metadata?.preset).toBe('flow-cytometry-assay')
    expect(createBioTemplatePresetCollection('immunoblot').metadata?.preset).toBe('western-blot-assay')
    expect(createBioTemplatePresetCollection('targeted metabolomics').metadata?.preset).toBe('targeted-metabolomics')
    expect(() => createBioTemplatePresetCollection('unknown-preset')).toThrow("Unknown template preset 'unknown-preset'.")
  })

  it('maps preset control values into template collection previews', () => {
    const wellplateOptions = bioTemplatePresetControlValuesToOptions('wellplate-screen', {
      sampleNames: 'Vehicle, Drug A, Drug B',
      plateName: 'Custom screen',
      plateFormat: '384',
      unit: 'nM',
      replicates: '2',
    })
    const wellplate = createBioTemplatePresetCollectionFromControls('wellplate-screen', {
      sampleNames: 'Vehicle, Drug A, Drug B',
      plateName: 'Custom screen',
      plateFormat: '384',
      unit: 'nM',
      replicates: '2',
    })
    const wellplateTemplates = extractTemplateCollection(wellplate)
    const plate = wellplateTemplates['plate-map'] as PlateMapTemplate
    const dose = wellplateTemplates['dose-response'] as DoseResponseTemplate

    expect(wellplateOptions.samples).toEqual(['Vehicle', 'Drug A', 'Drug B'])
    expect(wellplateOptions.plateFormat).toBe(384)
    expect(wellplateOptions.replicates).toBe(2)
    expect(plate.data.plates[0].name).toBe('Custom screen')
    expect(plate.data.plates[0].format).toBe(384)
    expect(plate.data.samples.map(sample => sample.id)).toEqual(['vehicle', 'drug-a', 'drug-b'])
    expect(dose.data.unit).toBe('nM')
    expect(dose.data.replicates).toBe(2)

    const qpcrOptions = bioTemplatePresetControlValuesToOptions('qpcr-expression', {
      sampleNames: ['Control', 'Knockdown'],
      targets: 'ACTB, MYC',
      chemistry: 'taqman',
      plateFormat: 384,
      includeNoTemplateControls: false,
      replicates: 2,
      instrument: 'QuantStudio',
    })
    const qpcr = ensureTemplateFromCollection<QpcrPlateTemplate>(
      createBioTemplatePresetCollectionFromControls('qpcr-expression', {
        sampleNames: ['Control', 'Knockdown'],
        targets: 'ACTB, MYC',
        chemistry: 'taqman',
        plateFormat: 384,
        includeNoTemplateControls: false,
        replicates: 2,
        instrument: 'QuantStudio',
      }),
      'qpcr-plate',
    )

    expect(qpcrOptions.targets).toEqual(['ACTB', 'MYC'])
    expect(qpcrOptions.includeNoTemplateControls).toBe(false)
    expect(qpcr.data.chemistry).toBe('taqman')
    expect(qpcr.data.format).toBe(384)
    expect(qpcr.data.instrument).toBe('QuantStudio')
    expect(qpcr.data.reactions).toHaveLength(8)
    expect(qpcr.data.reactions.some(reaction => reaction.controlKind === 'no-template')).toBe(false)

    const lcmsOptions = bioTemplatePresetControlValuesToOptions('lcms-batch', {
      sampleNames: 'S001, S002',
      featureNames: 'Glucose, Pyruvate',
      instrument: 'Orbitrap',
      method: 'Polar metabolites',
      includeQc: false,
    })
    const lcmsTemplates = extractTemplateCollection(
      createBioTemplatePresetCollectionFromControls('lcms-batch', {
        sampleNames: 'S001, S002',
        featureNames: 'Glucose, Pyruvate',
        instrument: 'Orbitrap',
        method: 'Polar metabolites',
        includeQc: false,
      }),
    )
    const run = lcmsTemplates['instrument-run'] as InstrumentRunTemplate

    expect(lcmsOptions.features).toEqual(['Glucose', 'Pyruvate'])
    expect(lcmsOptions.includeQc).toBe(false)
    expect(run.data.instrument).toBe('Orbitrap')
    expect(run.data.methods[0].name).toBe('Polar metabolites')
    expect(run.data.items.map(item => item.kind)).toEqual(['blank', 'sample', 'sample'])
    expect(toTemplateDataFrame(lcmsTemplates['assay-matrix']).columns.map(column => column.key)).toContain('pyruvate')

    const targetedOptions = bioTemplatePresetControlValuesToOptions('targeted-metabolomics', {
      sampleNames: 'QC Pool, Patient A',
      metaboliteNames: 'Glucose, Citrate',
      internalStandards: '13C Glucose',
      standardConcentrations: '0.5, 5, 50',
      concentrationUnit: 'nM',
      responseUnit: 'area ratio',
      instrument: 'Triple quadrupole',
      method: 'MRM panel',
      outputVolume: '25',
      includeQc: false,
    })
    const targetedTemplates = extractTemplateCollection(
      createBioTemplatePresetCollectionFromControls('targeted-metabolomics', {
        sampleNames: 'QC Pool, Patient A',
        metaboliteNames: 'Glucose, Citrate',
        internalStandards: '13C Glucose',
        standardConcentrations: '0.5, 5, 50',
        concentrationUnit: 'nM',
        responseUnit: 'area ratio',
        instrument: 'Triple quadrupole',
        method: 'MRM panel',
        outputVolume: '25',
        includeQc: false,
      }),
    )
    const targetedRun = targetedTemplates['instrument-run'] as InstrumentRunTemplate

    expect(targetedOptions.metabolites).toEqual(['Glucose', 'Citrate'])
    expect(targetedOptions.standardConcentrations).toEqual([0.5, 5, 50])
    expect(targetedOptions.outputVolume).toBe(25)
    expect(targetedRun.data.instrument).toBe('Triple quadrupole')
    expect(targetedRun.data.methods[0].name).toBe('MRM panel')
    expect(targetedRun.data.items.map(item => item.kind)).toEqual([
      'blank',
      'standard',
      'standard',
      'standard',
      'sample',
      'sample',
    ])
    expect(toTemplateDataFrame(targetedTemplates['assay-matrix']).columns.map(column => column.key)).toContain('citrate')

    const flowOptions = bioTemplatePresetControlValuesToOptions('flow-cytometry-assay', {
      sampleNames: 'Control, Treatment',
      markers: 'CD3, CD19',
      featureNames: 'T cells, B cells',
      instrument: 'Cytek Aurora',
      includeDefaultControls: false,
    })
    const flowTemplates = extractTemplateCollection(
      createBioTemplatePresetCollectionFromControls('flow-cytometry-assay', {
        sampleNames: 'Control, Treatment',
        markers: 'CD3, CD19',
        featureNames: 'T cells, B cells',
        instrument: 'Cytek Aurora',
        includeDefaultControls: false,
      }),
    )
    const flowPanel = flowTemplates['flow-cytometry-panel'] as FlowCytometryPanelTemplate

    expect(flowOptions.markers).toEqual(['CD3', 'CD19'])
    expect(flowOptions.features).toEqual(['T cells', 'B cells'])
    expect(flowPanel.data.instrument).toBe('Cytek Aurora')
    expect(flowPanel.data.controls).toEqual([])
    expect(toTemplateDataFrame(flowTemplates['assay-matrix']).columns.map(column => column.key)).toContain('b-cells')

    const westernOptions = bioTemplatePresetControlValuesToOptions('western-blot-assay', {
      sampleNames: 'Control, Treatment',
      targets: 'pERK, ERK',
      loadingControl: 'ACTB',
    })
    const westernTemplates = extractTemplateCollection(
      createBioTemplatePresetCollectionFromControls('western-blot-assay', {
        sampleNames: 'Control, Treatment',
        targets: 'pERK, ERK',
        loadingControl: 'ACTB',
      }),
    )

    expect(westernOptions.targets).toEqual(['pERK', 'ERK'])
    expect(westernOptions.loadingControl).toBe('ACTB')
    expect(toProtocolSteps(westernTemplates['protocol-steps'] as ProtocolStepsTemplate).map(step => step.name)).toContain('Run SDS-PAGE')
    expect(toTemplateDataFrame(westernTemplates['assay-matrix']).columns.map(column => column.key)).toContain('actb')
  })

  it('creates sample-sheet templates and adapts rows, columns, and options', () => {
    const template = createSampleSheetTemplate({
      samples: [
        {
          sampleId: 'S001',
          name: 'Control 1',
          group: 'Control',
          metadata: { cell_line: 'HCT116' },
        },
        {
          sampleId: 'S002',
          name: 'Control 2',
          group: 'Control',
        },
      ],
      columns: [
        { id: 'sampleId', label: 'Sample ID', type: 'string', required: true, groupable: false },
        { id: 'cell_line', label: 'Cell Line', type: 'string', required: false, groupable: true },
      ],
    })

    expect(toSampleRows(template)[0].cell_line).toBe('HCT116')
    expect(template.data.samples[1].metadata).toEqual({})
    expect(toSampleColumns(template)[0].key).toBe('sampleId')
    expect(toSampleColumns(template)[1].key).toBe('cell_line')
    const sampleFrame = toSampleDataFrame(template)
    expect(sampleFrame.rowKey).toBe('sampleId')
    expect(sampleFrame.data[0].cell_line).toBe('HCT116')
    expect(sampleFrame.columns.map(column => column.key)).toEqual(['sampleId', 'cell_line'])
    expect(toTemplateDataFrame(template).rowKey).toBe('sampleId')
    expect(toSampleOptions(template)[0].label).toBe('Control 1')
  })

  it('loads the shared sample-sheet fixture', () => {
    const rows = toSampleRows(sampleSheetFixture as SampleSheetTemplate)
    const columns = toSampleColumns(sampleSheetFixture as SampleSheetTemplate)
    const options = toSampleOptions(sampleSheetFixture as SampleSheetTemplate)

    expect(rows[1].group).toBe('Drug A')
    expect(columns[0].key).toBe('sampleId')
    expect(options[0].value).toBe('S001')
  })

  it('creates sample-prep templates and adapts prep steps', () => {
    const template = createSamplePrepTemplate({
      samples: ['S001', { name: 'Dilute S002', sourceSampleId: 'S002', type: 'dilution' }],
      prepType: 'extraction',
      outputVolume: 50,
    })
    const rows = toSamplePrepRows(template)
    const frame = toSamplePrepDataFrame(template)

    expect(template.template_id).toBe('sample-prep')
    expect(rows[0].sourceSampleId).toBe('s001')
    expect(rows[0].destinationSampleId).toBe('s001-prepared')
    expect(rows[0].outputVolume).toBe(50)
    expect(rows[1].id).toBe('dilute-s002')
    expect(frame.rowKey).toBe('id')
    expect(frame.columns.map(column => column.key)).toContain('status')
    expect(toTemplateDataFrame(template).data[1].type).toBe('dilution')
  })

  it('creates dose-response templates and adapts dose conditions', () => {
    const template = createDoseResponseTemplate({
      compounds: { 'Drug A': [0.1, 10, 1] },
      unit: 'uM',
      replicates: 2,
    })
    const conditions = toDoseConditions(template)

    expect(template.template_id).toBe('dose-response')
    expect(template.data.compounds[0].concentrations).toEqual([10, 1, 0.1])
    expect(conditions[0].unit).toBe('uM')
    expect(conditions[0].concentrations).toEqual([10, 1, 0.1])
  })

  it('defaults metadata for explicit template records', () => {
    const samplePrep = createSamplePrepTemplate({
      samples: [{ name: 'Extract S001', sourceSampleId: 'S001' }],
    })
    const doseResponse = createDoseResponseTemplate({
      compounds: [{ id: 'drug-a', name: 'Drug A', concentrations: [1, 0.1] }],
      unit: 'uM',
      controls: [{ id: 'vehicle', name: 'DMSO', role: 'vehicle' }],
    })
    const timeCourse = createTimeCourseTemplate({
      timepoints: [{ id: 't0-hour', label: '0 hour', value: 0, unit: 'hour' }],
      unit: 'hour',
      conditions: [{ id: 'control', name: 'Control' }],
    })
    const assayMatrix = createAssayMatrixTemplate({
      samples: [{ sampleId: 'S001', name: 'Control 1' }],
      features: [{ id: 'lactate', name: 'Lactate', type: 'metabolite' }],
    })

    expect(samplePrep.data.steps[0].metadata).toEqual({})
    expect(doseResponse.data.compounds[0].metadata).toEqual({})
    expect(doseResponse.data.controls[0].metadata).toEqual({})
    expect(timeCourse.data.timepoints[0].metadata).toEqual({})
    expect(timeCourse.data.conditions[0].metadata).toEqual({})
    expect(assayMatrix.data.samples[0].metadata).toEqual({})
    expect(assayMatrix.data.features[0].metadata).toEqual({})
    expect(toDoseConditions(doseResponse)[0].color).toBe('#3B82F6')
    expect(toTimeCourseRows(timeCourse)[0].sampleId).toBe('control-t0-hour-r1')
    expect(toAssayMatrixRows(assayMatrix)[0].sampleId).toBe('S001')
  })

  it('loads the shared dose-response fixture with layout', () => {
    const conditions = toDoseConditions(doseResponseFixture as DoseResponseTemplate)
    const layout = toDoseLayoutState(doseResponseFixture as DoseResponseTemplate)
    const componentProps = toBioTemplateComponentProps(doseResponseFixture as DoseResponseTemplate)
    const doseCalculator = componentProps.find(binding => binding.component === 'DoseCalculator')
    const wellPlate = componentProps.find(binding => binding.component === 'WellPlate')

    expect(conditions[0].label).toBe('Drug A')
    expect(layout?.plates[0].wells.A2.value).toBe(10)
    expect(doseCalculator?.propsObject.mode).toBe('serial')
    expect((doseCalculator?.propsObject.targetWells as string[])).toContain('A2')
    expect((wellPlate?.propsObject.wells as Record<string, { value?: number }>).A2.value).toBe(10)
  })

  it('rejects invalid dose-response data', () => {
    expect(() => createDoseResponseTemplate({
      compounds: { 'Drug A': [-1] },
      unit: 'uM',
    })).toThrow('negative concentration')
  })

  it('creates calibration-curve templates and adapts standard curves', () => {
    const template = createCalibrationCurveTemplate({
      concentrations: [0.1, { level: 'Standard 2', concentration: 1 }, 10],
      analyte: 'Glucose',
      unit: 'uM',
    })
    const rows = toCalibrationCurveRows(template)
    const frame = toCalibrationCurveDataFrame(template)

    expect(template.template_id).toBe('calibration-curve')
    expect(template.data.points.map(point => point.role)).toEqual([
      'blank',
      'standard',
      'standard',
      'standard',
      'qc',
      'qc',
    ])
    expect(rows[2].id).toBe('standard-2')
    expect(rows[2].analyte).toBe('Glucose')
    expect(frame.rowKey).toBe('id')
    expect(frame.columns.map(column => column.key)).toContain('status')
    expect(toTemplateDataFrame(template).data[0].role).toBe('blank')
  })

  it('creates time-course templates and adapts samples and steps', () => {
    const template = createTimeCourseTemplate({
      timepoints: [24, 0, 6],
      unit: 'hour',
      conditions: ['Control', 'Treatment'],
      replicates: 2,
    })
    const rows = toTimeCourseRows(template)
    const steps = toTimeCourseSteps(template)

    expect(template.template_id).toBe('time-course')
    expect(template.data.timepoints.map(timepoint => timepoint.id)).toEqual(['t0-hour', 't6-hour', 't24-hour'])
    expect(rows).toHaveLength(12)
    expect(toTimeCourseDataFrame(template).columns[0].key).toBe('sampleId')
    expect(toTemplateDataFrame(template).data).toHaveLength(12)
    expect(steps[0].type).toBe('measurement')
  })

  it('creates protocol-step templates and adapts timeline and dataframe props', () => {
    const template = createProtocolStepsTemplate({
      steps: [
        {
          name: 'Measure readout',
          type: 'measurement',
          duration: 45,
          order: 2,
        },
        'Seed cells',
      ],
    })
    const steps = toProtocolSteps(template)
    const frame = toProtocolDataFrame(template)

    expect(template.template_id).toBe('protocol-steps')
    expect(steps.map(step => step.name)).toEqual(['Seed cells', 'Measure readout'])
    expect(steps[1].type).toBe('measurement')
    expect(frame.rowKey).toBe('id')
    expect(frame.columns.map(column => column.key)).toContain('duration')
    expect(toTemplateDataFrame(template).data[0].id).toBe('seed-cells')
  })

  it('creates assay-matrix templates and adapts pivoted rows and columns', () => {
    const template = createAssayMatrixTemplate({
      samples: ['S001', 'S002'],
      features: ['Lactate', 'Glucose'],
      values: {
        s001: { lactate: 1.2, glucose: 5.4 },
        s002: { lactate: 2.1, glucose: 4.8 },
      },
    })
    const rows = toAssayMatrixRows(template)
    const columns = toAssayMatrixColumns(template)

    expect(template.template_id).toBe('assay-matrix')
    expect(rows[0].lactate).toBe(1.2)
    expect(columns.map(column => column.key)).toContain('glucose')
    const assayFrame = toAssayMatrixDataFrame(template)
    expect(assayFrame.rowKey).toBe('sampleId')
    expect(assayFrame.data[0].lactate).toBe(1.2)
    expect(toAssayMatrixSampleOptions(template)).toEqual([
      { value: 's001', label: 'S001', description: undefined },
      { value: 's002', label: 'S002', description: undefined },
    ])
    expect(toTemplateDataFrame(template).columns.map(column => column.key)).toContain('glucose')
  })

  it('creates reagent-list templates and adapts items and dataframe props', () => {
    const template = createReagentListTemplate({
      reagents: [
        {
          id: 'dmso',
          name: 'DMSO',
          kind: 'compound',
          storageCondition: 'RT',
          stockLevel: 80,
          stockUnit: '%',
        },
        'Anti-HA antibody',
      ],
    })
    const items = toReagentListItems(template)
    const frame = toReagentDataFrame(template)

    expect(template.template_id).toBe('reagent-list')
    expect(items[0].name).toBe('DMSO')
    expect(items[0].storageCondition).toBe('RT')
    expect(template.data.reagents[1].id).toBe('anti-ha-antibody')
    expect(frame.rowKey).toBe('id')
    expect(frame.columns.map(column => column.key)).toContain('stockLevel')
    expect(toTemplateDataFrame(template).data[0].kind).toBe('compound')
  })

  it('creates flow-cytometry panel templates and adapts marker rows', () => {
    const template = createFlowCytometryPanelTemplate({
      markers: [
        { id: 'cd3', marker: 'CD3', fluorophore: 'FITC', detector: 'B530/30' },
        { id: 'cd4', marker: 'CD4', fluorophore: 'PE', detector: 'B585/42' },
      ],
      instrument: 'BD LSRFortessa',
    })
    const rows = toFlowPanelRows(template)
    const frame = toFlowPanelDataFrame(template)

    expect(template.template_id).toBe('flow-cytometry-panel')
    expect(template.data.controls.map(control => control.kind)).toContain('single-stain')
    expect(rows[0].marker).toBe('CD3')
    expect(rows[0].controls).toContain('CD3 single stain')
    expect(frame.rowKey).toBe('id')
    expect(frame.columns.map(column => column.key)).toContain('fluorophore')
    expect(toTemplateDataFrame(template).data[1].detector).toBe('B585/42')
  })

  it('creates instrument-run templates and adapts run queues', () => {
    const template = createInstrumentRunTemplate({
      items: ['S001', { name: 'S002', vial: 'A2' }],
      instrument: 'LC-MS',
      method: 'Default method',
    })
    const rows = toInstrumentRunRows(template)
    const frame = toInstrumentRunDataFrame(template)
    const steps = toInstrumentRunSteps(template)
    const events = toInstrumentRunScheduleEvents(template)
    const componentProps = toBioTemplateComponentProps(template)
    const calendar = componentProps.find(binding => binding.component === 'ScheduleCalendar')
    const timeline = componentProps.find(binding => binding.component === 'ExperimentTimeline')

    expect(template.template_id).toBe('instrument-run')
    expect(template.data.items.map(item => item.kind)).toEqual(['blank', 'qc', 'sample', 'sample', 'qc'])
    expect(rows[0].name).toBe('Blank start')
    expect(rows[2].sampleId).toBe('s001')
    expect(rows[3].vial).toBe('A2')
    expect(frame.rowKey).toBe('id')
    expect(frame.columns.map(column => column.key)).toContain('status')
    expect(toTemplateDataFrame(template).data[3].sampleId).toBe('s002')
    expect(steps[2]).toMatchObject({
      id: 's001-run',
      type: 'measurement',
      name: 'S001',
      status: 'pending',
      order: 3,
    })
    expect(steps[2].parameters?.method).toBe('Default method')
    expect(events[0]).toMatchObject({
      id: 'blank-start',
      title: 'Blank start',
      start: '2024-01-01T08:00:00.000Z',
      end: '2024-01-01T08:10:00.000Z',
      status: 'pending',
    })
    expect(events[2].title).toBe('S001')
    expect(calendar?.propsObject.modelValue).toBe(events[0].start)
    expect(calendar?.propsObject.events).toEqual(events)
    expect(timeline?.propsObject.modelValue).toEqual(steps)
  })

  it('creates qPCR plate templates and adapts reactions to dataframe and wells', () => {
    const template = createQpcrPlateTemplate({
      samples: ['Control', 'Treatment'],
      targets: ['ACTB', 'GAPDH'],
      replicates: 2,
      instrument: 'QuantStudio',
    })
    const rows = toQpcrRows(template)
    const frame = toQpcrDataFrame(template)
    const wells = toQpcrWellPlateWells(template)

    expect(template.template_id).toBe('qpcr-plate')
    expect(template.data.reactions).toHaveLength(10)
    expect(template.data.reactions.at(-1)?.controlKind).toBe('no-template')
    expect(rows[0].sample).toBe('Control')
    expect(rows[0].target).toBe('ACTB')
    expect(frame.rowKey).toBe('id')
    expect(frame.columns.map(column => column.key)).toContain('cq')
    expect(wells.A1.sampleType).toBe('control')
    expect(wells.A1.metadata?.targetId).toBe('actb')
    expect(toTemplateDataFrame(template).data.at(-1)?.controlKind).toBe('no-template')
  })

  it('loads the shared qPCR plate fixture', () => {
    const template = ensureTemplateEnvelope<QpcrPlateTemplate>(qpcrPlateFixture, 'qpcr-plate')
    const frame = toQpcrDataFrame(template)
    const wells = toQpcrWellPlateWells(template)
    const componentProps = toBioTemplateComponentProps(template)
    const wellPlate = componentProps.find(binding => binding.component === 'WellPlate')
    const table = componentProps.find(binding => binding.component === 'DataFrame')

    expect(template.data.chemistry).toBe('taqman')
    expect(frame.data[2].flags).toBe('review')
    expect(frame.data[3].sample).toBe('no-template')
    expect(wells.A1.row).toBe(0)
    expect(wells.A1.col).toBe(0)
    expect(wells.A4.sampleType).toBe('no-template')
    expect((wellPlate?.propsObject.wells as Record<string, { sampleType?: string }>).A4.sampleType).toBe('no-template')
    expect((table?.propsObject.data as Record<string, unknown>[])[0].target).toBe('ACTB')
  })

  it('rejects templates without a dataframe adapter', () => {
    expect(() => toTemplateDataFrame(createPlateMapTemplate())).toThrow(
      "Template 'plate-map' does not expose a DataFrame adapter."
    )
    expect(() => toTemplateDataFrame(createDoseResponseTemplate({
      compounds: { 'Drug A': [1] },
      unit: 'uM',
    }))).toThrow("Template 'dose-response' does not expose a DataFrame adapter.")
  })

  it('accepts assay-matrix display names for values', () => {
    const template = createAssayMatrixTemplate({
      samples: ['S001'],
      features: ['Lactate'],
      values: {
        S001: { Lactate: 1.2 },
      },
    })

    expect(template.data.measurements[0].sampleId).toBe('s001')
    expect(template.data.measurements[0].featureId).toBe('lactate')
  })
})

describe('plate-map PlateEditor binding (7a)', () => {
  const editorProps = () =>
    toBioTemplateComponentProps(plateMapFixture as PlateMapTemplate)
      .find(binding => binding.component === 'PlateEditor')?.propsObject as Record<string, unknown>

  it('should pass the plates as racks with sequential slots', () => {
    expect((editorProps().modelValue as Array<{ slot: string }>)[0].slot).toBe('R')
  })

  it('should move the sample id of a well to its group', () => {
    const racks = editorProps().modelValue as Array<{ wells: Record<string, { group?: string }> }>

    expect(racks[0].wells.A2.group).toBe('drug-a')
  })

  it('should make a well with a sample id a sample', () => {
    const racks = editorProps().modelValue as Array<{ wells: Record<string, { sampleType?: string }> }>

    expect(racks[0].wells.A2.sampleType).toBe('sample')
  })

  it('should leave the stored plate-map wells unchanged', () => {
    const template = structuredClone(plateMapFixture) as PlateMapTemplate
    toBioTemplateComponentProps(template)

    expect(template).toEqual(plateMapFixture)
  })

  it('should offer the template samples as groups', () => {
    expect((editorProps().groups as Array<{ id: string }>).map(group => group.id)).toContain('drug-a')
  })

  it('should pin the format to the plate format', () => {
    expect(editorProps().formats).toEqual([96])
  })
})