import {
    BarcodeScannerConfiguration,
    BatchBarcodeScannerConfiguration,
    CheckRecognizerConfiguration,
    CroppingConfiguration,
    DocumentScannerConfiguration,
    FinderDocumentScannerConfiguration,
    GenericDocumentRecognizerConfiguration,
    HealthInsuranceCardScannerConfiguration,
    LicensePlateScannerConfiguration,
    MedicalCertificateRecognizerConfiguration,
    MrzScannerConfiguration,
    ScanbotSdkConfiguration,
    TextDataScannerConfiguration,
    VinScannerConfiguration
} from './configurations';
import {
    ApplyImageFilterResult,
    BarcodeScannerResult,
    BatchBarcodeScannerResult,
    CreatePDFResult,
    CroppingResult,
    DetectBarcodesOnImageResult,
    DetectBarcodesOnImagesResult,
    DetectDocumentResult,
    DocumentQualityAnalyzerResult,
    DocumentScannerResult,
    ExtractImagesFromPdfResult,
    ExtractPagesFromPdfResult,
    FinderDocumentScannerResult,
    GetFilteredDocumentPreviewUriResult,
    GetImageDataResult,
    GetLicenseInfoResult,
    GetOCRConfigsResult,
    HealthInsuranceCardScannerResult,
    InitializeSDKResult,
    LicensePlateScannerResult,
    MedicalCertificateScannerResult,
    MrzScannerResult,
    PerformOCRResult,
    RecognizeMRZResult,
    RefreshImageUrisResult,
    RemovePageResult,
    RotateImageResult,
    TextDataScannerResult,
    VinScannerResult,
    WriteTIFFResult
} from "./results";
import {
    ApplyImageFilterOnPageResult,
    CheckRecognizerResult,
    CreatePageResult,
    DetectDocumentOnPageResult,
    ImageFilterType,
    Page,
    RecognizeCheckResult,
    RotatePageResult,
    SetDocumentImageResult
} from './types';
import {
    CreatePDFArguments,
    DetectBarcodesOnImageArgs,
    DetectBarcodesOnImagesArgs,
    ExtractImagesFromPdfArguments,
    ExtractPagesFromPdfArguments,
    PerformOCRArguments,
    RecognizeCheckOnImageArgs,
    WriteTIFFArguments,
} from "./arguments";
import {ErrorCallback, ResultWrapper, SuccessCallback} from "./customTypes";
import {GenericDocumentRecognizerResult} from "./gdr/gdr-base-wrappers";

export interface ScanbotSDKUI {
    // Document Scanner RTU-UI
    startDocumentScanner(args?: {
        uiConfigs?: DocumentScannerConfiguration,
    }): Promise<ResultWrapper<DocumentScannerResult>>;

    closeDocumentScanner(): Promise<void>;

    // Finder Document Scanner RTU-UI
    startFinderDocumentScanner(args?: {
        uiConfigs?: FinderDocumentScannerConfiguration,
    }): Promise<ResultWrapper<FinderDocumentScannerResult>>;

    closeFinderDocumentScanner(): Promise<void>;

    // Cropping Screen RTU-UI
    startCroppingScreen(args: {
        page: Page,
        uiConfigs?: CroppingConfiguration,
    }): Promise<ResultWrapper<CroppingResult>>;

    closeCroppingScreen(): Promise<void>;

    // Machine Readable Zone (MRZ) Scanner RTU-UI
    startMrzScanner(args?: {
        uiConfigs?: MrzScannerConfiguration,
    }): Promise<ResultWrapper<MrzScannerResult>>;

    closeMrzScanner(): Promise<void>;

    // Barcode Scanner RTU-UI
    startBarcodeScanner(args?: {
        uiConfigs?: BarcodeScannerConfiguration,
    }): Promise<ResultWrapper<BarcodeScannerResult>>;

    closeBarcodeScanner(): Promise<void>;

    // Batch Barcode Scanner RTU-UI
    startBatchBarcodeScanner(args?: {
        uiConfigs?: BatchBarcodeScannerConfiguration,
    }): Promise<ResultWrapper<BatchBarcodeScannerResult>>;

