import {z} from 'zod'

export type GetApiApiPublicV1LivePositioningByEntryCoinArgs = {minRecentSharpe?: number | undefined, minTotalSharpe?: number | undefined, coin: string, tierType?: ('pnl' | 'pnl_recent' | 'size') | undefined, buckets?: number | undefined, range?: number | undefined};

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

export const entryBinTier = z.object({longAccounts: z.number().int(), longNotional: z.number(), shortAccounts: z.number().int(), shortNotional: z.number(), tier: z.string()});

export const entryBin = z.object({longAccounts: z.number().int(), longNotional: z.number(), priceHigh: z.number(), priceLow: z.number(), shortAccounts: z.number().int(), shortNotional: z.number(), tiers: z.array(entryBinTier).nullable()});

export const cohortEntrySummary = z.object({accounts: z.number().int(), avgEntryPx: z.number().nullable(), avgLeverage: z.number().nullable(), flatNotional: z.number(), inProfitNotional: z.number(), inProfitShare: z.number().nullable(), leverageCoveredNotional: z.number(), nearLiqNotional: z.number(), notional: z.number(), outsideRangeNotional: z.number(), pricedNotional: z.number(), side: z.string(), tier: z.string(), underwaterNotional: z.number(), unknownProfitNotional: z.number(), unpricedAccounts: z.number().int(), unpricedNotional: z.number()});

export const positioningCoverage = z.object({positions: z.number().int(), withoutEntry: z.number().int(), withoutEntryNotional: z.number(), withoutLeverage: z.number().int(), withoutTier: z.number().int()});

export const positioningSideTotals = z.object({accounts: z.number().int(), inRangeAccounts: z.number().int(), inRangeNotional: z.number(), notional: z.number(), outsideRangeAccounts: z.number().int(), outsideRangeNotional: z.number(), pricedNotional: z.number(), unpricedAccounts: z.number().int(), unpricedNotional: z.number()});

export const positioningSource = z.object({asOf: z.number().int(), cadence: z.string(), kind: z.string(), medianAgeS: z.number().int(), newestRow: z.number().int(), oldestRow: z.number().int(), table: z.string()});

export const positioningByEntryBody = z.object({$schema: z.string().optional(), binSize: z.number(), bins: z.array(entryBin).nullable(), cohortBasis: z.string(), cohorts: z.array(cohortEntrySummary).nullable(), coin: z.string(), coverage: positioningCoverage, long: positioningSideTotals, markAsOf: z.number().int(), markDivergencePct: z.number().nullable(), markMethod: z.string(), markPx: z.number().nullable(), markSource: z.string(), nearLiqPct: z.number(), notes: z.array(z.string()).nullable(), rangeHigh: z.number(), rangeLow: z.number(), short: positioningSideTotals, source: positioningSource, storedMark: z.number().nullable(), storedMarkAsOf: z.number().int(), tierType: z.string(), tierWindowDays: z.number().int().nullable()});

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 API public v1 live positioning by entry by coin
 * 
 * GET /api/public/v1/live/positioning-by-entry/{coin}
 */
export const getApiApiPublicV1LivePositioningByEntryCoin = async (args: GetApiApiPublicV1LivePositioningByEntryCoinArgs, options?: GetApiApiPublicV1LivePositioningByEntryCoinOptions) => {
const {baseUrl = "https://api.coinversa.ai", fetch: fetchFn = fetch, apiKey} = options ?? {}

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

if (args.minRecentSharpe != null) query.append("minRecentSharpe", String(args.minRecentSharpe))
if (args.minTotalSharpe != null) query.append("minTotalSharpe", String(args.minTotalSharpe))
if (args.tierType != null) query.append("tierType", String(args.tierType))
if (args.buckets != null) query.append("buckets", String(args.buckets))
if (args.range != null) query.append("range", String(args.range))
if (apiKey !== undefined) headers.set("X-API-Key", apiKey)

const url = `${baseUrl.replace(/\/+$/, '')}/api/public/v1/live/positioning-by-entry/${encodeURIComponent(String(args.coin))}${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(positioningByEntryBody, await res.json())
};