import type { HttpMethods, DictAndT, FetchResponse } from '../types.ts';
import type { FetchError } from '../helpers/fetch-error.ts';
/**
 * Base event data payload for FetchEngine events.
 *
 * Contains common fields shared across all fetch-related events.
 *
 * @template S - Instance state type
 * @template H - Instance headers type
 * @template P - Instance params type
 */
export interface EventData<S = unknown, H = unknown, P = unknown> {
    state: S;
    url?: string | URL | undefined;
    method?: HttpMethods | undefined;
    headers?: DictAndT<H> | undefined;
    params?: DictAndT<P> | undefined;
    error?: Error | FetchError<DictAndT<H>> | undefined;
    response?: Response | undefined;
    data?: unknown;
    payload?: unknown;
    attempt?: number | undefined;
    nextAttempt?: number | undefined;
    delay?: number | undefined;
    step?: 'fetch' | 'parse' | undefined;
    status?: number | undefined;
    path?: string | undefined;
    aborted?: boolean | undefined;
    /** Unique ID for this request, flows through all events */
    requestId?: string | undefined;
    /** Timestamp (ms) when the request entered the execution pipeline */
    requestStart?: number | undefined;
    /** Timestamp (ms) when the request resolved (success, error, or abort) */
    requestEnd?: number | undefined;
}
/**
 * Event data for deduplication events.
 *
 * Extends base event data with deduplication-specific fields.
 *
 * @template S - Instance state type
 * @template H - Instance headers type
 * @template P - Instance params type
 */
export interface DedupeEventData<S = unknown, H = unknown, P = unknown> extends EventData<S, H, P> {
    /** The generated deduplication key */
    key: string;
    /** Number of callers waiting on this request (join events only) */
    waitingCount?: number | undefined;
}
/**
 * Event data for cache events.
 *
 * Extends base event data with cache-specific fields.
 *
 * @template S - Instance state type
 * @template H - Instance headers type
 * @template P - Instance params type
 */
export interface CacheEventData<S = unknown, H = unknown, P = unknown> extends EventData<S, H, P> {
    /** The generated cache key */
    key: string;
    /** Whether the cache entry is stale (SWR) */
    isStale?: boolean | undefined;
    /** Time until expiration (ms) */
    expiresIn?: number | undefined;
    /**
     * The cause of a `cache-revalidate-error`: either a transport `FetchError`
     * or a resolved `ok: false` `FetchResponse` (a non-2xx revalidation never
     * throws under resolve-on-response, so the cause isn't always an `Error`).
     */
    outcome?: FetchResponse<unknown, DictAndT<H>, DictAndT<P>> | FetchError<DictAndT<H>> | undefined;
}
/**
 * Event data for rate limit events.
 *
 * Extends base event data with rate limiting-specific fields.
 *
 * @template S - Instance state type
 * @template H - Instance headers type
 * @template P - Instance params type
 */
export interface RateLimitEventData<S = unknown, H = unknown, P = unknown> extends EventData<S, H, P> {
    /** The rate limit bucket key */
    key: string;
    /** Current tokens available in the bucket */
    currentTokens: number;
    /** Maximum capacity of the bucket */
    capacity: number;
    /** Time to wait before next token is available (ms) */
    waitTimeMs: number;
    /** When the next token will be available */
    nextAvailable: Date;
}
/**
 * Event data for retry events.
 *
 * Extends base event data with the outcome that triggered the retry — a
 * resolved `ok: false` response for an HTTP-status retry, or a rejected
 * transport `FetchError` for a transport retry. Mirrors the union
 * `shouldRetry` is invoked with.
 *
 * @template S - Instance state type
 * @template H - Instance headers type
 * @template P - Instance params type
 */
