import { getTemplateWithFields } from './template-validator'
import { filterVisibleFieldValues, getVisibleTemplateFields, hasFieldValue } from './field-conditions'

type TemplateFieldLike = {
  key: string
  label?: string | null
  type?: string | null
  required?: boolean | null
  conditions?: string | null
}

export type TemplateFieldValidationResult =
  | {
      valid: true
      templateName?: string
      templateFields: Record<string, unknown>
      visibleFieldKeys: string[]
    }
  | {
      valid: false
      error: string
      errorCode: string
      details?: Record<string, unknown>
    }

export { hasFieldValue } from './field-conditions'

export async function validateSubmittedTemplateFields(args: {
  templateId: string | null | undefined
  templateFields: Record<string, unknown>
  allowUnknownKeys?: boolean
}): Promise<TemplateFieldValidationResult> {
  const { templateId, templateFields, allowUnknownKeys = true } = args

  if (!templateId) {
    return {
      valid: true,
      templateFields,
      visibleFieldKeys: Object.keys(templateFields),
    }
  }

  const template = await getTemplateWithFields(templateId)
  if (!template) {
    return {
      valid: false,
      error: '模板不存在或不可用',
      errorCode: 'TEMPLATE_NOT_FOUND',
    }
  }

  const fields = (template.fields || []) as TemplateFieldLike[]
  const fieldMap = new Map(fields.map((field) => [field.key, field]))
  const visibleFields = getVisibleTemplateFields(fields, templateFields)
  const visibleTemplateFields = filterVisibleFieldValues(fields, templateFields)

  if (!allowUnknownKeys) {
    const unknownKeys = Object.keys(templateFields).filter((key) => !fieldMap.has(key))
    if (unknownKeys.length > 0) {
      return {
        valid: false,
        error: `提交了模板中不存在的字段：${unknownKeys.join(', ')}`,
        errorCode: 'UNKNOWN_TEMPLATE_FIELDS',
        details: {
          unknownKeys,
          templateId,
        },
      }
    }
  }

  const missingRequiredFields = visibleFields
    .filter((field) => field.required)
    .filter((field) => !hasFieldValue(visibleTemplateFields[field.key], field.type))
    .map((field) => ({
      key: field.key,
      label: field.label || field.key,
      type: field.type || 'text',
    }))

  if (missingRequiredFields.length > 0) {
    return {
      valid: false,
      error: `模板必填字段未填写：${missingRequiredFields.map((field) => field.label).join('、')}`,
      errorCode: 'TEMPLATE_REQUIRED_FIELDS_MISSING',
      details: {
        templateId,
        missingRequiredFields,
      },
    }
  }

  return {
    valid: true,
    templateName: typeof template.name === 'string' ? template.name : undefined,
    templateFields: visibleTemplateFields,
    visibleFieldKeys: visibleFields.map((field) => field.key),
  }
}