import {z} from 'zod'

export type GetApiV2SpeciesMatchArgs = {usageKey?: string | undefined, taxonID?: string | undefined, taxonConceptID?: string | undefined, scientificNameID?: string | undefined, scientificName?: string | undefined, scientificNameAuthorship?: string | undefined, taxonRank?: ('SUPERDOMAIN' | 'DOMAIN' | 'SUBDOMAIN' | 'INFRADOMAIN' | 'EMPIRE' | 'REALM' | 'SUBREALM' | 'SUPERKINGDOM' | 'KINGDOM' | 'SUBKINGDOM' | 'INFRAKINGDOM' | 'SUPERPHYLUM' | 'PHYLUM' | 'SUBPHYLUM' | 'INFRAPHYLUM' | 'PARVPHYLUM' | 'MICROPHYLUM' | 'NANOPHYLUM' | 'CLAUDIUS' | 'GIGACLASS' | 'MEGACLASS' | 'SUPERCLASS' | 'CLASS' | 'SUBCLASS' | 'INFRACLASS' | 'SUBTERCLASS' | 'PARVCLASS' | 'SUPERDIVISION' | 'DIVISION_ZOOLOGY' | 'SUBDIVISION' | 'INFRADIVISION' | 'SUPERLEGION' | 'LEGION' | 'SUBLEGION' | 'INFRALEGION' | 'MEGACOHORT' | 'SUPERCOHORT' | 'COHORT' | 'SUBCOHORT' | 'INFRACOHORT' | 'GIGAORDER' | 'MAGNORDER' | 'GRANDORDER' | 'MIRORDER' | 'SUPERORDER' | 'ORDER' | 'NANORDER' | 'HYPOORDER' | 'MINORDER' | 'SUBORDER' | 'INFRAORDER' | 'PARVORDER' | 'SUPERSECTION_ZOOLOGY' | 'SECTION_ZOOLOGY' | 'SUBSECTION_ZOOLOGY' | 'SUPERSERIES_ZOOLOGY' | 'SERIES_ZOOLOGY' | 'SUBSERIES_ZOOLOGY' | 'FALANX' | 'GIGAFAMILY' | 'MEGAFAMILY' | 'GRANDFAMILY' | 'SUPERFAMILY' | 'EPIFAMILY' | 'FAMILY' | 'SUBFAMILY' | 'INFRAFAMILY' | 'SUPERTRIBE' | 'TRIBE' | 'SUBTRIBE' | 'INFRATRIBE' | 'SUPRAGENERIC_NAME' | 'SUPERGENUS' | 'GENUS' | 'SUBGENUS' | 'INFRAGENUS' | 'DIVISION_BOTANY' | 'SUPERSECTION_BOTANY' | 'SECTION_BOTANY' | 'SUBSECTION_BOTANY' | 'SUPERSERIES_BOTANY' | 'SERIES_BOTANY' | 'SUBSERIES_BOTANY' | 'INFRAGENERIC_NAME' | 'SPECIES_AGGREGATE' | 'SPECIES' | 'INFRASPECIFIC_NAME' | 'GREX' | 'KLEPTON' | 'SUBSPECIES' | 'CULTIVAR_GROUP' | 'CONVARIETY' | 'INFRASUBSPECIFIC_NAME' | 'PROLES' | 'NATIO' | 'ABERRATION' | 'MORPH' | 'SUPERVARIETY' | 'VARIETY' | 'SUBVARIETY' | 'SUPERFORM' | 'FORM' | 'SUBFORM' | 'PATHOVAR' | 'BIOVAR' | 'CHEMOVAR' | 'MORPHOVAR' | 'PHAGOVAR' | 'SEROVAR' | 'CHEMOFORM' | 'FORMA_SPECIALIS' | 'LUSUS' | 'CULTIVAR' | 'MUTATIO' | 'STRAIN' | 'OTHER' | 'UNRANKED') | undefined, verbatimTaxonRank?: string | undefined, genericName?: string | undefined, specificEpithet?: string | undefined, infraspecificEpithet?: string | undefined, kingdom?: string | undefined, phylum?: string | undefined, order?: string | undefined, superfamily?: string | undefined, family?: string | undefined, subfamily?: string | undefined, tribe?: string | undefined, subtribe?: string | undefined, genus?: string | undefined, subgenus?: string | undefined, species?: string | undefined, exclude?: Array<string> | undefined, strict?: boolean | undefined, verbose?: boolean | undefined, checklistKey?: string | undefined, class?: string | undefined};

