locality.ts

import { EditDataType, LocalityDetailsType } from '../types'
import { Validators, validateFields, validator } from './validator'
import { validCountries } from './countryList'

const pollenFields = ['pers_pollen_ap', 'pers_pollen_nap', 'pers_pollen_other'] as const

export const pollenTotalValidationError =
  'Combined Arboreal (AP%), Non-arboreal (NAP%), and Other pollen (OP%) must be less than or equal to 100'
export const estimateTempRangeValidationError = 'Estimated temperature must be between -999.9 and 999.9'

const validatePollenPercentage = (name: string, num: number) => {
  if (!Number.isInteger(num)) return `${name} must be an integer value`
  if (num < 0 || num > 100) return `${name} must be between 0 and 100`
  return
}

const validateNonNegativeInteger = (name: string, num: number) => {
  if (!Number.isInteger(num) || num < 0) return `${name} must be a non-negative integer.`
  return
}

const validateIntegerInRange = (name: string, num: number, min: number, max: number) => {
  if (!Number.isInteger(num)) return `${name} must be an integer value`
  if (num < min || num > max) return `${name} must be between ${min} and ${max}`
  return
}

const validatePositiveInteger = (name: string, num: number) => {
  if (!Number.isInteger(num) || num < 1) return `${name} must be a positive integer.`
  return
}

const validateFraction = (name: string, value: string) => {
  const trimmed = value.trim()
  if (trimmed === '') return
  const match = /^(\d+):(\d+)$/.exec(trimmed)
  if (!match) return `${name} must be in format integer:integer`

  const numerator = Number(match[1])
  const denominator = Number(match[2])

  if (!Number.isInteger(numerator) || !Number.isInteger(denominator)) return `${name} must be in format integer:integer`
  if (denominator < 1) return `${name} denominator must be >= 1`
  if (numerator < 1) return `${name} numerator must be >= 1`
  if (numerator > denominator) return `${name} numerator must be <= denominator`
  return
}

const validatePollenRecordTotal = (editData: Partial<EditDataType<LocalityDetailsType>>) => {
  const values = pollenFields
    .map(fieldName => editData[fieldName])
    .filter((value): value is number => typeof value === 'number')

  const total = values.reduce((sum, value) => sum + value, 0)

  if (total > 100) return pollenTotalValidationError

  return
}