    closeBatchBarcodeScanner(): Promise<void>;

    // Health Insurance Card (EHIC) Scanner RTU-UI
    startEHICScanner(args?: {
        uiConfigs?: HealthInsuranceCardScannerConfiguration,
    }): Promise<ResultWrapper<HealthInsuranceCardScannerResult>>;

    closeEHICScanner(): Promise<void>;

    // Text Data Scanner RTU-UI
    startTextDataScanner(args?: {
        uiConfigs?: TextDataScannerConfiguration,
    }): Promise<ResultWrapper<TextDataScannerResult>>;

    closeTextDataScanner(): Promise<void>;

    // License Plate Scanner RTU-UI
    startLicensePlateScanner(args?: {
        uiConfigs?: LicensePlateScannerConfiguration,
    }): Promise<ResultWrapper<LicensePlateScannerResult>>;

    closeLicensePlateScanner(): Promise<void>;

    // Medical Certificate Recognizer RTU-UI
    startMedicalCertificateRecognizer(args?: {
        uiConfigs?: MedicalCertificateRecognizerConfiguration,
    }): Promise<ResultWrapper<MedicalCertificateScannerResult>>;

    closeMedicalCertificateRecognizer(): Promise<void>;

    // Generic Document Recognizer RTU-UI
    startGenericDocumentRecognizer(args?: {
        uiConfigs?: GenericDocumentRecognizerConfiguration,
    }): Promise<ResultWrapper<GenericDocumentRecognizerResult>>;

    closeGenericDocumentRecognizer(): Promise<void>;

    // Check Recognizer RTU-UI
    startCheckRecognizer(args?: {
        uiConfigs?: CheckRecognizerConfiguration,
    }): Promise<ResultWrapper<CheckRecognizerResult>>;

    closeCheckRecognizer(): Promise<void>;

    // VIN Scanner RTU-UI
    startVinScanner(args?: {
        uiConfigs?: VinScannerConfiguration,
    }): Promise<ResultWrapper<VinScannerResult>>;

    closeVinScanner(): Promise<void>;
}

export interface ScanbotSDK {
    UI: ScanbotSDKUI

    initializeSdk(
        config: ScanbotSdkConfiguration,
    ): Promise<ResultWrapper<InitializeSDKResult>>;

    getLicenseInfo(): Promise<ResultWrapper<GetLicenseInfoResult>>;

    detectBarcodesOnImage(
        args: DetectBarcodesOnImageArgs,
    ): Promise<ResultWrapper<DetectBarcodesOnImageResult>>;

    detectBarcodesOnImages(
        args: DetectBarcodesOnImagesArgs,
    ): Promise<ResultWrapper<DetectBarcodesOnImagesResult>>;

    applyImageFilter(args: {
        imageFileUri: string,
        imageFilter: ImageFilterType,
    }): Promise<ResultWrapper<ApplyImageFilterResult>>;

    applyImageFilterOnPage(args: {
        page: Page,
        imageFilter: ImageFilterType,
    }): Promise<ResultWrapper<ApplyImageFilterOnPageResult>>;

    getImageData(args: {
        imageFileUri: string,
    }): Promise<ResultWrapper<GetImageDataResult>>;

    rotateImage(args: {
        imageFileUri: string,
        degrees: number,
    }): Promise<ResultWrapper<RotateImageResult>>;

    createPage(args: {
        originalImageFileUri: string
    }): Promise<ResultWrapper<CreatePageResult>>;

    removePage(args: {
        page: Page
    }): Promise<ResultWrapper<RemovePageResult>>;

    rotatePage(args: {
        page: Page,
        times: number,
    }): Promise<ResultWrapper<RotatePageResult>>;

    setDocumentImage(args: {
        page: Page,
        documentImageFileUri: string,
    }): Promise<ResultWrapper<SetDocumentImageResult>>;

    detectDocument(args: {
        imageFileUri: string,
    }): Promise<ResultWrapper<DetectDocumentResult>>;

    detectDocumentOnPage(args: {
        page: Page,
    }): Promise<ResultWrapper<DetectDocumentOnPageResult>>;

