import stableStringify from 'fast-json-stable-stringify';import { CallApi } from '../engine/ApiFetcher.js';
import { ApiDefinitionSpec, ApiInParameterSpec, ApiOutParameterSpec, ApiSpec, AuthSpec, LookUpSpec, StatusSpec } from '../schema/WebApiSchema.js';
import { Config } from '../types/Config';
import { PagingState } from '../types/PagingState.js';
import { DataTransform, PluginContext } from '../types/PluginContext';
import { DataSource } from '../types/ReadDataSourceEvent.js';
import { Timeframe } from '../types/Timeframe.js';
import { MockSqupApi } from './MockSqupApi.js';
import { ApiTestResult } from './types.js';

export async function testApi(
    apiIn: ApiSpec,
    pagingState: PagingState,
    pluginConfig: Record<string, unknown>,
    dataSource?: DataSource,
    dataSourceConfig?: Record<string, unknown>,
    targetNodes?: unknown[],
    timeframe?: Timeframe
): Promise<ApiTestResult> {

    const startDate = new Date();
    const startTime = startDate.getTime();
    const squpApi = new MockSqupApi();
    squpApi.log.debug(`testApi starts at ${startDate.toUTCString()}`);
    let response: Response | undefined = undefined;
    let data: any = undefined;
    let newPagingState: PagingState | undefined = undefined;

    try {
        const pluginConfigId = 'config-1234567890';
        const tenantId = 'ten-1234567890';
        const plugin = { displayName: 'Plugin DisplayName', name: 'Plugin Name' };
        const headroom = 200;
        const canContinue = (delay = 0) => {
            const elapsed = Date.now() - startTime;
            const remaining = squpApi.runtimeContext.getRemainingTimeMs();
            const result = remaining - delay > headroom;
            squpApi.log.debug(`testApi canContinue: headroom = ${headroom}, delay = ${delay}, elapsed = ${elapsed}, remaining = ${remaining}, result = ${result}`);
            return result;
        };
        const squpContext = {
            log: squpApi.log,
            report: squpApi.report,
            patchConfig: squpApi.patchConfig,
            runtimeContext: squpApi.runtimeContext,
            allowInlineEval: true,
            canContinue
        };
    
        const config: Config = { id: pluginConfigId, pluginConfig, tenantId };
        const pluginContext: PluginContext = {
            plugin,
            config,
            apiDefinitions: new Map<string, ApiDefinitionSpec>(),
            lookUps: new Map<string, LookUpSpec>(),
            lookUpCache: new Map<string, any>(),
            dataTransforms: [],
            dataTransformsByName: new Map<string, DataTransform>()
        };
    
        const replacements = {
        };

        newPagingState = { ...pagingState };

        const callResult = await CallApi(
            pluginContext,
            apiIn,
            newPagingState,
            squpContext,
            replacements
        );
        response = callResult.response;
        data = callResult.data;

        const endDate = new Date();
        const endTime = endDate.getTime();
        squpApi.log.debug(`testApi ends at ${endDate.toUTCString()} - elapsed time = ${endTime - startTime}ms`);

        return {
            response: (<any>stableStringify)(response, { cycles : true }),
            data,
            pagingState: newPagingState,
            messages: squpApi.messages
        };
    } catch (e: any) {
        return {
            response: (<any>stableStringify)(response, { cycles : true }),
            exception: e instanceof Error ? e.message : e.toString(),
            data,
            pagingState: newPagingState,
            messages: squpApi.messages
        };
    }
}