export interface RetryEventData<S = unknown, H = unknown, P = unknown> extends EventData<S, H, P> {
    /** The response or error that triggered this retry attempt. */
    outcome: FetchResponse<unknown, DictAndT<H>, DictAndT<P>> | FetchError<DictAndT<H>>;
}
/**
 * Event data for state mutation events.
 *
 * @template S - Instance state type
 */
export interface StateEventData<S = unknown> {
    /** Key that was set (for single key updates) */
    key?: keyof S | undefined;
    /** Value that was set */
    value?: S[keyof S] | Partial<S> | undefined;
    /** Previous state before the change */
    previous?: S | undefined;
    /** Current state after the change */
    current: S;
}
/**
 * Event data for property (header/param) events.
 *
 * @template T - Property type (headers or params)
 */
export interface PropertyEventData<T = unknown> {
    /** Key that was added/removed */
    key?: string | string[] | undefined;
    /** Value that was set (for add events) */
    value?: string | Partial<T> | undefined;
    /** HTTP method this change applies to (undefined = all methods) */
    method?: HttpMethods | undefined;
}
/**
 * Event data for options change events.
 */
export interface OptionsEventData {
    /** Path that was changed (for path-based sets) */
    path?: string | undefined;
    /** Value that was set */
    value?: unknown;
}
/**
 * Event map for FetchEngine - maps event names to their data types.
 *
 * Event names have been simplified by removing the `fetch-` prefix.
 * This provides cleaner API while maintaining full type safety.
 *
 * @template S - Instance state type
 * @template H - Instance headers type
 * @template P - Instance params type
 *
 * @example
 * ```typescript
 * // Subscribe to events
 * engine.on('before-request', (data) => console.log('Request starting:', data.url));
 * engine.on('cache-hit', (data) => console.log('Cache hit:', data.key));
 * engine.on('state-set', (data) => console.log('State changed:', data.current));
 * ```
 */
export interface EventMap<S = unknown, H = unknown, P = unknown> {
    'before-request': EventData<S, H, P>;
    'after-request': EventData<S, H, P>;
    'abort': EventData<S, H, P>;
    /** Transport failure or a parse failure on an `ok: true` body. Never non-2xx. */
    'error': EventData<S, H, P>;
    /** Fires for every completed exchange, any status. */
    'response': EventData<S, H, P>;
    /** Fires alongside `response` when `status` is 400-499. */
    'response-4xx': EventData<S, H, P>;
    /** Fires alongside `response` when `status` is 500-599. */
    'response-5xx': EventData<S, H, P>;
    'retry': RetryEventData<S, H, P>;
    'header-add': PropertyEventData<DictAndT<H>>;
    'header-remove': PropertyEventData<DictAndT<H>>;
    'param-add': PropertyEventData<DictAndT<P>>;
    'param-remove': PropertyEventData<DictAndT<P>>;
    'state-set': StateEventData<S>;
    'state-reset': StateEventData<S>;
    'config-change': OptionsEventData;
    'url-change': {
        url: string;
        state: S;
    };
    'dedupe-start': DedupeEventData<S, H, P>;
    'dedupe-join': DedupeEventData<S, H, P>;
    'cache-hit': CacheEventData<S, H, P>;
    'cache-stale': CacheEventData<S, H, P>;
    'cache-miss': CacheEventData<S, H, P>;
    'cache-set': CacheEventData<S, H, P>;
    'cache-revalidate': CacheEventData<S, H, P>;
    'cache-revalidate-error': CacheEventData<S, H, P>;
    'ratelimit-wait': RateLimitEventData<S, H, P>;
    'ratelimit-reject': RateLimitEventData<S, H, P>;
    'ratelimit-acquire': RateLimitEventData<S, H, P>;
    /** Terminal event for a wait that ended because the request aborted. Pairs with `ratelimit-wait`. */
    'ratelimit-abort': RateLimitEventData<S, H, P>;
}
/**
 * Helper type to extract event names from EventMap.
 */
export type EventNames<S = unknown, H = unknown, P = unknown> = keyof EventMap<S, H, P>;