import {
    InfinityMintDeployedProject,
    InfinityMintProjectPathExport,
    KeyValue,
} from 'infinitymint/dist/app/interfaces';
import { getConfig } from '../main';
import { getApiEndpoint, log } from '../utils/helpers';

const cache: KeyValue = {};

export const fetchImport = async (
    project: InfinityMintDeployedProject,
    pathExport: InfinityMintProjectPathExport,
    abortController?: AbortController,
    onlyUseIPFS: boolean = false,
    onlyUseAPI: boolean = false,
    onlyUsePublic: boolean = false,
    useCache: boolean = true
): Promise<Blob> => {
    let config = getConfig();
    let { useInfinityMintApi, forceIPFS, usePublic, useIPFS, forcePublic } =
        config.imports || {
            usePublic: true,
            useIPFS: true,
            useInfinityMintApi: true,
        };

    let source = (project as any)?.source?.base;
    let key = pathExport.key;
    let url = getApiEndpoint(
        `/imports/get?source=${source}&key=${key}&version=${
            project?.version?.version || '1.0.0'
        }`
    );

    if (
        useCache &&
        cache[`${project.name}_${project.version.version}_${pathExport.key}`]
    ) {
        log(
            'using cache => ' +
                `${project.name}_${project.version.version}_${pathExport.key}`
        );
        return cache[
            `${project.name}_${project.version.version}_${pathExport.key}`
        ];
    }

    if (
        (forceIPFS || onlyUseIPFS || useIPFS) &&
        (pathExport as any)?.locations?.ipfs &&
        !forcePublic &&
        !onlyUsePublic &&
        !onlyUseAPI
    ) {
        let location = (pathExport as any).locations.ipfs;
        url = `${location.url}${location.hash}/?filename=${location.filename}`;
    }

    if (
        (forcePublic || onlyUsePublic || usePublic || !useInfinityMintApi) &&
        project.imports[key] !== undefined &&
        !onlyUseIPFS &&
        !onlyUseAPI
    ) {
        url = '/imports' + project.bundles.imports[project.imports[key]].bundle;
    }

    log('fetching import', url, {
        source,
        key,
        version: project.version.version,
        useInfinityMintApi,
        forceIPFS,
        usePublic,
        useIPFS,
        forcePublic,
        onlyUseAPI,
        onlyUseIPFS,
        onlyUsePublic,
    });

    let fallBackToLocal = false;
    try {
        let resolvedImport = await fetch(url, {
            signal: abortController?.signal,
            method: 'GET',
        });

        if (resolvedImport.status !== 200) {
            console.error(
                (await resolvedImport.json()).message || 'Internal Server Error'
            );
            fallBackToLocal = true;
        } else if (resolvedImport.status === 200) {
            let result = await resolvedImport.blob();

            if (useCache)
                cache[
                    `${project.name}_${project.version.version}_${pathExport.key}`
                ] = result;

            return result;
        }
    } catch (error) {
        console.error(error);
        fallBackToLocal = true;
    }

    if (fallBackToLocal && !onlyUsePublic) {
        log('falling back to local import');
        let result = await fetchImport(
            project,
            pathExport,
            abortController,
            false,
            false,
            true
        );

        if (useCache)
            cache[
                `${project.name}_${project.version.version}_${pathExport.key}`
            ] = result;

        return result;
    } else
        throw new Error(
            'Could not fetch import from InfinityMint API or IPFS or Public'
        );
};