    documentQualityAnalyzer(args: {
        imageFileUri: string;
        imageSizeLimit?: number;
    }): Promise<ResultWrapper<DocumentQualityAnalyzerResult>>;

    extractImagesFromPdf(
        args: ExtractImagesFromPdfArguments,
    ): Promise<ResultWrapper<ExtractImagesFromPdfResult>>;

    extractPagesFromPdf(
        args: ExtractPagesFromPdfArguments,
    ): Promise<ResultWrapper<ExtractPagesFromPdfResult>>;

    recognizeCheckOnImage(
        args: RecognizeCheckOnImageArgs
    ): Promise<ResultWrapper<RecognizeCheckResult>>;

    recognizeMrz(args: {
        imageFileUri: string,
    }): Promise<ResultWrapper<RecognizeMRZResult>>;

    refreshImageUris(args: {
        pages: Page[];
    }): Promise<ResultWrapper<RefreshImageUrisResult>>;

    getOcrConfigs(): Promise<ResultWrapper<GetOCRConfigsResult>>;

    cleanup(): Promise<ResultWrapper<void>>;

    getFilteredDocumentPreviewUri(args: {
        page: Page,
        imageFilter: ImageFilterType,
    }): Promise<ResultWrapper<GetFilteredDocumentPreviewUriResult>>;

    performOcr(
        args: PerformOCRArguments,
    ): Promise<ResultWrapper<PerformOCRResult>>;

    createPdf(
        args: CreatePDFArguments,
    ): Promise<ResultWrapper<CreatePDFResult>>;

    writeTiff(
        args: WriteTIFFArguments,
    ): Promise<ResultWrapper<WriteTIFFResult>>;
}

export interface ScanbotSDKUICordova {
    // Document Scanner RTU-UI
    startDocumentScanner(
        successCallback: SuccessCallback<DocumentScannerResult>,
        errorCallback: ErrorCallback,
        args?: { uiConfigs?: DocumentScannerConfiguration }
    ): void

    closeDocumentScanner(
        successCallback: SuccessCallback<void>,
        errorCallback: ErrorCallback,
    ): void

    // Cropping Screen RTU-UI
    startCroppingScreen(
        successCallback: SuccessCallback<CroppingResult>,
        errorCallback: ErrorCallback,
        args?: { page: Page, uiConfigs?: CroppingConfiguration }
    ): void

    closeCroppingScreen(
        successCallback: SuccessCallback<void>,
        errorCallback: ErrorCallback,
    ): void

    // Machine Readable Zone (MRZ) Scanner RTU-UI
    startMrzScanner(
        successCallback: SuccessCallback<MrzScannerResult>,
        errorCallback: ErrorCallback,
        args?: { uiConfigs?: MrzScannerConfiguration },
    ): void

    closeMrzScanner(
        successCallback: SuccessCallback<void>,
        errorCallback: ErrorCallback,
    ): void

    // Barcode Scanner RTU-UI
    startBarcodeScanner(
        successCallback: SuccessCallback<BarcodeScannerResult>,
        errorCallback: ErrorCallback,
        args?: { uiConfigs?: BarcodeScannerConfiguration },
    ): void

    closeBarcodeScanner(
        successCallback: SuccessCallback<void>,
        errorCallback: ErrorCallback,
    ): void

    // Batch Barcode Scanner RTU-UI
    startBatchBarcodeScanner(
        successCallback: SuccessCallback<BatchBarcodeScannerResult>,
        errorCallback: ErrorCallback,
        args?: { uiConfigs?: BatchBarcodeScannerConfiguration },
    ): void

    closeBatchBarcodeScanner(
        successCallback: SuccessCallback<void>,
        errorCallback: ErrorCallback,
    ): void

    // Health Insurance Card (EHIC) Scanner RTU-UI
    startEHICScanner(
        successCallback: SuccessCallback<HealthInsuranceCardScannerResult>,
        errorCallback: ErrorCallback,
        args?: { uiConfigs?: HealthInsuranceCardScannerConfiguration },
    ): void

    closeEHICScanner(
        successCallback: SuccessCallback<void>,
        errorCallback: ErrorCallback,
    ): void

