import request from 'request';
import { Utils } from './utils';
export class H2I {
    public static getImg(config: {
        html: string,
        bucketId: number,
        waitTime?: number,
        transparentBg?: boolean,
        type?: 'png' | 'jpg',
        debug?: boolean
    }): Promise<string> {
        return new Promise(async (resolve) => {
            let url = await this.getImgTryOnce(config)
            if (url?.length) {
                return resolve(url?.replace(/##noimg##/gi,''));
            }
            let retryMap: { [key: number]: number } = {
                50: 10, 500: 10, 1000: 10, 2000: 10, 5000: 10, 20000: 5
            }
            for (let k in retryMap) {
                for (let i = 0; i < Number(retryMap[k]); i++) {
                    await Utils.wait(Number(k));
                    url = await this.getImgTryOnce(config)
                    if (url?.length) {
                        return resolve(url?.replace(/##noimg##/gi,''));
                    }
                }
            }

            return resolve(url?.replace(/##noimg##/gi,''));

        })

    }


    public static getImgTryOnce(config: {
        html: string,
        bucketId: number,
        waitTime?: number,
        transparentBg?: boolean,
        type?: 'png' | 'jpg',
        debug?: boolean
    }): Promise<string> {
        return new Promise((resolve) => {
            request({
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                url: `https://mdh.ezobooks.in/html2image/${config?.bucketId}`,
                body: JSON.stringify({
                    htmlStr: config.html,
                    waitTime: config?.waitTime || 0,
                    transparentBg: config?.transparentBg || false,
                    type: config?.type || 'png',
                })
            }, async (error, res) => {
                if (error) {
                    if (config?.debug === true) { console.error('H2I:95', error); }
                    return resolve('');
                }
                if (res?.body) {
                    if (res?.body?.indexOf("502 Bad Gateway") > -1) {
                        return resolve('');
                    }

                    if (res?.body?.indexOf("504 Gateway Time-out") > -1) {
                        return resolve('');
                    }

                    if (res?.body?.indexOf("504 Gateway Timeout") > -1) {
                        return resolve('');
                    }

                    try {
                        let obj = JSON.parse(res?.body);
                        if (obj?.status == 'success' && obj?.image?.length) {
                            let finalUrl = obj?.image.replace(/mdh.ezobooks/, 'mdi.ezobooks')?.replace(/md1.ezobooks/, 'mdi.ezobooks');
                            finalUrl=obj?.imagePublicUrl
                            
                            return resolve(finalUrl);
                        } else {
                            if(obj?.noretry){
                                return resolve('##noimg##');
                            }
                            if (config?.debug === true) { console.error('H2I:105', obj); }

                            return resolve('');

                        }
                    } catch (err) {
                        if (config?.debug === true) { console.error('H2I:111', res?.body, err); }

                        return resolve('');

                    }
                }
                return resolve('');
            })

        })

    }

    public static getImgFromBase64(config: {
        base64Str: string,
        bucketId: number,
        type?: 'png' | 'jpg',
        debug?: boolean
    }): Promise<string> {
        return new Promise(async (resolve) => {
            let url = await this.getImgFromBase64TryOnce(config)
            if (url?.length) {
                return resolve(url);
            }
            let retryMap: { [key: number]: number } = {
                50: 10, 500: 10, 1000: 10, 2000: 10, 5000: 10, 20000: 5
            }
            for (let k in retryMap) {
                for (let i = 0; i < Number(retryMap[k]); i++) {
                    await Utils.wait(Number(k));
                    url = await this.getImgFromBase64TryOnce(config)
                    if (url?.length) {
                        return resolve(url);
                    }
                }
            }

            return resolve(url);

        })

    }


    public static getImgFromBase64TryOnce(config: {
        base64Str: string,
        bucketId: number,
        type?: 'png' | 'jpg',
        debug?: boolean
    }): Promise<string> {
        return new Promise((resolve) => {
            request({
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                url: `https://mdh.ezobooks.in/base642image/${config?.bucketId}`,
                body: JSON.stringify({
                    base64Str: config.base64Str,
                    type: config?.type || 'png',
                })
            }, (error, res) => {
                if (error) {
                    if (config?.debug === true) { console.error('H2I:245', error); }
                    return resolve('');
                }
                if (res?.body) {
                    if (res?.body?.indexOf("502 Bad Gateway") > -1) {
                        return resolve('');
                    }

                    if (res?.body?.indexOf("504 Gateway Time-out") > -1) {
                        return resolve('');
                    }

                    if (res?.body?.indexOf("504 Gateway Timeout") > -1) {
                        return resolve('');
                    }

                    try {
                        let obj = JSON.parse(res?.body);
                        if (obj?.status == 'success' && obj?.image?.length) {
                            let finalUrl = obj?.image.replace(/mdh.ezobooks/, 'mdi.ezobooks')?.replace(/md1.ezobooks/, 'mdi.ezobooks');
                            if(obj?.imagePublicUrl){
                                finalUrl=obj?.imagePublicUrl
                            }
                            return resolve(finalUrl);

                        } else {
                            if (config?.debug === true) { console.error('H2I:268', obj); }

                            return resolve('');

                        }
                    } catch (err) {
                        if (config?.debug === true) { console.error('H2I:274', res?.body, err); }

                        return resolve('');

                    }
                }
                return resolve('');
            })

        })

    }

    public static getPdf(config: {
        html: string,
        bucketId: number,
        waitTime?: number,
        debug?: boolean
    }): Promise<string> {
        return new Promise(async (resolve) => {
            let url = await this.getPdfTryOnce(config)
            if (url?.length) {
                return resolve(url);
            }
            let retryMap: { [key: number]: number } = {
                50: 10, 500: 10, 1000: 10, 2000: 10, 5000: 10, 20000: 5
            }
            for (let k in retryMap) {
                for (let i = 0; i < Number(retryMap[k]); i++) {
                    await Utils.wait(Number(k));
                    url = await this.getPdfTryOnce(config)
                    if (url?.length) {
                        return resolve(url);
                    }
                }
            }

            return resolve(url);

        })

    }

    public static getPdfTryOnce(config: {
        html: string,
        bucketId: number,
        waitTime?: number,
        debug?: boolean
    }): Promise<string> {
        return new Promise((resolve) => {
            request({
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                url: `https://mdh.ezobooks.in/html2pdf/${config.bucketId}`,
                body: JSON.stringify({
                    htmlStr: config.html,
                    waitTime: config?.waitTime || 0
                })
            }, (error, res) => {
                if (error) {
                    if (config?.debug === true) { console.error('H2I:262', error); }
                    return resolve('');
                }
                if (res?.body) {
                    if (res?.body?.indexOf("502 Bad Gateway") > 0) {
                        return resolve('');
                    }
                    try {
                        let obj = JSON.parse(res?.body);
                        if (obj?.status == 'success' && obj?.image?.length) {
                            let finalUrl = obj?.image.replace(/mdh.ezobooks/, 'mdi.ezobooks')?.replace(/md1.ezobooks/, 'mdi.ezobooks');
                            if(obj?.publicUrl){
                                finalUrl=obj?.publicUrl
                            }
                            return resolve(finalUrl);

                        } else {
                            if (config?.debug === true) { console.error('H2I:272', obj); }

                            return resolve('');

                        }
                    } catch (err) {
                        if (config?.debug === true) { console.error('H2I:278', err); }

                        return resolve('');

                    }
                }
                return resolve('');
            })

        })

    }




    public static compileVideoByCommand(config: {
        requestId: string,
        ffmpegCommand: string,
        mediaMap: {
            [key: string]: string | {
                url?:string,
                content?:string,
                cache?:boolean
            }
        }
        debug?: boolean,
        bucketId?:string
    }): Promise<string> {
        return new Promise(async (resolve) => {
            let url = '';
            url=await this.compileVideoByCommandTryOnce(config)
            if (url?.length) {
                return resolve(url);
            }
            let retryMap: { [key: number]: number } = {
                50: 1, 500: 1, 1000: 1
            }
            let cntr=0;
            for (let k in retryMap) {
                for (let i = 0; i < Number(retryMap[k]); i++) {
                    ++cntr;
                    if(cntr>5){
                        console.log("Retry",k,cntr,JSON.stringify(config));
                    }
                    await Utils.wait(Number(k));
                    url = await this.compileVideoByCommandTryOnce(config)
                    if (url?.length) {
                        return resolve(url);
                    }
                }
            }

            return resolve(url);

        })

    }

    public static compileVideoByCommandTryOnce(config: {
        requestId: string,
        ffmpegCommand: string,
        mediaMap: {
            [key: string]: string | {
                url?:string,
                content?:string,
                cache?:boolean
            }
        }
        debug?: boolean,
        bucketId?:string
    }): Promise<string> {
        return new Promise((resolve) => {
            request({
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                url: `https://vdh.ezobooks.in/vd/compileVideoCommand`,
                body: JSON.stringify({
                    requestId: config.requestId,
                    ffmpegCommand: config.ffmpegCommand,
                    mediaMap: config.mediaMap,
                    bucketId: config.bucketId
                })
            }, (error, res) => {
                if (error) {
                    if (config?.debug === true) { console.error('H2I:95', error); }
                    return resolve('');
                }
                if (res?.body) {
                    try {
                        let obj = JSON.parse(res?.body);
                        if (obj?.status == 'success' && obj?.url?.length) {
                            let finalUrl = obj?.url?.replace(/mdh.ezobooks/, 'mdi.ezobooks')?.replace(/md1.ezobooks/, 'mdi.ezobooks');
                            return resolve(finalUrl);

                        } else {
                            if (config?.debug === true) { console.error('H2I:105', obj); }

                            return resolve('');

                        }
                    } catch (err) {
                        if (config?.debug === true) { console.error('H2I:111', err); }

                        return resolve('');

                    }
                }
                return resolve('');
            })

        })

    }


}