import {z} from 'zod'

export type SerieBeginAt = string;

export type SerieEndAt = string;

export type SerieID = number;

export type LeagueID = number;

export type SerieModifiedAt = string;

export type SerieName = string;

export type SerieSeason = string;

export type SerieSlug = string;

export type VideogameTitleID = number;

export type VideogameTitleSlug = string;

export type PlayerID = number;

export type TeamID = number;

export type OpponentID = PlayerID | TeamID;

export type OpponentType = 'Player' | 'Team';

export type SerieYear = number;

export type FilterOverOwSeries = {begin_at?: Array<SerieBeginAt> | undefined, end_at?: Array<SerieEndAt> | undefined, id?: Array<SerieID> | undefined, league_id?: Array<LeagueID> | undefined, modified_at?: Array<SerieModifiedAt> | undefined, name?: Array<SerieName> | undefined, season?: Array<SerieSeason> | undefined, slug?: Array<SerieSlug> | undefined, videogame_title?: (Array<VideogameTitleID | VideogameTitleSlug>) | undefined, winner_id?: Array<OpponentID> | undefined, winner_type?: Array<OpponentType> | undefined, year?: Array<SerieYear> | undefined};

export type RangeOverOwSeries = {begin_at?: Array<SerieBeginAt> | undefined, end_at?: Array<SerieEndAt> | undefined, id?: Array<SerieID> | undefined, league_id?: Array<LeagueID> | undefined, modified_at?: Array<SerieModifiedAt> | undefined, name?: Array<SerieName> | undefined, season?: Array<SerieSeason> | undefined, slug?: Array<SerieSlug> | undefined, winner_id?: Array<OpponentID> | undefined, winner_type?: Array<OpponentType> | undefined, year?: Array<SerieYear> | undefined};

export type SortOverOwSeries = Array<'begin_at' | '-begin_at' | 'end_at' | '-end_at' | 'id' | '-id' | 'league_id' | '-league_id' | 'modified_at' | '-modified_at' | 'name' | '-name' | 'season' | '-season' | 'slug' | '-slug' | 'winner_id' | '-winner_id' | 'winner_type' | '-winner_type' | 'year' | '-year'>;

export type SearchOverOwSeries = {name?: SerieName | undefined, season?: SerieSeason | undefined, slug?: SerieSlug | undefined, winner_type?: OpponentType | undefined};

export type GetApiOwSeriesPastArgs = {filter?: FilterOverOwSeries | undefined, range?: RangeOverOwSeries | undefined, sort?: SortOverOwSeries | undefined, search?: SearchOverOwSeries | undefined, page?: (number | {number?: number | undefined, size?: number | undefined}) | undefined, per_page?: number | undefined};

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

export const serieFullName = z.string();

export const serieID = z.number().int().gte(1);

export const leagueID = z.number().int().gte(1);

export const leagueModifiedAt = z.string().min(1);

export const leagueName = z.string();

export const leagueSlug = z.string().min(1);

export const baseLeague = z.object({id: leagueID, image_url: z.string().nullable(), modified_at: leagueModifiedAt, name: leagueName, slug: leagueSlug, url: z.string().nullable()});

export const serieModifiedAt = z.string().min(1);

export const serieSlug = z.string().min(1);

export const tournamentDetailedStats = z.boolean();

export const tournamentHasBracket = z.boolean();

export const tournamentID = z.number().int().gte(1);

export const tournamentLiveSupported = z.boolean();

export const tournamentModifiedAt = z.string().min(1);

export const tournamentName = z.string();

export const tournamentSlug = z.string().min(1);

export const baseTournament = z.object({begin_at: z.string().min(1).nullable(), country: z.string().nullable(), detailed_stats: tournamentDetailedStats, end_at: z.string().min(1).nullable(), has_bracket: tournamentHasBracket, id: tournamentID, league_id: leagueID, live_supported: tournamentLiveSupported, modified_at: tournamentModifiedAt, name: tournamentName, prizepool: z.string().nullable(), region: z.enum(["AF", "ASIA", "EEU", "ME", "NA", "OCE", "SA", "WEU"]).nullable(), serie_id: serieID, slug: tournamentSlug, tier: z.enum(["a", "b", "c", "d", "s", "unranked"]).nullable(), type: z.enum(["offline", "online", "online/offline"]).nullable(), winner_id: z.union([z.number().int().gte(1).nullable(), z.number().int().gte(1).nullable()]), winner_type: z.enum(["Player", "Team"]).nullable()});

export const baseTournaments = z.array(baseTournament);

export const currentVideogame = z.object({});

export const videogameTitleID = z.number().int().gte(1);

export const videogameTitleName = z.string();

export const videogameTitleSlug = z.string().min(1);

export const videogameID = z.union([z.literal(1), z.literal(3), z.literal(4), z.literal(14), z.literal(20), z.literal(22), z.literal(23), z.literal(24), z.literal(25), z.literal(26), z.literal(27), z.literal(28), z.literal(29), z.literal(30), z.literal(31), z.literal(32), z.literal(33), z.literal(34), z.literal(35), z.literal(36)]);

export const serie = z.object({begin_at: z.string().min(1).nullable(), end_at: z.string().min(1).nullable(), full_name: serieFullName, id: serieID, league: baseLeague, league_id: leagueID, modified_at: serieModifiedAt, name: z.string().nullable(), season: z.string().nullable(), slug: serieSlug, tournaments: baseTournaments, videogame: currentVideogame, videogame_title: z.object({id: videogameTitleID, name: videogameTitleName, slug: videogameTitleSlug, videogame_id: videogameID}).nullable(), winner_id: z.union([z.number().int().gte(1).nullable(), z.number().int().gte(1).nullable()]), winner_type: z.enum(["Player", "Team"]).nullable(), year: z.number().int().gte(2012).nullable()});

export const owSeries = z.array(serie);

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
};

/**
 * Get past Overwatch series
 * 
 * GET /ow/series/past
 * 
 * Also accepts auth: QueryToken
 */
export const getApiOwSeriesPast = async (args: GetApiOwSeriesPastArgs, options?: GetApiOwSeriesPastOptions) => {
const {baseUrl = "https://api.pandascore.co", fetch: fetchFn = fetch, BearerToken} = options ?? {}

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

if (args.filter != null) query.append("filter", JSON.stringify(args.filter))
if (args.range != null) query.append("range", JSON.stringify(args.range))
for (const item of args.sort ?? []) query.append("sort", String(item))
if (args.search != null) query.append("search", JSON.stringify(args.search))
if (args.page != null) query.append("page", String(args.page))
if (args.per_page != null) query.append("per_page", String(args.per_page))
if (BearerToken !== undefined) headers.set('authorization', `Bearer ${BearerToken}`)

const url = `${baseUrl.replace(/\/+$/, '')}/ow/series/past${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(owSeries, await res.json())
};