    // Text Data Scanner RTU-UI
    startTextDataScanner(
        successCallback: SuccessCallback<TextDataScannerResult>,
        errorCallback: ErrorCallback,
        args?: { uiConfigs?: TextDataScannerConfiguration },
    ): void

    closeTextDataScanner(
        successCallback: SuccessCallback<void>,
        errorCallback: ErrorCallback,
    ): void

    // License Plate Scanner RTU-UI
    startLicensePlateScanner(
        successCallback: SuccessCallback<LicensePlateScannerResult>,
        errorCallback: ErrorCallback,
        args?: { uiConfigs?: LicensePlateScannerConfiguration },
    ): void;

    closeLicensePlateScanner(
        successCallback: SuccessCallback<void>,
        errorCallback: ErrorCallback,
    ): void

    // Medical Certificate Recognizer RTU-UI
    startMedicalCertificateRecognizer(
        successCallback: SuccessCallback<MedicalCertificateScannerResult>,
        errorCallback: ErrorCallback,
        args?: { uiConfigs?: MedicalCertificateRecognizerConfiguration },
    ): void

    closeMedicalCertificateRecognizer(
        successCallback: SuccessCallback<void>,
        errorCallback: ErrorCallback,
    ): void

    // Generic Document Recognizer RTU-UI
    startGenericDocumentRecognizer(
        successCallback: SuccessCallback<GenericDocumentRecognizerResult>,
        errorCallback: ErrorCallback,
        args?: { uiConfigs?: GenericDocumentRecognizerConfiguration },
    ): void

    closeGenericDocumentRecognizer(
        successCallback: SuccessCallback<void>,
        errorCallback: ErrorCallback,
    ): void

    //Check Recognizer RTU-UI
    startCheckRecognizer(
        successCallback: SuccessCallback<CheckRecognizerResult>,
        errorCallback: ErrorCallback,
        args?: { uiConfigs?: CheckRecognizerConfiguration },
    ): void

    closeCheckRecognizer(
        successCallback: SuccessCallback<void>,
        errorCallback: ErrorCallback,
    ): void

    // Finder Document Scanner RTU-UI
    startFinderDocumentScanner(
        successCallback: SuccessCallback<FinderDocumentScannerResult>,
        errorCallback: ErrorCallback,
        args?: { uiConfigs?: FinderDocumentScannerConfiguration },
    ): void

    closeFinderDocumentScanner(
        successCallback: SuccessCallback<void>,
        errorCallback: ErrorCallback,
    ): void

    // VIN Scanner RTU-UI
    startVinScanner(
        successCallback: SuccessCallback<VinScannerResult>,
        errorCallback: ErrorCallback,
        args?: { uiConfigs?: VinScannerConfiguration },
    ): void

    closeVinScanner(
        successCallback: SuccessCallback<void>,
        errorCallback: ErrorCallback,
    ): void
}

export interface ScanbotSDKCordova {
    promisify(): ScanbotSDK

    UI: ScanbotSDKUICordova

    initializeSdk(
        successCallback: SuccessCallback<InitializeSDKResult>,
        errorCallback: ErrorCallback,
        configuration: ScanbotSdkConfiguration,
    ): void

    getLicenseInfo(
        successCallback: SuccessCallback<GetLicenseInfoResult>,
        errorCallback: ErrorCallback,
    ): void

    detectBarcodesOnImage(
        successCallback: SuccessCallback<DetectBarcodesOnImageResult>,
        errorCallback: ErrorCallback,
        args: DetectBarcodesOnImageArgs,
    ): void

    detectBarcodesOnImages(
        successCallback: SuccessCallback<DetectBarcodesOnImagesResult>,
        errorCallback: ErrorCallback,
        args: DetectBarcodesOnImagesArgs,
    ): void

    applyImageFilter(
        successCallback: SuccessCallback<ApplyImageFilterResult>,
        errorCallback: ErrorCallback,
        args: {
            imageFileUri: string,
            imageFilter: ImageFilterType,
        }
    ): void

    applyImageFilterOnPage(
        successCallback: SuccessCallback<ApplyImageFilterOnPageResult>,
        errorCallback: ErrorCallback,
        args: {
            page: Page,
            imageFilter: ImageFilterType,
        }
    ): void

