import ConcurrentExecutor from "../../core/process/executor/ConcurrentExecutor";
import {Asset} from "./Asset";
import {AssetTransformer} from "./AssetTransformer";
import {CrossOriginConfig} from "./CORS/CrossOriginConfig";
import {AssetLoader} from "./loaders/AssetLoader";

interface PromiseOptions {
    skip_queue: boolean
}

interface AssetManagerOptions<CTX> {
    context: CTX,
    executor?: ConcurrentExecutor
}

interface GetOptions<T> {
    type: string
    path: string
    callback?: (asset: Asset<T>) => any
    failure?: (reason: any) => any
    progress?: (current: number, total: number) => any
}

export declare class AssetManager<CTX> {
    constructor(options?: AssetManagerOptions<CTX>)

    public readonly crossOriginConfig: CrossOriginConfig

    load_concurrency: number

    startup(): void

    shutdown(immediate?: boolean): Promise<void>

    get<T>(options: GetOptions<T>): void

    promise<T>(path: string, type: string, options?: PromiseOptions): Promise<Asset<T>>

    remove(path: string, type: string): boolean

    clear(): void

    registerLoader<T>(type: string, loader: AssetLoader<T, CTX>): Promise<AssetLoader<T, CTX>>

    unregisterLoader(type: string): Promise<void>

    getLoaderByType<T>(type: string): AssetLoader<T, CTX> | undefined

    registerTransformer<T extends Asset<X>, X = any>(type: string, transformer: AssetTransformer<T>): void

    unregisterTransformer<T extends Asset<X>, X = any>(type: string, transformer: AssetTransformer<T>): boolean
}