import {
  validateArray,
  validateChoice,
  validateDistinct,
  validateMaybeTrimmedString,
  validateMissing,
  validateNonEmptyTrimmedString,
  validateOption,
  Validator,
} from "@biryani/core"

import { DatasetNodeType } from "../datasets"

export function validateDatasetData(fields?: string[]): Validator {
  return fields === undefined
    ? validateMissing
    : validateArray(validateDatasetEntry(fields))
}

export function validateDatasetEntry(fields: string[]): Validator {
  return function(data: any): [any, any] {
    if (data === null || data === undefined) {
      return [data, "Missing value"]
    }
    if (typeof data !== "object") {
      return [data, `Expected an object, got ${typeof data}`]
    }

    const errors: { [key: string]: any } = {}
    for (const key of Object.keys(data)) {
      if (!fields.includes(key)) {
        errors[key] = "Unexpected field name"
      }
    }
    return [data, Object.keys(errors).length === 0 ? null : errors]
  }
}

export function validateDatasetNode(data: any): [any, any] {
  if (data === null || data === undefined) {
    return [data, "Missing value"]
  }
  if (typeof data !== "object") {
    return [data, `Expected an object, got ${typeof data}`]
  }

  data = {
    ...data,
  }
  const remainingKeys = new Set(Object.keys(data))
  const errors: { [key: string]: any } = {}

  {
    const key = "description"
    remainingKeys.delete(key)
    const [value, error] = validateMaybeTrimmedString(data[key])
    if (value === null) {
      delete data[key]
    } else {
      data[key] = value
    }
    if (error !== null) {
      errors[key] = error
    }
  }

  {
    const key = "name"
    remainingKeys.delete(key)
    const [value, error] = validateNonEmptyTrimmedString(data[key])
    data[key] = value
    if (error !== null) {
      errors[key] = error
    }
  }

  {
    const key = "path"
    remainingKeys.delete(key)
    const [value, error] = validateNonEmptyTrimmedString(data[key])
    data[key] = value
    if (error !== null) {
      errors[key] = error
    }
  }

  {
    const key = "type"
    remainingKeys.delete(key)
    const [value, error] = validateChoice([
      DatasetNodeType.Dataset,
      DatasetNodeType.Group,
    ])(data[key])
    data[key] = value
    if (error !== null) {
      errors[key] = error
    }
  }

  if (errors.type === undefined && data.type === DatasetNodeType.Dataset) {
    {
      const key = "fields"
      remainingKeys.delete(key)
      const [value, error] = validateOption(validateMissing, [
        validateArray(validateNonEmptyTrimmedString),
        validateDistinct,
      ])(data[key])
      if (value === null) {
        delete data[key]
      } else {
        data[key] = value
      }
      if (error !== null) {
        errors[key] = error
      }
    }
    if (errors.fields === undefined) {
      {
        const key = "data"
        remainingKeys.delete(key)
        const [value, error] = validateDatasetData(data.fields)(data[key])
        if (value === null) {
          delete data[key]
        } else {
          data[key] = value
        }
        if (error !== null) {
          errors[key] = error
        }
      }
    }
  }
  for (const key of remainingKeys) {
    errors[key] = "Unexpected entry"
  }
  return [data, Object.keys(errors).length === 0 ? null : errors]
}