export type GetApiV2SpeciesMatchOptions = {baseUrl?: string | undefined, fetch?: typeof fetch | undefined};

export const usage = z.object({key: z.string().optional(), name: z.string().optional(), canonicalName: z.string().optional(), authorship: z.string().optional(), rank: z.enum(["SUPERDOMAIN", "DOMAIN", "SUBDOMAIN", "INFRADOMAIN", "EMPIRE", "REALM", "SUBREALM", "SUPERKINGDOM", "KINGDOM", "SUBKINGDOM", "INFRAKINGDOM", "SUPERPHYLUM", "PHYLUM", "SUBPHYLUM", "INFRAPHYLUM", "PARVPHYLUM", "MICROPHYLUM", "NANOPHYLUM", "CLAUDIUS", "GIGACLASS", "MEGACLASS", "SUPERCLASS", "CLASS", "SUBCLASS", "INFRACLASS", "SUBTERCLASS", "PARVCLASS", "SUPERDIVISION", "DIVISION_ZOOLOGY", "SUBDIVISION", "INFRADIVISION", "SUPERLEGION", "LEGION", "SUBLEGION", "INFRALEGION", "MEGACOHORT", "SUPERCOHORT", "COHORT", "SUBCOHORT", "INFRACOHORT", "GIGAORDER", "MAGNORDER", "GRANDORDER", "MIRORDER", "SUPERORDER", "ORDER", "NANORDER", "HYPOORDER", "MINORDER", "SUBORDER", "INFRAORDER", "PARVORDER", "SUPERSECTION_ZOOLOGY", "SECTION_ZOOLOGY", "SUBSECTION_ZOOLOGY", "SUPERSERIES_ZOOLOGY", "SERIES_ZOOLOGY", "SUBSERIES_ZOOLOGY", "FALANX", "GIGAFAMILY", "MEGAFAMILY", "GRANDFAMILY", "SUPERFAMILY", "EPIFAMILY", "FAMILY", "SUBFAMILY", "INFRAFAMILY", "SUPERTRIBE", "TRIBE", "SUBTRIBE", "INFRATRIBE", "SUPRAGENERIC_NAME", "SUPERGENUS", "GENUS", "SUBGENUS", "INFRAGENUS", "DIVISION_BOTANY", "SUPERSECTION_BOTANY", "SECTION_BOTANY", "SUBSECTION_BOTANY", "SUPERSERIES_BOTANY", "SERIES_BOTANY", "SUBSERIES_BOTANY", "INFRAGENERIC_NAME", "SPECIES_AGGREGATE", "SPECIES", "INFRASPECIFIC_NAME", "GREX", "KLEPTON", "SUBSPECIES", "CULTIVAR_GROUP", "CONVARIETY", "INFRASUBSPECIFIC_NAME", "PROLES", "NATIO", "ABERRATION", "MORPH", "SUPERVARIETY", "VARIETY", "SUBVARIETY", "SUPERFORM", "FORM", "SUBFORM", "PATHOVAR", "BIOVAR", "CHEMOVAR", "MORPHOVAR", "PHAGOVAR", "SEROVAR", "CHEMOFORM", "FORMA_SPECIALIS", "LUSUS", "CULTIVAR", "MUTATIO", "STRAIN", "OTHER", "UNRANKED"]).optional(), code: z.enum(["BACTERIAL", "BOTANICAL", "CULTIVARS", "PHYTO", "VIRUS", "ZOOLOGICAL", "PHYLO"]).optional(), status: z.enum(["ACCEPTED", "PROVISIONALLY_ACCEPTED", "SYNONYM", "AMBIGUOUS_SYNONYM", "MISAPPLIED", "BARE_NAME"]).optional(), uninomial: z.string().optional(), genericName: z.string().optional(), infragenericEpithet: z.string().optional(), specificEpithet: z.string().optional(), infraspecificEpithet: z.string().optional(), type: z.string().optional(), formattedName: z.string().optional()});

