export const FIELD_TYPES = [
  'text',
  'textarea',
  'number',
  'date',
  'daterange',
  'boolean',
  'select',
  'multiselect',
  'hybrid_select',
  'file_upload',
  'user_picker',
  'supplier_picker',
] as const

export type FieldType = (typeof FIELD_TYPES)[number]

export const FIELD_TYPE_LABEL: Record<FieldType, string> = {
  text: 'Text',
  textarea: 'Textfeld',
  number: 'Zahl',
  date: 'Datum',
  daterange: 'Datums-Range',
  boolean: 'Ja/Nein',
  select: 'Dropdown',
  multiselect: 'Multi-Select',
  hybrid_select: 'Dropdown + Freitext',
  file_upload: 'Datei-Upload',
  user_picker: 'User-Picker',
  supplier_picker: 'Lieferanten-Picker',
}

export const SELECT_TYPES: ReadonlySet<FieldType> = new Set<FieldType>([
  'select',
  'multiselect',
  'hybrid_select',
])

export type FieldDefinition = {
  id: string
  field_key: string
  block: number
  sort_order: number
  label_de: string
  label_en: string | null
  helptext_de: string | null
  helptext_en: string | null
  field_type: FieldType
  is_required: boolean
  is_active: boolean
  visible_if: unknown
}

export type FieldOption = {
  id: string
  field_definition_id: string
  option_value: string
  label_de: string
  label_en: string | null
  sort_order: number
  is_active: boolean
}

export const FIELD_KEY_PATTERN = /^[a-z][a-z0-9_]{2,49}$/

export type DefinitionInput = {
  field_key: string
  block: number
  label_de: string
  label_en: string | null
  helptext_de: string | null
  helptext_en: string | null
  field_type: FieldType
  is_required: boolean
  visible_if_text: string | null
  sort_order: number
}

export type DefinitionValidationError =
  | 'field_key_invalid'
  | 'field_key_required'
  | 'label_de_required'
  | 'block_out_of_range'
  | 'unknown_field_type'
  | 'visible_if_invalid_json'
  | 'sort_order_invalid'

export function validateDefinitionInput(
  input: DefinitionInput,
): { ok: true; visibleIf: unknown | null } | { ok: false; error: DefinitionValidationError } {
  const key = input.field_key.trim()
  if (!key) return { ok: false, error: 'field_key_required' }
  if (!FIELD_KEY_PATTERN.test(key)) return { ok: false, error: 'field_key_invalid' }
  if (!input.label_de.trim()) return { ok: false, error: 'label_de_required' }
  if (!Number.isInteger(input.block) || input.block < 1 || input.block > 9) {
    return { ok: false, error: 'block_out_of_range' }
  }
  if (!FIELD_TYPES.includes(input.field_type)) return { ok: false, error: 'unknown_field_type' }
  if (!Number.isInteger(input.sort_order) || input.sort_order < 0) {
    return { ok: false, error: 'sort_order_invalid' }
  }

  let visibleIf: unknown | null = null
  const visTrim = input.visible_if_text?.trim() ?? ''
  if (visTrim) {
    try {
      visibleIf = JSON.parse(visTrim)
    } catch {
      return { ok: false, error: 'visible_if_invalid_json' }
    }
  }

  return { ok: true, visibleIf }
}

export type UpdateDefinitionInput = {
  block: number
  label_de: string
  label_en: string | null
  helptext_de: string | null
  helptext_en: string | null
  is_required: boolean
  visible_if_text: string | null
  sort_order: number
  is_active: boolean
}

export function validateUpdateDefinitionInput(
  input: UpdateDefinitionInput,
): { ok: true; visibleIf: unknown | null } | { ok: false; error: DefinitionValidationError } {
  if (!input.label_de.trim()) return { ok: false, error: 'label_de_required' }
  if (!Number.isInteger(input.block) || input.block < 1 || input.block > 9) {
    return { ok: false, error: 'block_out_of_range' }
  }
  if (!Number.isInteger(input.sort_order) || input.sort_order < 0) {
    return { ok: false, error: 'sort_order_invalid' }
  }
  let visibleIf: unknown | null = null
  const visTrim = input.visible_if_text?.trim() ?? ''
  if (visTrim) {
    try {
      visibleIf = JSON.parse(visTrim)
    } catch {
      return { ok: false, error: 'visible_if_invalid_json' }
    }
  }
  return { ok: true, visibleIf }
}

export type OptionInput = {
  option_value: string
  label_de: string
  label_en: string | null
  sort_order: number
  is_active: boolean
}

export type OptionValidationError =
  | 'option_value_required'
  | 'label_de_required'
  | 'sort_order_invalid'

export function validateOptionInput(
  input: OptionInput,
): { ok: true } | { ok: false; error: OptionValidationError } {
  if (!input.option_value.trim()) return { ok: false, error: 'option_value_required' }
  if (!input.label_de.trim()) return { ok: false, error: 'label_de_required' }
  if (!Number.isInteger(input.sort_order) || input.sort_order < 0) {
    return { ok: false, error: 'sort_order_invalid' }
  }
  return { ok: true }
}

export const VALIDATION_LABEL_DE: Record<string, string> = {
  field_key_invalid: "field_key: nur a-z, 0-9, _, Startbuchstabe, 3-50 Zeichen",
  field_key_required: 'field_key fehlt',
  label_de_required: 'Label (DE) fehlt',
  block_out_of_range: 'Block muss zwischen 1 und 9 liegen',
  unknown_field_type: 'Unbekannter Feldtyp',
  visible_if_invalid_json: 'visible_if ist kein valides JSON',
  sort_order_invalid: 'Sort-Order muss eine nicht-negative Ganzzahl sein',
  option_value_required: 'option_value fehlt',
}

export const BLOCK_LABELS: Record<number, string> = {
  1: 'Block 1 — Projektdaten',
  2: 'Block 2 — Produktdaten',
  3: 'Block 3 — Lieferantendaten',
  4: 'Block 4 — Ansprechpartner Kunde',
  5: 'Block 5 — Ansprechpartner Lieferant',
  6: 'Block 6 — Kosten',
  7: 'Block 7 — Kapazität',
  8: 'Block 8 — Unterlagen',
  9: 'Block 9 — Terminwünsche',
}