// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.

import { ScenarioError } from './error';
import { FinalRequestOptions } from '../internal/request-options';
import { defaultParseResponse } from '../internal/parse';
import { type Scenario } from '../client';
import { APIPromise } from './api-promise';
import { type APIResponseProps } from '../internal/parse';
import { maybeObj } from '../internal/utils/values';

export type PageRequestOptions = Pick<FinalRequestOptions, 'query' | 'headers' | 'body' | 'path' | 'method'>;

export abstract class AbstractPage<Item> implements AsyncIterable<Item> {
  #client: Scenario;
  protected options: FinalRequestOptions;

  protected response: Response;
  protected body: unknown;

  constructor(client: Scenario, response: Response, body: unknown, options: FinalRequestOptions) {
    this.#client = client;
    this.options = options;
    this.response = response;
    this.body = body;
  }

  abstract nextPageRequestOptions(): PageRequestOptions | null;

  abstract getPaginatedItems(): Item[];

  hasNextPage(): boolean {
    const items = this.getPaginatedItems();
    if (!items.length) return false;
    return this.nextPageRequestOptions() != null;
  }

  async getNextPage(): Promise<this> {
    const nextOptions = this.nextPageRequestOptions();
    if (!nextOptions) {
      throw new ScenarioError(
        'No next page expected; please check `.hasNextPage()` before calling `.getNextPage()`.',
      );
    }

    return await this.#client.requestAPIList(this.constructor as any, nextOptions);
  }

  async *iterPages(): AsyncGenerator<this> {
    let page: this = this;
    yield page;
    while (page.hasNextPage()) {
      page = await page.getNextPage();
      yield page;
    }
  }

  async *[Symbol.asyncIterator](): AsyncGenerator<Item> {
    for await (const page of this.iterPages()) {
      for (const item of page.getPaginatedItems()) {
        yield item;
      }
    }
  }
}

/**
 * This subclass of Promise will resolve to an instantiated Page once the request completes.
 *
 * It also implements AsyncIterable to allow auto-paginating iteration on an unawaited list call, eg:
 *
 *    for await (const item of client.items.list()) {
 *      console.log(item)
 *    }
 */
export class PagePromise<
    PageClass extends AbstractPage<Item>,
    Item = ReturnType<PageClass['getPaginatedItems']>[number],
  >
  extends APIPromise<PageClass>
  implements AsyncIterable<Item>
{
  constructor(
    client: Scenario,
    request: Promise<APIResponseProps>,
    Page: new (...args: ConstructorParameters<typeof AbstractPage>) => PageClass,
  ) {
    super(
      client,
      request,
      async (client, props) =>
        new Page(client, props.response, await defaultParseResponse(client, props), props.options),
    );
  }

  /**
   * Allow auto-paginating iteration on an unawaited list call, eg:
   *
   *    for await (const item of client.items.list()) {
   *      console.log(item)
   *    }
   */
  async *[Symbol.asyncIterator](): AsyncGenerator<Item> {
    const page = await this;
    for await (const item of page) {
      yield item;
    }
  }
}

export interface AssetsCursorResponse<Item> {
  assets: Array<Item>;

  nextPaginationToken: string;
}

export interface AssetsCursorParams {
  paginationToken?: string;
}

export class AssetsCursor<Item> extends AbstractPage<Item> implements AssetsCursorResponse<Item> {
  assets: Array<Item>;

  nextPaginationToken: string;

  constructor(
    client: Scenario,
    response: Response,
    body: AssetsCursorResponse<Item>,
    options: FinalRequestOptions,
  ) {
    super(client, response, body, options);

    this.assets = body.assets || [];
    this.nextPaginationToken = body.nextPaginationToken || '';
  }

  getPaginatedItems(): Item[] {
    return this.assets ?? [];
  }

  nextPageRequestOptions(): PageRequestOptions | null {
    const cursor = this.nextPaginationToken;
    if (!cursor) {
      return null;
    }

    return {
      ...this.options,
      query: {
        ...maybeObj(this.options.query),
        paginationToken: cursor,
      },
    };
  }
}

export interface SnapshotsCursorResponse<Item> {
  nextPaginationToken: string;

  snapshots: Array<Item>;
}

export interface SnapshotsCursorParams {
  paginationToken?: string;
}

export class SnapshotsCursor<Item> extends AbstractPage<Item> implements SnapshotsCursorResponse<Item> {
  nextPaginationToken: string;

  snapshots: Array<Item>;

  constructor(
    client: Scenario,
    response: Response,
    body: SnapshotsCursorResponse<Item>,
    options: FinalRequestOptions,
  ) {
    super(client, response, body, options);

    this.nextPaginationToken = body.nextPaginationToken || '';
    this.snapshots = body.snapshots || [];
  }

  getPaginatedItems(): Item[] {
    return this.snapshots ?? [];
  }

  nextPageRequestOptions(): PageRequestOptions | null {
    const cursor = this.nextPaginationToken;
    if (!cursor) {
      return null;
    }

    return {
      ...this.options,
      query: {
        ...maybeObj(this.options.query),
        paginationToken: cursor,
      },
    };
  }
}

export interface CollectionsCursorResponse<Item> {
  collections: Array<Item>;

  nextPaginationToken: string;
}

export interface CollectionsCursorParams {
  paginationToken?: string;
}

export class CollectionsCursor<Item> extends AbstractPage<Item> implements CollectionsCursorResponse<Item> {
  collections: Array<Item>;

  nextPaginationToken: string;

  constructor(
    client: Scenario,
    response: Response,
    body: CollectionsCursorResponse<Item>,
    options: FinalRequestOptions,
  ) {
    super(client, response, body, options);

    this.collections = body.collections || [];
    this.nextPaginationToken = body.nextPaginationToken || '';
  }

