import type { ProtocolStep, ProtocolStepStatus } from '../types'
import type { ParameterDefinition, StepTemplate } from '../composables/useProtocolTemplates'

export interface ProtocolStepEditorFields {
  name: string
  description: string
  duration?: number
  parameters: Record<string, unknown>
}

export interface InitializedProtocolStepEditorState {
  selectedTemplateId: string | null
  fields: ProtocolStepEditorFields
}

export type ProtocolParameterFormatter = (
  value: unknown,
  parameter: ParameterDefinition
) => string

export function buildProtocolTemplateDefaults(
  template: StepTemplate
): ProtocolStepEditorFields {
  const parameters: Record<string, unknown> = {}
  for (const parameter of template.parameters) {
    if (parameter.default !== undefined) {
      parameters[parameter.key] = parameter.default
    }
  }

  return {
    name: template.name,
    description: template.description || '',
    duration: template.defaultDuration,
    parameters,
  }
}

export function buildProtocolStepEditorState(
  step: ProtocolStep,
  getTemplateByType: (type: ProtocolStep['type']) => StepTemplate | undefined
): InitializedProtocolStepEditorState {
  const template = getTemplateByType(step.type)

  return {
    selectedTemplateId: template?.id || null,
    fields: {
      name: step.name,
      description: step.description || '',
      duration: step.duration,
      parameters: { ...(step.parameters || {}) },
    },
  }
}

export function buildProtocolStepPreview(
  template: StepTemplate,
  fields: ProtocolStepEditorFields,
  sourceStep?: ProtocolStep
): ProtocolStep {
  return {
    id: sourceStep?.id || 'preview',
    type: template.type,
    name: fields.name || template.name,
    description: fields.description,
    duration: fields.duration ?? template.defaultDuration,
    status: (sourceStep?.status || 'pending') as ProtocolStepStatus,
    parameters: { ...fields.parameters },
    order: sourceStep?.order || 0,
  }
}

export function buildProtocolPreviewParams(
  template: StepTemplate,
  parameters: Record<string, unknown>,
  formatParameterValue: ProtocolParameterFormatter
): string {
  return template.parameters
    .filter((parameter) => (
      parameters[parameter.key] !== undefined
      && parameters[parameter.key] !== ''
    ))
    .map((parameter) => formatParameterValue(parameters[parameter.key], parameter))
    .join(', ')
}

export function buildCustomProtocolTemplate(
  template: StepTemplate,
  fields: ProtocolStepEditorFields,
  templateId = `custom-${Date.now()}`
): StepTemplate {
  return {
    id: templateId,
    type: template.type,
    name: fields.name || template.name,
    description: fields.description,
    defaultDuration: fields.duration,
    parameters: template.parameters.map((parameter) => ({
      ...parameter,
      default: fields.parameters[parameter.key],
    })),
    isBuiltIn: false,
  }
}