import { Provider } from "../providers/provider";

import { AxiosStatic } from 'axios'
export class CloudStorageService {

    InitCloud: Boolean = false
    Keys: Map<any, any> = new Map()

    constructor(private httpService: AxiosStatic) {

    }


    setItem(key: string, value: string, type?: string) {
        return this.SetCloudStorage({
            key,
            value,
        })
    }

    getItem(key: string) {
        return new Promise((resolve, reject) => {


            if (this.InitCloud) {
                resolve(this.Keys.get(key))
            }

            setTimeout(() => {
                reject("request timeout")
            }, 20000);
            let interTime = 20;
            const interval = setInterval(() => {

                if (this.InitCloud) {
                    resolve(this.Keys.get(key))
                    clearInterval(interval)
                }




                interTime *= 2
            }, interTime);
        })


    }

    CloneCloudStorage(token: string, TimeOutNumber = 30000) {
        return new Promise((resolve, rejects) => {
            Provider.CurrentConnection.emit('cloud_storage', {
                method: 'CLONE',
                data: token
            })
            const TimeOut = setTimeout(() => {
                rejects(`request timeout : ${TimeOutNumber}`)


            }, TimeOutNumber);

            Provider.readData('cloud_storage_cloned', (back: any) => {
                resolve(back)
                clearTimeout(TimeOut)
            })
        })
    }
    LoadCloudStorage(realtime: boolean, ldata?: any, TimeOutNumber = 30000) {









        return new Promise((resolve, rejects) => {

            if (ldata) {
                this.InitCloud = true
                ldata.forEach((element: any) => {
                    if (!['setItem', 'getItem', 'removeItem', 'clear'].includes(element.key)) {
                        this.Keys.set(element.key, element.value)
                    }
                });

                

                return resolve(this)
            }

            Provider.CurrentConnection.emit('cloud_storage', {
                method: 'LOAD'
            })
            const TimeOut = setTimeout(() => {
                rejects(`request timeout : ${TimeOutNumber}`)


            }, TimeOutNumber);

            Provider.readData('cloud_storage_load', (data: any) => {

                resolve(this)
                this.InitCloud = true

                clearTimeout(TimeOut)
                data.forEach((element: any) => {
                    if (!['setItem', 'getItem', 'removeItem', 'clear'].includes(element.key)) {
                        this.Keys.set(element.key, element.value)
                    }
                });
            })
        })

    }
    protected SetCloudStorage(data: any, TimeOutNumber = 30000) {

        return new Promise((resolve, rejects) => {


            if (['setItem', 'getItem', 'removeItem', 'clear'].includes(data.key)) {

                return rejects('can not use reserved function as data')

            }
            Provider.CurrentConnection.emit('cloud_storage', {
                method: 'SET',
                data: data
            })
            const TimeOut = setTimeout(() => {
                rejects(`request timeout : ${TimeOutNumber}`)


            }, TimeOutNumber);

            Provider.readData('cloud_storage_set_' + data.key, (back: any) => {
                this.Keys.set(data.key, data.value)
                resolve(back)
                clearTimeout(TimeOut)
            })
        })

    }
}