  getPaginatedItems(): Item[] {
    return this.collections ?? [];
  }

  nextPageRequestOptions(): PageRequestOptions | null {
    const cursor = this.nextPaginationToken;
    if (!cursor) {
      return null;
    }

    return {
      ...this.options,
      query: {
        ...maybeObj(this.options.query),
        paginationToken: cursor,
      },
    };
  }
}

export interface JobsCursorResponse<Item> {
  jobs: Array<Item>;

  nextPaginationToken: string;
}

export interface JobsCursorParams {
  paginationToken?: string;
}

export class JobsCursor<Item> extends AbstractPage<Item> implements JobsCursorResponse<Item> {
  jobs: Array<Item>;

  nextPaginationToken: string;

  constructor(
    client: Scenario,
    response: Response,
    body: JobsCursorResponse<Item>,
    options: FinalRequestOptions,
  ) {
    super(client, response, body, options);

    this.jobs = body.jobs || [];
    this.nextPaginationToken = body.nextPaginationToken || '';
  }

  getPaginatedItems(): Item[] {
    return this.jobs ?? [];
  }

  nextPageRequestOptions(): PageRequestOptions | null {
    const cursor = this.nextPaginationToken;
    if (!cursor) {
      return null;
    }

    return {
      ...this.options,
      query: {
        ...maybeObj(this.options.query),
        paginationToken: cursor,
      },
    };
  }
}

export interface ModelsCursorResponse<Item> {
  models: Array<Item>;

  nextPaginationToken: string;
}

export interface ModelsCursorParams {
  paginationToken?: string;
}

export class ModelsCursor<Item> extends AbstractPage<Item> implements ModelsCursorResponse<Item> {
  models: Array<Item>;

  nextPaginationToken: string;

  constructor(
    client: Scenario,
    response: Response,
    body: ModelsCursorResponse<Item>,
    options: FinalRequestOptions,
  ) {
    super(client, response, body, options);

    this.models = body.models || [];
    this.nextPaginationToken = body.nextPaginationToken || '';
  }

  getPaginatedItems(): Item[] {
    return this.models ?? [];
  }

  nextPageRequestOptions(): PageRequestOptions | null {
    const cursor = this.nextPaginationToken;
    if (!cursor) {
      return null;
    }

    return {
      ...this.options,
      query: {
        ...maybeObj(this.options.query),
        paginationToken: cursor,
      },
    };
  }
}

export interface TagsCursorResponse<Item> {
  nextPaginationToken: string;

  tags: Array<Item>;
}

export interface TagsCursorParams {
  paginationToken?: string;
}

export class TagsCursor<Item> extends AbstractPage<Item> implements TagsCursorResponse<Item> {
  nextPaginationToken: string;

  tags: Array<Item>;

  constructor(
    client: Scenario,
    response: Response,
    body: TagsCursorResponse<Item>,
    options: FinalRequestOptions,
  ) {
    super(client, response, body, options);

    this.nextPaginationToken = body.nextPaginationToken || '';
    this.tags = body.tags || [];
  }

  getPaginatedItems(): Item[] {
    return this.tags ?? [];
  }

  nextPageRequestOptions(): PageRequestOptions | null {
    const cursor = this.nextPaginationToken;
    if (!cursor) {
      return null;
    }

    return {
      ...this.options,
      query: {
        ...maybeObj(this.options.query),
        paginationToken: cursor,
      },
    };
  }
}

export interface WorkflowsCursorResponse<Item> {
  nextPaginationToken: string;

  workflows: Array<Item>;
}

export interface WorkflowsCursorParams {
  paginationToken?: string;
}

export class WorkflowsCursor<Item> extends AbstractPage<Item> implements WorkflowsCursorResponse<Item> {
  nextPaginationToken: string;

  workflows: Array<Item>;

  constructor(
    client: Scenario,
    response: Response,
    body: WorkflowsCursorResponse<Item>,
    options: FinalRequestOptions,
  ) {
    super(client, response, body, options);

    this.nextPaginationToken = body.nextPaginationToken || '';
    this.workflows = body.workflows || [];
  }

  getPaginatedItems(): Item[] {
    return this.workflows ?? [];
  }

  nextPageRequestOptions(): PageRequestOptions | null {
    const cursor = this.nextPaginationToken;
    if (!cursor) {
      return null;
    }

    return {
      ...this.options,
      query: {
        ...maybeObj(this.options.query),
        paginationToken: cursor,
      },
    };
  }
}

export interface SearchHitsOffsetResponse<Item> {
  estimatedTotalHits: number;

  hits: Array<Item>;

  offset: number;
}

export interface SearchHitsOffsetParams {
  offset?: number;
}

export class SearchHitsOffset<Item> extends AbstractPage<Item> implements SearchHitsOffsetResponse<Item> {
  estimatedTotalHits: number;

  hits: Array<Item>;

  offset: number;

  constructor(
    client: Scenario,
    response: Response,
    body: SearchHitsOffsetResponse<Item>,
    options: FinalRequestOptions,
  ) {
    super(client, response, body, options);

    this.estimatedTotalHits = body.estimatedTotalHits || 0;
    this.hits = body.hits || [];
    this.offset = body.offset || 0;
  }

  getPaginatedItems(): Item[] {
    return this.hits ?? [];
  }

  nextPageRequestOptions(): PageRequestOptions | null {
    const offset = this.offset ?? 0;
    const length = this.getPaginatedItems().length;
    const currentCount = offset + length;

    const totalCount = this.estimatedTotalHits;
    if (!totalCount) {
      return null;
    }

    if (currentCount < totalCount) {
      return {
        ...this.options,
        body: {
          ...maybeObj(this.options.body),
          offset: currentCount,
        },
      };
    }

    return null;
  }
}