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

import { Metadata, Endpoint, HandlerFunction } from './types';

export { Metadata, Endpoint, HandlerFunction };

import list_tasks from './tasks/list-tasks';
import delete_tasks from './tasks/delete-tasks';
import cancel_tasks from './tasks/cancel-tasks';
import get_tasks from './tasks/get-tasks';
import create_tasks_extract from './tasks/extract/create-tasks-extract';
import get_tasks_extract from './tasks/extract/get-tasks-extract';
import create_tasks_parse from './tasks/parse/create-tasks-parse';
import get_tasks_parse from './tasks/parse/get-tasks-parse';
import create_files from './files/create-files';
import list_files from './files/list-files';
import delete_files from './files/delete-files';
import content_files from './files/content-files';
import get_files from './files/get-files';
import url_files from './files/url-files';
import check_health from './health/check-health';
import url_webhooks from './webhooks/url-webhooks';
import get_file_types from './file-types/get-file-types';

export const endpoints: Endpoint[] = [];

function addEndpoint(endpoint: Endpoint) {
  endpoints.push(endpoint);
}

addEndpoint(list_tasks);
addEndpoint(delete_tasks);
addEndpoint(cancel_tasks);
addEndpoint(get_tasks);
addEndpoint(create_tasks_extract);
addEndpoint(get_tasks_extract);
addEndpoint(create_tasks_parse);
addEndpoint(get_tasks_parse);
addEndpoint(create_files);
addEndpoint(list_files);
addEndpoint(delete_files);
addEndpoint(content_files);
addEndpoint(get_files);
addEndpoint(url_files);
addEndpoint(check_health);
addEndpoint(url_webhooks);
addEndpoint(get_file_types);

export type Filter = {
  type: 'resource' | 'operation' | 'tag' | 'tool';
  op: 'include' | 'exclude';
  value: string;
};

export function query(filters: Filter[], endpoints: Endpoint[]): Endpoint[] {
  const allExcludes = filters.length > 0 && filters.every((filter) => filter.op === 'exclude');
  const unmatchedFilters = new Set(filters);

  const filtered = endpoints.filter((endpoint: Endpoint) => {
    let included = false || allExcludes;

    for (const filter of filters) {
      if (match(filter, endpoint)) {
        unmatchedFilters.delete(filter);
        included = filter.op === 'include';
      }
    }

    return included;
  });

  // Check if any filters didn't match
  const unmatched = Array.from(unmatchedFilters).filter((f) => f.type === 'tool' || f.type === 'resource');
  if (unmatched.length > 0) {
    throw new Error(
      `The following filters did not match any endpoints: ${unmatched
        .map((f) => `${f.type}=${f.value}`)
        .join(', ')}`,
    );
  }

  return filtered;
}

function match({ type, value }: Filter, endpoint: Endpoint): boolean {
  switch (type) {
    case 'resource': {
      const regexStr = '^' + normalizeResource(value).replace(/\*/g, '.*') + '$';
      const regex = new RegExp(regexStr);
      return regex.test(normalizeResource(endpoint.metadata.resource));
    }
    case 'operation':
      return endpoint.metadata.operation === value;
    case 'tag':
      return endpoint.metadata.tags.includes(value);
    case 'tool':
      return endpoint.tool.name === value;
  }
}

function normalizeResource(resource: string): string {
  return resource.toLowerCase().replace(/[^a-z.*\-_]*/g, '');
}