import { beforeEach, describe, expect, it, vi } from 'vitest'

const mockGet = vi.fn()
const mockPut = vi.fn()
const mockDelete = vi.fn()
const mockUseApi = vi.fn((_options?: unknown) => ({
  get: mockGet,
  put: mockPut,
  delete: mockDelete,
}))

vi.mock('../../composables/useApi', () => ({
  useApi: (options: unknown) => mockUseApi(options),
}))

import { useTemplateCollection } from '../../composables/useTemplateCollection'
import {
  createPlateMapTemplate,
  createSampleSheetTemplate,
  createTemplateCollection,
  createWellPlateScreenCollection,
} from '../../templates'
import type { PlateMapTemplate, SampleSheetTemplate } from '../../templates'

function setup(options?: Parameters<typeof useTemplateCollection>[0]) {
  return useTemplateCollection(options)
}

describe('useTemplateCollection', () => {
  beforeEach(() => {
    vi.clearAllMocks()
    mockGet.mockResolvedValue({})
    mockPut.mockResolvedValue({})
    mockDelete.mockResolvedValue({})
    delete (window as unknown as { __MINT_PLATFORM__?: unknown }).__MINT_PLATFORM__
    window.history.replaceState({}, '', '/')
  })

  it('initializes from a template collection envelope', () => {
    const plate = createPlateMapTemplate({ samples: ['Control', 'Treatment'] })
    const { templateIds, templates, metadata, hasTemplates, getTemplate, requireTemplate } = setup({
      initial: createTemplateCollection([plate], { preset: 'unit-test' }),
    })

    expect(templateIds.value).toEqual(['plate-map'])
    expect(Object.keys(templates.value)).toEqual(['plate-map'])
    expect(metadata.value).toEqual({ preset: 'unit-test' })
    expect(hasTemplates.value).toBe(true)
    expect(getTemplate<PlateMapTemplate>('plate-map')?.data.samples[1].id).toBe('treatment')
    expect(requireTemplate<PlateMapTemplate>('plate-map').template_id).toBe('plate-map')
  })

  it('applies, sets, removes, and resets local templates', () => {
    const plate = createPlateMapTemplate({ samples: ['Control'] })
    const sampleSheet = createSampleSheetTemplate({
      samples: [{ sampleId: 'S001', name: 'Sample 1' }],
    })
    const { apply, setTemplate, removeTemplate, reset, templateIds, metadata } = setup({
      initial: [plate],
    })

    setTemplate(sampleSheet)
    expect(templateIds.value).toEqual(['plate-map', 'sample-sheet'])

    expect(removeTemplate('plate-map')).toBe(true)
    expect(templateIds.value).toEqual(['sample-sheet'])
    expect(removeTemplate('missing')).toBe(false)

    apply(createTemplateCollection([sampleSheet], { source: 'loaded' }))
    expect(metadata.value).toEqual({ source: 'loaded' })

    reset()
    expect(templateIds.value).toEqual(['plate-map'])
  })

  it('uses fallback metadata only when the payload has none', () => {
    const plate = createPlateMapTemplate({ samples: ['Control'] })
    const { apply, metadata } = setup()

    apply(createTemplateCollection([plate], { source: 'payload' }), { source: 'fallback' })
    expect(metadata.value).toEqual({ source: 'payload' })

    apply([plate], { source: 'fallback' })
    expect(metadata.value).toEqual({ source: 'fallback' })
  })

  it('saves the local collection through experiment design_data', async () => {
    const collection = createWellPlateScreenCollection({
      samples: ['Control', 'Treatment'],
      compounds: { Drug: [10, 1] },
    })
    const { save, lastSavedAt } = setup({ pluginId: 'p1', initial: collection })

    const ok = await save(42)

    expect(ok).toBe(true)
    expect(lastSavedAt.value).toBeInstanceOf(Date)
    expect(mockPut).toHaveBeenCalledWith('/experiments/42/data', {
      plugin_id: 'p1',
      data: collection,
      schema_version: '1.0',
    })
  })

  it('loads design_data into the local collection', async () => {
    const sampleSheet = createSampleSheetTemplate({
      samples: [
        { sampleId: 'S001', name: 'Sample 1' },
        { sampleId: 'S002', name: 'Sample 2' },
      ],
    })
    mockGet.mockResolvedValueOnce(createTemplateCollection([sampleSheet], { source: 'api' }))
    const { load, templateIds, metadata, requireTemplate, lastLoadedAt } = setup()

    const loaded = await load(7)

    expect(mockGet).toHaveBeenCalledWith('/experiments/7/data')
    expect(loaded?.metadata).toEqual({ source: 'api' })
    expect(templateIds.value).toEqual(['sample-sheet'])
    expect(requireTemplate<SampleSheetTemplate>('sample-sheet').data.samples[1].sampleId).toBe(
      'S002',
    )
    expect(metadata.value).toEqual({ source: 'api' })
    expect(lastLoadedAt.value).toBeInstanceOf(Date)
  })

  it('saves the current URL experiment without route plumbing', async () => {
    window.history.replaceState({}, '', '/plugins/template?experimentId=88')
    const plate = createPlateMapTemplate({ samples: ['Control'] })
    const { currentExperimentId, hasCurrentExperiment, saveCurrent } = setup({
      pluginId: 'p1',
      initial: [plate],
    })

    expect(currentExperimentId.value).toBe(88)
    expect(hasCurrentExperiment.value).toBe(true)

    const ok = await saveCurrent()

    expect(ok).toBe(true)
    expect(mockPut).toHaveBeenCalledWith('/experiments/88/data', {
      plugin_id: 'p1',
      data: createTemplateCollection([plate]),
      schema_version: '1.0',
    })
  })
})