import type { TriggerEventParameter } from '../../plugins/types'
import type { ToolCredential, ToolParameter } from '../types'
import type { TypeWithI18N } from '@/app/components/header/account-setting/model-provider-page/declarations'
import type { SchemaRoot } from '@/app/components/workflow/nodes/llm/types'
import { FormTypeEnum } from '@/app/components/header/account-setting/model-provider-page/declarations'
import { VarType as VarKindType } from '@/app/components/workflow/nodes/tool/types'

// Type for form value input with type and value properties
type FormValueInput = {
  type?: string
  value?: unknown
}

/**
 * Form schema type for tool credentials.
 * This type represents the schema returned by toolCredentialToFormSchemas.
 */
export type ToolCredentialFormSchema = {
  name: string
  variable: string
  label: TypeWithI18N
  type: string
  required: boolean
  default?: string
  tooltip?: TypeWithI18N
  placeholder?: TypeWithI18N
  show_on: { variable: string; value: string }[]
  options?: {
    label: TypeWithI18N
    value: string
    show_on: { variable: string; value: string }[]
  }[]
  help?: TypeWithI18N | null
  url?: string
}

/**
 * Form schema type for tool parameters.
 * This type represents the schema returned by toolParametersToFormSchemas.
 */
export type ToolFormSchema = {
  name: string
  variable: string
  label: TypeWithI18N
  type: string
  _type: string
  form: string
  required: boolean
  default?: string
  tooltip?: TypeWithI18N
  show_on: { variable: string; value: string }[]
  options?: {
    label: TypeWithI18N
    value: string
    show_on: { variable: string; value: string }[]
  }[]
  placeholder?: TypeWithI18N
  min?: number
  max?: number
  llm_description?: string
  human_description?: TypeWithI18N
  multiple?: boolean
  url?: string
  scope?: string
  input_schema?: SchemaRoot
}

export const toType = (type: string) => {
  switch (type) {
    case 'string':
      return 'text-input'
    case 'number':
      return 'number-input'
    case 'boolean':
      return 'checkbox'
    default:
      return type
  }
}

export const triggerEventParametersToFormSchemas = (parameters: TriggerEventParameter[]) => {
  if (!parameters?.length) return []

  return parameters.map((parameter) => {
    return {
      ...parameter,
      type: toType(parameter.type),
      _type: parameter.type,
      tooltip: parameter.description,
    }
  })
}

export const toolParametersToFormSchemas = (parameters: ToolParameter[]): ToolFormSchema[] => {
  if (!parameters) return []

  const formSchemas = parameters.map((parameter): ToolFormSchema => {
    return {
      ...parameter,
      variable: parameter.name,
      type: toType(parameter.type),
      _type: parameter.type,
      show_on: [],
      options: parameter.options?.map((option) => {
        return {
          ...option,
          show_on: [],
        }
      }),
      tooltip: parameter.human_description,
    }
  })
  return formSchemas
}

export const toolCredentialToFormSchemas = (
  parameters: ToolCredential[],
): ToolCredentialFormSchema[] => {
  if (!parameters) return []

  const formSchemas = parameters.map((parameter): ToolCredentialFormSchema => {
    return {
      ...parameter,
      variable: parameter.name,
      type: toType(parameter.type),
      label: parameter.label,
      tooltip: parameter.help ?? undefined,
      show_on: [],
      options: parameter.options?.map((option) => {
        return {
          ...option,
          show_on: [],
        }
      }),
    }
  })
  return formSchemas
}

export const addDefaultValue = (
  value: Record<string, unknown>,
  formSchemas: { variable: string; type: string; default?: unknown }[],
) => {
  const newValues = { ...value }
  formSchemas.forEach((formSchema) => {
    const itemValue = value[formSchema.variable]
    if (
      formSchema.default !== undefined &&
      (value === undefined || itemValue === null || itemValue === '' || itemValue === undefined)
    )
      newValues[formSchema.variable] = formSchema.default

    // Fix: Convert boolean field values to proper boolean type
    if (
      formSchema.type === 'boolean' &&
      itemValue !== undefined &&
      itemValue !== null &&
      itemValue !== ''
    ) {
      if (typeof itemValue === 'string')
        newValues[formSchema.variable] =
          itemValue === 'true' || itemValue === '1' || itemValue === 'True'
      else if (typeof itemValue === 'number') newValues[formSchema.variable] = itemValue === 1
      else if (typeof itemValue === 'boolean') newValues[formSchema.variable] = itemValue
    }
  })
  return newValues
}

