import {z} from 'zod'

export type V2TaxonomyMetadataRequestContentType = 'COMPLETE' | 'TAXIDS' | 'METADATA';

export type V2IncludeTabularHeader = 'INCLUDE_TABULAR_HEADER_FIRST_PAGE_ONLY' | 'INCLUDE_TABULAR_HEADER_ALWAYS' | 'INCLUDE_TABULAR_HEADER_NEVER';

export type V2TaxonomyMetadataRequestTableFormat = 'SUMMARY';

export type V2reportsRankType = 'NO_RANK' | 'SUPERKINGDOM' | 'DOMAIN' | 'REALM' | 'KINGDOM' | 'SUBKINGDOM' | 'SUPERPHYLUM' | 'SUBPHYLUM' | 'PHYLUM' | 'CLADE' | 'SUPERCLASS' | 'CLASS' | 'SUBCLASS' | 'INFRACLASS' | 'COHORT' | 'SUBCOHORT' | 'SUPERORDER' | 'ORDER' | 'SUBORDER' | 'INFRAORDER' | 'PARVORDER' | 'SUPERFAMILY' | 'FAMILY' | 'SUBFAMILY' | 'GENUS' | 'SUBGENUS' | 'SPECIES_GROUP' | 'SPECIES_SUBGROUP' | 'SPECIES' | 'SUBSPECIES' | 'TRIBE' | 'SUBTRIBE' | 'FORMA' | 'VARIETAS' | 'STRAIN' | 'SECTION' | 'SUBSECTION' | 'PATHOGROUP' | 'SUBVARIETY' | 'GENOTYPE' | 'SEROTYPE' | 'ISOLATE' | 'MORPH' | 'SERIES' | 'FORMA_SPECIALIS' | 'SEROGROUP' | 'BIOTYPE' | 'ACELLULAR_ROOT' | 'CELLULAR_ROOT';

export type GetApiTaxonomyTaxonTaxonsArgs = {taxons: Array<string>, returned_content?: V2TaxonomyMetadataRequestContentType | undefined, page_size?: number | undefined, include_tabular_header?: V2IncludeTabularHeader | undefined, page_token?: string | undefined, table_format?: V2TaxonomyMetadataRequestTableFormat | undefined, children?: boolean | undefined, ranks?: Array<V2reportsRankType> | undefined};

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

export const v2reportsErrorAssemblyErrorCode = z.enum(["UNKNOWN_ASSEMBLY_ERROR_CODE", "INVALID_BIOPROJECT_IDS", "NO_ASSEMBLIES_FOR_BIOPROJECTS", "INVALID_TAXON", "MISSING_SEARCH_FIELD", "INVALID_BIOSAMPLE_IDS", "NO_ASSEMBLIES_FOR_BIOSAMPLE_IDS", "NO_ASSEMBLIES_FOR_ASSEMBLY_NAMES", "INVALID_WGS_ACCESSIONS", "NO_ASSEMBLIES_FOR_WGS_ACCESSIONS"]);

export const v2reportsErrorGeneErrorCode = z.enum(["UNKNOWN_GENE_ERROR_CODE", "INCOMPLETE_LOOKUP_SYMBOL", "INVALID_TAXON_GENE_ARGUMENT"]);

export const v2reportsErrorOrganelleErrorCode = z.enum(["UNKNOWN_ORGANELLE_ERROR_CODE", "INVALID_ORGANELLE_TAXON", "NO_ORGANELLES_FOR_ACCESSION"]);

export const v2reportsErrorVirusErrorCode = z.literal("UNKNOWN_VIRUS_ERROR_CODE");

export const v2reportsErrorTaxonomyErrorCode = z.enum(["UNKNOWN_TAXONOMY_ERROR_CODE", "INVALID_TAXONOMY_TAXON"]);

export const v2reportsErrorSequenceErrorCode = z.enum(["UNKNOWN_SEQUENCE_ERROR_CODE", "INVALID_SEQUENCE_ACCESSION"]);

export const v2reportsError = z.object({assembly_error_code: v2reportsErrorAssemblyErrorCode.optional(), gene_error_code: v2reportsErrorGeneErrorCode.optional(), organelle_error_code: v2reportsErrorOrganelleErrorCode.optional(), virus_error_code: v2reportsErrorVirusErrorCode.optional(), taxonomy_error_code: v2reportsErrorTaxonomyErrorCode.optional(), sequence_error_code: v2reportsErrorSequenceErrorCode.optional(), reason: z.string().optional(), message: z.string().optional(), invalid_identifiers: z.array(z.string()).optional()});

export const v2reportsWarningGeneWarningCode = z.enum(["UNKNOWN_GENE_WARNING_CODE", "ACCESSION_VERSION_MISMATCH", "REPLACED_GENE_ID", "DISCONTINUED_GENE_ID", "UNRECOGNIZED_GENE_ID", "UNRECOGNIZED_GENE_SYMBOL", "UNRECOGNIZED_ACCESSION", "UNRECOGNIZED_TAX_TOKEN", "NO_GENE_ANNOTATION_FOUND", "ABOVE_SPECIES_TAXON"]);

