import { checkRateLimits } from './checkRateLimits.ts';
import { cleanupQueues } from './cleanupQueues.ts';
import { createRequestBody } from './createRequestBody.ts';
import { processGlobalQueue } from './processGlobalQueue.ts';
import { processQueue } from './processQueue.ts';
import { processRateLimitedPaths } from './processRateLimitedPaths.ts';
import { processRequest } from './processRequest.ts';
import { processRequestHeaders } from './processRequestHeaders.ts';
import { convertRestError } from './convertRestError.ts';
import { RestPayload, RestRateLimitedPath, RestRequest } from './rest.ts';
import { runMethod } from './runMethod.ts';
import { simplifyUrl } from './simplifyUrl.ts';
import { baseEndpoints } from '../util/constants.ts';
import { API_VERSION } from '../util/constants.ts';
import { removeTokenPrefix } from '../util/token.ts';
import { sendRequest } from './sendRequest.ts';

export function createRestManager(options: CreateRestManagerOptions) {
    const version = options.version || API_VERSION;

    if (options.customUrl) {
        baseEndpoints.BASE_URL = `${options.customUrl}/v${version}`;
    }

    return {
        // current invalid amount
        invalidRequests: 0,
        // max invalid requests allowed until ban
        maxInvalidRequests: 10000,
        // 10 minutes
        invalidRequestsInterval: 600000,
        // timer to reset to 0
        invalidRequestsTimeoutId: 0,
        // how safe to be from max
        invalidRequestsSafetyAmount: 1,
        // when first request in this period was made
        invalidRequestFrozenAt: 0,
        invalidRequestErrorStatuses: [401, 403, 429],
        version,
        token: removeTokenPrefix(options.token),
        maxRetryCount: options.maxRetryCount || 10,
        secretKey: options.secretKey || 'discordeno_best_lib_ever',
        customUrl: options.customUrl || '',
        pathQueues: new Map<
            string,
            {
                isWaiting: boolean;
                requests: {
                    request: RestRequest;
                    payload: RestPayload;
                }[];
            }
        >(),
        processingQueue: false,
        processingRateLimitedPaths: false,
        globallyRateLimited: false,
        globalQueue: [] as {
            request: RestRequest;
            payload: RestPayload;
            basicURL: string;
            urlToUse: string;
        }[],
        globalQueueProcessing: false,
        rateLimitedPaths: new Map<string, RestRateLimitedPath>(),
        debug: options.debug || function (_text: string) {},
        checkRateLimits: options.checkRateLimits || checkRateLimits,
        cleanupQueues: options.cleanupQueues || cleanupQueues,
        processQueue: options.processQueue || processQueue,
        processRateLimitedPaths: options.processRateLimitedPaths || processRateLimitedPaths,
        processRequestHeaders: options.processRequestHeaders || processRequestHeaders,
        processRequest: options.processRequest || processRequest,
        createRequestBody: options.createRequestBody || createRequestBody,
        runMethod: options.runMethod || runMethod,
        simplifyUrl: options.simplifyUrl || simplifyUrl,
        processGlobalQueue: options.processGlobalQueue || processGlobalQueue,
        convertRestError: options.convertRestError || convertRestError,
        sendRequest: options.sendRequest || sendRequest,
    };
}

export interface CreateRestManagerOptions {
    token: string;
    customUrl?: string;
    maxRetryCount?: number;
    version?: number;
    secretKey?: string;
    debug?: (text: string) => unknown;
    checkRateLimits?: typeof checkRateLimits;
    cleanupQueues?: typeof cleanupQueues;
    processQueue?: typeof processQueue;
    processRateLimitedPaths?: typeof processRateLimitedPaths;
    processRequestHeaders?: typeof processRequestHeaders;
    processRequest?: typeof processRequest;
    createRequestBody?: typeof createRequestBody;
    runMethod?: typeof runMethod;
    simplifyUrl?: typeof simplifyUrl;
    processGlobalQueue?: typeof processGlobalQueue;
    convertRestError?: typeof convertRestError;
    sendRequest?: typeof sendRequest;
}

export type RestManager = ReturnType<typeof createRestManager>;