const correctInitialData = (
  type: string,
  target: FormValueInput,
  defaultValue: unknown,
): FormValueInput => {
  if (type === 'text-input' || type === 'secret-input') target.type = 'mixed'

  if (type === 'boolean') {
    if (typeof defaultValue === 'string')
      target.value = defaultValue === 'true' || defaultValue === '1'

    if (typeof defaultValue === 'boolean') target.value = defaultValue

    if (typeof defaultValue === 'number') target.value = defaultValue === 1
  }

  if (type === 'number-input') {
    if (typeof defaultValue === 'string' && defaultValue !== '')
      target.value = Number.parseFloat(defaultValue)
  }

  if (type === 'app-selector' || type === 'model-selector') target.value = defaultValue

  return target
}

export const generateFormValue = (
  value: Record<string, unknown>,
  formSchemas: { variable: string; default?: unknown; type: string }[],
  isReasoning = false,
) => {
  const newValues: Record<string, unknown> = {}
  formSchemas.forEach((formSchema) => {
    const itemValue = value[formSchema.variable]
    if (
      formSchema.default !== undefined &&
      (value === undefined || itemValue === null || itemValue === '' || itemValue === undefined)
    ) {
      const defaultVal = formSchema.default
      if (isReasoning) {
        newValues[formSchema.variable] = { auto: 1, value: null }
      } else {
        const initialValue: FormValueInput = { type: 'constant', value: formSchema.default }
        newValues[formSchema.variable] = {
          value: correctInitialData(formSchema.type, initialValue, defaultVal),
        }
      }
    }
  })
  return newValues
}

export const getPlainValue = (value: Record<string, { value: unknown }>) => {
  const plainValue: Record<string, unknown> = {}
  Object.keys(value).forEach((key) => {
    plainValue[key] = {
      ...(value[key]!.value as object),
    }
  })
  return plainValue
}

export const getStructureValue = (
  value: Record<string, unknown>,
): Record<string, { value: unknown }> => {
  const newValue: Record<string, { value: unknown }> = {}
  Object.keys(value).forEach((key) => {
    newValue[key] = {
      value: value[key],
    }
  })
  return newValue
}

export const getConfiguredValue = (
  value: Record<string, unknown>,
  formSchemas: { variable: string; type: string; default?: unknown }[],
) => {
  const newValues: Record<string, unknown> = { ...value }
  formSchemas.forEach((formSchema) => {
    const itemValue = value[formSchema.variable]
    if (
      formSchema.default !== undefined &&
      (value === undefined || itemValue === null || itemValue === '' || itemValue === undefined)
    ) {
      const defaultVal = formSchema.default
      const initialValue: FormValueInput = {
        type: 'constant',
        value:
          typeof formSchema.default === 'string'
            ? formSchema.default.replace(/\n/g, '\\n')
            : formSchema.default,
      }
      newValues[formSchema.variable] = correctInitialData(formSchema.type, initialValue, defaultVal)
    }
  })
  return newValues
}

const getVarKindType = (type: FormTypeEnum) => {
  if (type === FormTypeEnum.file || type === FormTypeEnum.files) return VarKindType.variable
  if (
    type === FormTypeEnum.select ||
    type === FormTypeEnum.checkbox ||
    type === FormTypeEnum.textNumber
  )
    return VarKindType.constant
  if (type === FormTypeEnum.textInput || type === FormTypeEnum.secretInput) return VarKindType.mixed
}

export const generateAgentToolValue = (
  value: Record<string, { value?: unknown; auto?: 0 | 1 }>,
  formSchemas: { variable: string; default?: unknown; type: string }[],
  isReasoning = false,
) => {
  const newValues: Record<string, { value: FormValueInput | null; auto?: 0 | 1 }> = {}
  if (!isReasoning) {
    formSchemas.forEach((formSchema) => {
      const itemValue = value[formSchema.variable]
      newValues[formSchema.variable] = {
        value: {
          type: 'constant',
          value: itemValue?.value,
        },
      }
      newValues[formSchema.variable]!.value = correctInitialData(
        formSchema.type,
        newValues[formSchema.variable]!.value!,
        itemValue?.value,
      )
    })
  } else {
    formSchemas.forEach((formSchema) => {
      const itemValue = value[formSchema.variable]
      if (itemValue?.auto === 1) {
        newValues[formSchema.variable] = {
          auto: 1,
          value: null,
        }
      } else {
        newValues[formSchema.variable] = {
          auto: 0,
          value: (itemValue?.value as FormValueInput) || {
            type: getVarKindType(formSchema.type as FormTypeEnum),
            value: null,
          },
        }
      }
    })
  }
  return newValues
}