export const v2reportsWarningReplacedId = z.object({requested: z.string().optional(), returned: z.string().optional()});

export const v2reportsWarning = z.object({gene_warning_code: v2reportsWarningGeneWarningCode.optional(), reason: z.string().optional(), message: z.string().optional(), replaced_id: v2reportsWarningReplacedId.optional(), unrecognized_identifier: z.string().optional()});

export const v2reportsMessage = z.object({error: v2reportsError.optional(), warning: v2reportsWarning.optional()});

export const v2reportsRankType = z.enum(["NO_RANK", "SUPERKINGDOM", "DOMAIN", "REALM", "KINGDOM", "SUBKINGDOM", "SUPERPHYLUM", "SUBPHYLUM", "PHYLUM", "CLADE", "SUPERCLASS", "CLASS", "SUBCLASS", "INFRACLASS", "COHORT", "SUBCOHORT", "SUPERORDER", "ORDER", "SUBORDER", "INFRAORDER", "PARVORDER", "SUPERFAMILY", "FAMILY", "SUBFAMILY", "GENUS", "SUBGENUS", "SPECIES_GROUP", "SPECIES_SUBGROUP", "SPECIES", "SUBSPECIES", "TRIBE", "SUBTRIBE", "FORMA", "VARIETAS", "STRAIN", "SECTION", "SUBSECTION", "PATHOGROUP", "SUBVARIETY", "GENOTYPE", "SEROTYPE", "ISOLATE", "MORPH", "SERIES", "FORMA_SPECIALIS", "SEROGROUP", "BIOTYPE", "ACELLULAR_ROOT", "CELLULAR_ROOT"]);

export const v2reportsCountType = z.enum(["COUNT_TYPE_UNSPECIFIED", "COUNT_TYPE_ASSEMBLY", "COUNT_TYPE_GENE", "COUNT_TYPE_tRNA", "COUNT_TYPE_rRNA", "COUNT_TYPE_snRNA", "COUNT_TYPE_scRNA", "COUNT_TYPE_snoRNA", "COUNT_TYPE_PROTEIN_CODING", "COUNT_TYPE_PSEUDO", "COUNT_TYPE_TRANSPOSON", "COUNT_TYPE_miscRNA", "COUNT_TYPE_ncRNA", "COUNT_TYPE_BIOLOGICAL_REGION", "COUNT_TYPE_OTHER", "COUNT_TYPE_ORGANELLE"]);

export const v2TaxonomyNodeCountByType = z.object({type: v2reportsCountType.optional(), count: z.number().int().optional()});

export const v2TaxonomyNode = z.object({tax_id: z.number().int().optional(), organism_name: z.string().optional(), common_name: z.string().optional(), genbank_common_name: z.string().optional(), acronyms: z.array(z.string()).optional(), genbank_acronym: z.string().optional(), blast_name: z.string().optional(), lineage: z.array(z.number().int()).optional(), children: z.array(z.number().int()).optional(), descendent_with_described_species_names_count: z.number().int().optional(), rank: v2reportsRankType.optional(), has_described_species_name: z.boolean().optional(), counts: z.array(v2TaxonomyNodeCountByType).optional(), min_ord: z.number().int().optional(), max_ord: z.number().int().optional(), extinct: z.boolean().optional(), genomic_moltype: z.string().optional()});

export const v2TaxonomyMatch = z.object({warnings: z.array(v2reportsWarning).optional(), errors: z.array(v2reportsError).optional(), query: z.array(z.string()).optional(), taxonomy: v2TaxonomyNode.optional()});

export const v2TaxonomyMetadataResponse = z.object({messages: z.array(v2reportsMessage).optional(), taxonomy_nodes: z.array(v2TaxonomyMatch).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
};

/**
 * Use taxonomic identifiers to get taxonomic metadata
 * 
 * GET /taxonomy/taxon/{taxons}
 */
export const getApiTaxonomyTaxonTaxons = async (args: GetApiTaxonomyTaxonTaxonsArgs, options?: GetApiTaxonomyTaxonTaxonsOptions) => {
const {baseUrl = "https://api.ncbi.nlm.nih.gov/datasets/v2", fetch: fetchFn = fetch, ApiKeyAuthHeader} = options ?? {}

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

if (args.returned_content != null) query.append("returned_content", String(args.returned_content))
if (args.page_size != null) query.append("page_size", String(args.page_size))
if (args.include_tabular_header != null) query.append("include_tabular_header", String(args.include_tabular_header))
if (args.page_token != null) query.append("page_token", String(args.page_token))
if (args.table_format != null) query.append("table_format", String(args.table_format))
if (args.children != null) query.append("children", String(args.children))
for (const item of args.ranks ?? []) query.append("ranks", String(item))
if (ApiKeyAuthHeader !== undefined) headers.set("api-key", ApiKeyAuthHeader)

const url = `${baseUrl.replace(/\/+$/, '')}/taxonomy/taxon/${encodeURIComponent(String(args.taxons))}${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(v2TaxonomyMetadataResponse, await res.json())
};