    getImageData(
        successCallback: SuccessCallback<GetImageDataResult>,
        errorCallback: ErrorCallback,
        args: {
            imageFileUri: string
        }
    ): void

    rotateImage(
        successCallback: SuccessCallback<RotateImageResult>,
        errorCallback: ErrorCallback,
        args: {
            imageFileUri: string,
            degrees: number,
        }
    ): void

    createPage(
        successCallback: SuccessCallback<CreatePageResult>,
        errorCallback: ErrorCallback,
        args: {
            originalImageFileUri: string
        }
    ): void

    removePage(
        successCallback: SuccessCallback<RemovePageResult>,
        errorCallback: ErrorCallback,
        args: {
            page: Page
        }
    ): void

    rotatePage(
        successCallback: SuccessCallback<RotatePageResult>,
        errorCallback: ErrorCallback,
        args: {
            page: Page,
            times: number,
        }
    ): void

    setDocumentImage(
        successCallback: SuccessCallback<SetDocumentImageResult>,
        errorCallback: ErrorCallback,
        args: {
            page: Page,
            documentImageFileUri: string,
        }
    ): void

    detectDocument(
        successCallback: SuccessCallback<DetectDocumentResult>,
        errorCallback: ErrorCallback,
        args: {
            imageFileUri: string,
        }
    ): void

    detectDocumentOnPage(
        successCallback: SuccessCallback<DetectDocumentOnPageResult>,
        errorCallback: ErrorCallback,
        args: {
            page: Page,
        }
    ): void

    documentQualityAnalyzer(
        successCallback: SuccessCallback<DocumentQualityAnalyzerResult>,
        errorCallback: ErrorCallback,
        args: {
            imageFileUri: string,
            imageSizeLimit?: number
        }
    ): void

    extractImagesFromPdf(
        successCallback: SuccessCallback<ExtractImagesFromPdfResult>,
        errorCallback: ErrorCallback,
        args: ExtractImagesFromPdfArguments,
    ): void

    extractPagesFromPdf(
        successCallback: SuccessCallback<ExtractPagesFromPdfResult>,
        errorCallback: ErrorCallback,
        args: ExtractPagesFromPdfArguments,
    ): void

    recognizeCheckOnImage(
        successCallback: SuccessCallback<RecognizeCheckResult>,
        errorCallback: ErrorCallback,
        args: RecognizeCheckOnImageArgs
    ): void

    recognizeMrz(
        successCallback: SuccessCallback<RecognizeMRZResult>,
        errorCallback: ErrorCallback,
        args: {
            imageFileUri: string
        }
    ): void

    refreshImageUris(
        successCallback: SuccessCallback<RefreshImageUrisResult>,
        errorCallback: ErrorCallback,
        args: {
            pages: Page[]
        }
    ): void

    getOcrConfigs(
        successCallback: SuccessCallback<GetOCRConfigsResult>,
        errorCallback: ErrorCallback,
    ): void

    cleanup(
        successCallback: SuccessCallback<void>,
        errorCallback: ErrorCallback,
    ): void

    getFilteredDocumentPreviewUri(
        successCallback: SuccessCallback<GetFilteredDocumentPreviewUriResult>,
        errorCallback: ErrorCallback,
        args: {
            page: Page,
            filter: ImageFilterType,
        }
    ): void

    performOcr(
        successCallback: SuccessCallback<PerformOCRResult>,
        errorCallback: ErrorCallback,
        args: PerformOCRArguments
    ): void

    createPdf(
        successCallback: SuccessCallback<CreatePDFResult>,
        errorCallback: ErrorCallback,
        imageFileUris: string[],
        args: CreatePDFArguments
    ): void

    writeTiff(
        successCallback: SuccessCallback<WriteTIFFResult>,
        errorCallback: ErrorCallback,
        args: WriteTIFFArguments,
    ): void
}

declare var SDK: ScanbotSDKCordova

export default SDK
export * from './arguments';
export * from './types';
export * from './results';
export * from './configurations';
export * from './customTypes';
export * from './gdr/generic_document_wrappers';
export * from './gdr/gdr-base-wrappers';
export * from './gdr/generic_document_types';