export const rankedName = z.object({key: z.string().optional(), name: z.string().optional(), rank: z.enum(["SUPERDOMAIN", "DOMAIN", "SUBDOMAIN", "INFRADOMAIN", "EMPIRE", "REALM", "SUBREALM", "SUPERKINGDOM", "KINGDOM", "SUBKINGDOM", "INFRAKINGDOM", "SUPERPHYLUM", "PHYLUM", "SUBPHYLUM", "INFRAPHYLUM", "PARVPHYLUM", "MICROPHYLUM", "NANOPHYLUM", "CLAUDIUS", "GIGACLASS", "MEGACLASS", "SUPERCLASS", "CLASS", "SUBCLASS", "INFRACLASS", "SUBTERCLASS", "PARVCLASS", "SUPERDIVISION", "DIVISION_ZOOLOGY", "SUBDIVISION", "INFRADIVISION", "SUPERLEGION", "LEGION", "SUBLEGION", "INFRALEGION", "MEGACOHORT", "SUPERCOHORT", "COHORT", "SUBCOHORT", "INFRACOHORT", "GIGAORDER", "MAGNORDER", "GRANDORDER", "MIRORDER", "SUPERORDER", "ORDER", "NANORDER", "HYPOORDER", "MINORDER", "SUBORDER", "INFRAORDER", "PARVORDER", "SUPERSECTION_ZOOLOGY", "SECTION_ZOOLOGY", "SUBSECTION_ZOOLOGY", "SUPERSERIES_ZOOLOGY", "SERIES_ZOOLOGY", "SUBSERIES_ZOOLOGY", "FALANX", "GIGAFAMILY", "MEGAFAMILY", "GRANDFAMILY", "SUPERFAMILY", "EPIFAMILY", "FAMILY", "SUBFAMILY", "INFRAFAMILY", "SUPERTRIBE", "TRIBE", "SUBTRIBE", "INFRATRIBE", "SUPRAGENERIC_NAME", "SUPERGENUS", "GENUS", "SUBGENUS", "INFRAGENUS", "DIVISION_BOTANY", "SUPERSECTION_BOTANY", "SECTION_BOTANY", "SUBSECTION_BOTANY", "SUPERSERIES_BOTANY", "SERIES_BOTANY", "SUBSERIES_BOTANY", "INFRAGENERIC_NAME", "SPECIES_AGGREGATE", "SPECIES", "INFRASPECIFIC_NAME", "GREX", "KLEPTON", "SUBSPECIES", "CULTIVAR_GROUP", "CONVARIETY", "INFRASUBSPECIFIC_NAME", "PROLES", "NATIO", "ABERRATION", "MORPH", "SUPERVARIETY", "VARIETY", "SUBVARIETY", "SUPERFORM", "FORM", "SUBFORM", "PATHOVAR", "BIOVAR", "CHEMOVAR", "MORPHOVAR", "PHAGOVAR", "SEROVAR", "CHEMOFORM", "FORMA_SPECIALIS", "LUSUS", "CULTIVAR", "MUTATIO", "STRAIN", "OTHER", "UNRANKED"]).optional(), code: z.enum(["BACTERIAL", "BOTANICAL", "CULTIVARS", "PHYTO", "VIRUS", "ZOOLOGICAL", "PHYLO"]).optional()});

export const externalID = z.object({id: z.string().optional(), mainIndexID: z.string().optional(), datasetKey: z.string().optional(), clbDatasetKey: z.string().optional(), datasetTitle: z.string().optional(), parentID: z.string().optional(), scientificName: z.string().optional(), acceptedTaxonID: z.string().optional(), rank: z.string().optional(), status: z.string().optional(), recognizedVariants: z.array(z.string()).optional()});

export const diagnostics = z.object({matchType: z.enum(["EXACT", "VARIANT", "CANONICAL", "AMBIGUOUS", "NONE", "UNSUPPORTED", "HIGHERRANK"]).optional(), issues: z.array(z.enum(["TAXON_MATCH_SCIENTIFIC_NAME_ID_IGNORED", "TAXON_MATCH_TAXON_CONCEPT_ID_IGNORED", "TAXON_MATCH_TAXON_ID_IGNORED", "SCIENTIFIC_NAME_ID_NOT_FOUND", "TAXON_CONCEPT_ID_NOT_FOUND", "TAXON_ID_NOT_FOUND", "SCIENTIFIC_NAME_AND_ID_INCONSISTENT", "TAXON_MATCH_NAME_AND_ID_AMBIGUOUS"])).optional(), processingFlags: z.array(z.enum(["NO_MATCH", "MULTIPLE_MATCHES_SAME_CONFIDENCE", "LOW_CONFIDENCE", "NO_NAME_SUPPLIED", "NO_LOWEST_DENOMINATOR"])).optional(), confidence: z.number().int().optional(), note: z.string().optional(), timeTaken: z.number().int().optional(), alternatives: z.array(z.lazy(() => nameUsageMatch)).optional(), timings: z.record(z.string(), z.number().int()).optional(), matchedID: externalID.optional()});