const createLocalityValidators = (
  editData: EditDataType<LocalityDetailsType>
): Validators<Partial<EditDataType<LocalityDetailsType>>> => {
  const isAbsoluteDatingMethod = editData.date_meth === 'absolute'
  const isTimeUnitDatingMethod = editData.date_meth === 'time_unit'
  const isCompositeDatingMethod = editData.date_meth === 'composite'

  const minUsesAbsoluteBasis = !!editData.bfa_min_abs
  const minUsesTimeUnitBasis = !!editData.bfa_min
  const maxUsesAbsoluteBasis = !!editData.bfa_max_abs
  const maxUsesTimeUnitBasis = !!editData.bfa_max

  const compositeDatingMethodNoBases =
    isCompositeDatingMethod &&
    !minUsesTimeUnitBasis &&
    !minUsesAbsoluteBasis &&
    !maxUsesTimeUnitBasis &&
    !maxUsesAbsoluteBasis

  const compositeDatingMethodRequiredText = 'One age row must follow the rules for Absolute, the other for Time Unit'

  return {
    // const isNew = editData.lid === undefined
    date_meth: {
      name: 'Dating method',
      required: true,
    },
    max_age: {
      name: 'Age (max)',
      required: true,
      asNumber: (num: number) => {
        if (editData.min_age && num < editData.min_age) return 'Max value cannot be lower than min'
        if (num < 0) return 'Max value must be a positive real value'
        return
      },
    },
    min_age: {
      name: 'Age (min)',
      required: true,
      asNumber: (num: number) => {
        if (editData.max_age && num > editData.max_age) return 'Min value cannot be higher than max'
        if (num < 0) return 'Min value must be a positive real value'
        return
      },
    },
    bfa_min_abs: {
      name: 'Basis for age (Absolute, min)',
      required: () => {
        if (isAbsoluteDatingMethod || (isCompositeDatingMethod && maxUsesTimeUnitBasis)) return 'This field is required'
        if (compositeDatingMethodNoBases) return compositeDatingMethodRequiredText
        return
      },
    },
    bfa_max_abs: {
      name: 'Basis for age (Absolute, max)',
      required: () => {
        if (isAbsoluteDatingMethod || (isCompositeDatingMethod && minUsesTimeUnitBasis)) return 'This field is required'
        if (compositeDatingMethodNoBases) return compositeDatingMethodRequiredText
        return
      },
    },
    bfa_min: {
      name: 'Basis for age (Time unit, min)',
      required: () => {
        if (isTimeUnitDatingMethod || (isCompositeDatingMethod && maxUsesAbsoluteBasis)) return 'This field is required'
        if (compositeDatingMethodNoBases) return compositeDatingMethodRequiredText
        return
      },
    },
    bfa_max: {
      name: 'Basis for age (Time unit, max)',
      required: () => {
        if (isTimeUnitDatingMethod || (isCompositeDatingMethod && minUsesAbsoluteBasis)) return 'This field is required'
        if (compositeDatingMethodNoBases) return compositeDatingMethodRequiredText
        return
      },
    },
    loc_name: {
      name: 'Locality name',
      required: true,
    },
    country: {
      name: 'Country',
      required: true,
      asString: (countryName: string) => {
        if (!validCountries.includes(countryName)) return 'Country is not valid'
        return
      },
    },
    dms_lat: {
      name: 'Latitude (dms)',
      required: true,
      asString: (dms_lat: string) => {
        const dmsLatRegEx = /^(\d{1,3}) (\d{1,2}) (\d{1,2}) ([NS])$/
        if (!dmsLatRegEx.test(dms_lat)) return 'Must be in the format DD(D) M(M) S(S) N/S'
        return
      },
    },
    dec_lat: {
      name: 'Latitude (dec)',
      required: true,
      asNumber: (num: number) => {
        if (num < -90 || num > 90) return 'Must be between -90 and 90'
        return
      },
    },
    dms_long: {
      name: 'Longitude (dms)',
      required: true,
      asString: (dms_long: string) => {
        const dmsLongRegEx = /^(\d{1,3}) (\d{1,2}) (\d{1,2}) ([EW])$/
        if (!dmsLongRegEx.test(dms_long)) return 'Must be in the format DD(D) M(M) S(S) E/W'
        return
      },
    },
    dec_long: {
      name: 'Longitude (dec)',
      required: true,
      asNumber: (num: number) => {
        if (num < -180 || num > 180) return 'Must be between -180 and 180'
        return
      },
    },
    pers_pollen_ap: {
      name: 'Arboreal pollen (AP%)',
      asNumber: (num: number) => {
        const valueError = validatePollenPercentage('Arboreal pollen (AP%)', num)
        if (valueError) return valueError

        const totalError = validatePollenRecordTotal(editData)
        if (totalError) return totalError

        return
      },
    },
    pers_pollen_nap: {
      name: 'Non-arboreal pollen (NAP%)',
      asNumber: (num: number) => {
        const valueError = validatePollenPercentage('Non-arboreal pollen (NAP%)', num)
        if (valueError) return valueError

        const totalError = validatePollenRecordTotal(editData)
        if (totalError) return totalError

        return
      },
    },
    pers_pollen_other: {
      name: 'Other pollen (OP%)',
      asNumber: (num: number) => {
        const valueError = validatePollenPercentage('Other pollen (OP%)', num)
        if (valueError) return valueError

        const totalError = validatePollenRecordTotal(editData)
        if (totalError) return totalError

        return
      },
    },
    estimate_temp: {
      name: 'Estimated temperature',
      asNumber: (num: number) => {
        if (num <= -1000 || num >= 1000) return estimateTempRangeValidationError
        return
      },
    },
    estimate_precip: {
      name: 'Estimate of annual precipitation (mm)',
      asNumber: (num: number) => validateNonNegativeInteger('Estimate of annual precipitation (mm)', num),
    },
    altitude: {
      name: 'Altitude (m)',
      asNumber: (num: number) => validateIntegerInRange('Altitude (m)', num, -500, 9000),
    },
    appr_num_spm: {
      name: 'Approx. Number of Specimens',
      asNumber: (num: number) => validatePositiveInteger('Approx. Number of Specimens', num),
    },
    num_spm: {
      name: 'Exact Number of Specimens',
      asNumber: (num: number) => validatePositiveInteger('Exact Number of Specimens', num),
    },
    num_quad: {
      name: 'Number of Quadrats',
      asNumber: (num: number) => validatePositiveInteger('Number of Quadrats', num),
    },
    estimate_npp: {
      name: 'Estimate of net primary productivity (g/m2/yr)',
      asNumber: (num: number) => validateNonNegativeInteger('Estimate of net primary productivity (g/m2/yr)', num),
    },
    pers_woody_cover: {
      name: 'Woody cover percentage',
      asNumber: (num: number) => validateIntegerInRange('Woody cover percentage', num, 0, 100),
    },
    frac_min: {
      name: 'Minimum fraction',
      condition: (data: Partial<EditDataType<LocalityDetailsType>>) =>
        data.frac_min !== null && data.frac_min !== undefined && data.frac_min !== '',
      asString: (value: string) => validateFraction('Minimum fraction', value),
    },
    frac_max: {
      name: 'Maximum fraction',
      condition: (data: Partial<EditDataType<LocalityDetailsType>>) =>
        data.frac_max !== null && data.frac_max !== undefined && data.frac_max !== '',
      asString: (value: string) => validateFraction('Maximum fraction', value),
    },
  }
}

export const validateLocality = (
  editData: EditDataType<LocalityDetailsType>,
  fieldName: keyof EditDataType<LocalityDetailsType>
) => {
  const validators = createLocalityValidators(editData)
  return validator<EditDataType<LocalityDetailsType>>(validators, editData, fieldName)
}

export const validateLocalityFields = (editData: Partial<EditDataType<LocalityDetailsType>>) =>
  validateFields<EditDataType<LocalityDetailsType>>(
    createLocalityValidators(editData as EditDataType<LocalityDetailsType>),
    editData
  )