export const status = z.object({clbDatasetKey: z.string().optional(), datasetAlias: z.string().optional(), datasetKey: z.string().optional(), status: z.string().optional(), statusCode: z.string().optional(), sourceId: z.string().optional()});

export const nameUsageMatch: z.ZodType<NameUsageMatch> = z.object({usage: usage.optional(), acceptedUsage: usage.optional(), classification: z.array(rankedName).optional(), diagnostics: diagnostics.optional(), additionalStatus: z.array(status).optional(), environments: z.array(z.string()).optional(), synonym: z.boolean().optional(), left: z.number().int().optional(), right: z.number().int().optional()});

export const validateResponse = async <Output>(
  schema: {
    readonly '~standard': {
      readonly validate: (value: unknown) => ({ readonly value: Output; readonly issues?: undefined } | { readonly issues: ReadonlyArray<{ readonly message: string; readonly path?: ReadonlyArray<PropertyKey | { readonly key: PropertyKey }> | undefined }> }) | Promise<{ readonly value: Output; readonly issues?: undefined } | { readonly issues: ReadonlyArray<{ readonly message: string; readonly path?: ReadonlyArray<PropertyKey | { readonly key: PropertyKey }> | undefined }> }>
    }
  },
  value: unknown
): Promise<Output> => {
  const result = await schema['~standard'].validate(value)

  if (result.issues !== undefined) {
    const detail = result.issues
      .map(({ message, path }) =>
        path?.length
          ? `${path.map((segment) => String(typeof segment === 'object' ? segment.key : segment)).join('.')}: ${message}`
          : message
      )
      .join('; ')

    throw new Error(`Response does not match the schema: ${detail}`, { cause: { issues: result.issues } })
  }

  return result.value
};

/**
 * Fuzzy name match service (Version 2)
 * 
 * GET /v2/species/match
 */
export const getApiV2SpeciesMatch = async (args: GetApiV2SpeciesMatchArgs, options?: GetApiV2SpeciesMatchOptions) => {
const {baseUrl = "https://api.gbif.org", fetch: fetchFn = fetch} = options ?? {}

const query = new URLSearchParams()
const headers = new Headers()
headers.set('accept', "application/json")

if (args.usageKey != null) query.append("usageKey", String(args.usageKey))
if (args.taxonID != null) query.append("taxonID", String(args.taxonID))
if (args.taxonConceptID != null) query.append("taxonConceptID", String(args.taxonConceptID))
if (args.scientificNameID != null) query.append("scientificNameID", String(args.scientificNameID))
if (args.scientificName != null) query.append("scientificName", String(args.scientificName))
if (args.scientificNameAuthorship != null) query.append("scientificNameAuthorship", String(args.scientificNameAuthorship))
if (args.taxonRank != null) query.append("taxonRank", String(args.taxonRank))
if (args.verbatimTaxonRank != null) query.append("verbatimTaxonRank", String(args.verbatimTaxonRank))
if (args.genericName != null) query.append("genericName", String(args.genericName))
if (args.specificEpithet != null) query.append("specificEpithet", String(args.specificEpithet))
if (args.infraspecificEpithet != null) query.append("infraspecificEpithet", String(args.infraspecificEpithet))
if (args.kingdom != null) query.append("kingdom", String(args.kingdom))
if (args.phylum != null) query.append("phylum", String(args.phylum))
if (args.order != null) query.append("order", String(args.order))
if (args.superfamily != null) query.append("superfamily", String(args.superfamily))
if (args.family != null) query.append("family", String(args.family))
if (args.subfamily != null) query.append("subfamily", String(args.subfamily))
if (args.tribe != null) query.append("tribe", String(args.tribe))
if (args.subtribe != null) query.append("subtribe", String(args.subtribe))
if (args.genus != null) query.append("genus", String(args.genus))
if (args.subgenus != null) query.append("subgenus", String(args.subgenus))
if (args.species != null) query.append("species", String(args.species))
for (const item of args.exclude ?? []) query.append("exclude", String(item))
if (args.strict != null) query.append("strict", String(args.strict))
if (args.verbose != null) query.append("verbose", String(args.verbose))
if (args.checklistKey != null) query.append("checklistKey", String(args.checklistKey))
if (args.class != null) query.append("class", String(args.class))

const url = `${baseUrl.replace(/\/+$/, '')}/v2/species/match${query.size > 0 ? `?${query}` : ''}`

const res = await fetchFn(url, {method: "GET", headers})

if (!res.ok) throw new Error(`Request failed with status ${res.status}`, {cause: {status: res.status, body: await res.text()}})

return validateResponse(nameUsageMatch, await res.json())
};