import {AllFileContext, CryptContentResult, SencondPassBusket, TimeData, UploadResult} from "../Model";
import {getPathDigest} from "../Crypt/Encrypt";
import {CryptUploadDispatcher} from "../CryptUploadTack/CryptUploadDispatcher";
import {SencondPassBucket} from "../StreamCache/SencondPassCache";
import {FigureSencondPassBucket} from "../StreamCache/FigureSencondPassCache";
import {HeadshotSencondPassBucket} from "../StreamCache/HeadshotSencondPassCache";
import {ImageSencondPassBucket} from "../StreamCache/ImageSencondPassCache";
import {FileSencondPassBucket} from "../StreamCache/FileSencondPassCache";
import {VedioSencondPassBucket} from "../StreamCache/VedioSencondPassCache";
import IUploadTask from "../CryptUploadTack/ICryptUploadTask";
import {stringToUint8Array} from "../utils/TransferFunction";

/**
 * 秒传逻辑集合
 * 用静态的方式声明 保证不会被多次初始化
 * */
export class SencondPass {
    private fromHexString = hexString =>
        new Uint8Array(hexString.match(/.{1,2}/g).map(byte => parseInt(byte, 16)));
    /**
     * 秒传信息存储
     * @function HeadshotSencondPassStorage 头像信息存储
     * @function FigureSencondPassStorage 插图信息存储
     * @function ImageSencondPassStorage 图片信息存储
     * @function FileSencondPassStorage 文件信息存储
     * @function VedioSencondPassStorage 视频信息存储
     * @function default 信息异常处理
     * @return null 信息异常处理
     * */
    public async SencondPassStorage(uploadRet: UploadResult[], timeData: TimeData, file: string, _bucket: string, allFileInfo: AllFileContext) {
        console.log("allFileInfo.mediaType", allFileInfo.mediaType);
        switch (allFileInfo.mediaType) {
            case 'headshot':
                return this.HeadshotSencondPassStorage(uploadRet, timeData, file, _bucket, allFileInfo);
            case 'figure':
                return this.FigureSencondPassStorage(uploadRet, timeData, file, _bucket, allFileInfo);
            case 'images':
                return this.ImageSencondPassStorage(uploadRet, timeData, file, _bucket, allFileInfo);
            case 'other' || 'audio':
                return this.FileSencondPassStorage(uploadRet, timeData, file, _bucket, allFileInfo);
            case 'video':
                return this.VedioSencondPassStorage(uploadRet, timeData, file, _bucket, allFileInfo);
            default :
                return null;
        }
        return null;
    }

    private async FigureSencondPassStorage(uploadRet: UploadResult[], timeData: TimeData, file: string, _bucket: string, allFileInfo: AllFileContext) {
        /**
         * 获取加密信息
         * @param filesize 文件流大小
         * @param digest 摘要
         * @param key key
         * @param obejctkey 只有文件上传有
         * */
        let cacheBucket = [];
        const dbCache = await CryptUploadDispatcher._cacheManager.getFigureSencondPassCache();
        for (const result of uploadRet) {
            const index = uploadRet.indexOf(result);
            if (result.Error != 0){
                cacheBucket[index] = {
                    Error:result.Error
                }
            }else {
                try {
                    // 建立数据流缓存，下次直接秒传
                    let time = `${timeData.y}/${timeData.m}/${timeData.d} ${timeData.h}:${timeData.min}:${timeData.s}`;
                    console.log("秒传摘要信息",result.digest);
                    cacheBucket[index] = {
                        plain_sha: result.digest,
                        creation_time: time,
                        duration_time: allFileInfo.duration.toString(),
                        bucket_name: _bucket,
                        Complete: {
                            Bucket: result.Bucket,
                            Key: result.Key,
                            Url: result.Url,
                            cryptInfo: {
                                fileSize: result.cryptInfo.fileSize,
                                key: result.cryptInfo.key,
                                digest: result.cryptInfo.digest,
                                objectKeyPartial: result.cryptInfo.objectKeyPartial
                            }
                        },
                        storage_time: (allFileInfo.today.getTime() / (1000 * 60)).toString()
                    }
                    if (await dbCache.query(this.fromHexString(result.cryptInfo.digest).toString()) == undefined) {
                        dbCache.insert(cacheBucket[index]).then().catch();
                    }
                } catch (e) {
                    console.debug("参数异常", e);
                }
            }
        }
        return cacheBucket;
    }

    private async FileSencondPassStorage(uploadRet: UploadResult[], timeData: TimeData, file: string, _bucket: string, allFileInfo: AllFileContext) {
        /**
         * 获取加密信息
         * @param filesize 文件流大小
         * @param digest 摘要
         * @param key key
         * @param obejctkey 只有文件上传有
         * */
        let cacheBucket = [];
        const dbCache = await CryptUploadDispatcher._cacheManager.getFileSencondPassCache();
        for (const result of uploadRet) {
            const index = uploadRet.indexOf(result);
            // 建立数据流缓存，下次直接秒传
            let time = `${timeData.y}/${timeData.m}/${timeData.d} ${timeData.h}:${timeData.min}:${timeData.s}`;
            console.log("result.digest",allFileInfo.digest);
            if (allFileInfo.digest != undefined) {
                try {
                    cacheBucket[index] = {
                        plain_sha: allFileInfo.digest.toString(),
                        creation_time: time,
                        duration_time: allFileInfo.duration.toString(),
                        bucket_name: _bucket,
                        Complete: {
                            Bucket: result.Bucket,
                            Key: result.Key,
                            Url: result.Url,
                            cryptInfo: {
                                fileSize: result.cryptInfo.fileSize,
                                key: result.cryptInfo.key,
                                digest: result.cryptInfo.digest,
                            }
                        },
                        storage_time: (allFileInfo.today.getTime() / (1000 * 60)).toString()
                    }
                    if (await dbCache.query(allFileInfo.digest.toString()) == undefined) {
                        dbCache.insert(cacheBucket[index]).then().catch();
                    }
                } catch (e) {
                    console.debug("参数异常", e);
                }
            }
        }
        return cacheBucket;
    }

    private async HeadshotSencondPassStorage(uploadRet: UploadResult[], timeData: TimeData, file: string, _bucket: string, allFileInfo: AllFileContext) {
        /**
         * 获取加密信息
         * @param filesize 文件流大小
         * @param digest 摘要
         * @param key key
         * @param obejctkey 只有文件上传有
         * */
        let cacheBucket = [];
        const dbCache = await CryptUploadDispatcher._cacheManager.getHeadshotSencondPassCache();
        for (const result of uploadRet) {
            const index = uploadRet.indexOf(result);
            let time = `${timeData.y}/${timeData.m}/${timeData.d} ${timeData.h}:${timeData.min}:${timeData.s}`;
            if (result.cryptInfo.digest.toString() != undefined) {
                try {
                    cacheBucket[index] = {
                        plain_sha: result.digest,
                        creation_time: time,
                        duration_time: allFileInfo.duration.toString(),
                        bucket_name: _bucket,
                        Complete: {
                            Bucket: result.Bucket,
                            Key: result.Key,
                            Url: result.Url,
                            cryptInfo: {
                                fileSize: result.cryptInfo.fileSize,
                                key: result.cryptInfo.key,
                                digest: result.cryptInfo.digest,

                            }
                        },
                        storage_time: (allFileInfo.today.getTime() / (1000 * 60)).toString()
                    }
                    if (await dbCache.query(this.fromHexString(result.cryptInfo.digest).toString()) == undefined) {
                        dbCache.insert(cacheBucket[index]).then().catch();
                    }
                } catch (e) {
                    console.debug("参数异常", e);
                }
            }
        }
        return cacheBucket;
    }

    private async ImageSencondPassStorage(uploadRet: UploadResult[], timeData: TimeData, file: string, _bucket: string, allFileInfo: AllFileContext) {
        /**
         * 获取加密信息
         * @param filesize 文件流大小
         * @param digest 摘要
         * @param key key
         * @param obejctkey 只有文件上传有
         * */
        let cacheBucket = [];
        const dbCache = await CryptUploadDispatcher._cacheManager.getImageSencondPassCache();
        for (const result of uploadRet) {
            const index = uploadRet.indexOf(result);
            let time = `${timeData.y}/${timeData.m}/${timeData.d} ${timeData.h}:${timeData.min}:${timeData.s}`;
            try {
                cacheBucket[index] = {
                    plain_sha: result.digest,
                    creation_time: time,
                    duration_time: allFileInfo.duration.toString(),
                    bucket_name: _bucket,
                    Complete: {
                        Bucket: result.Bucket,
                        Key: result.Key,
                        Url: result.Url,
                        cryptInfo: {
                            fileSize: result.cryptInfo.fileSize,
                            key: result.cryptInfo.key,
                            digest: result.cryptInfo.digest,
                        }
                    },
                    storage_time: (allFileInfo.today.getTime() / (1000 * 60)).toString()
                }
                if (await dbCache.query(this.fromHexString(result.cryptInfo.digest).toString()) == undefined) {
                    dbCache.insert(cacheBucket[index]).then().catch();
                }
            } catch (e) {
                console.debug("参数异常", e);
            }
        }
        ;
        return cacheBucket;
    }

    private async VedioSencondPassStorage(uploadRet: UploadResult[], timeData: TimeData, file: string, _bucket: string, allFileInfo: AllFileContext) {
        /**
         * 获取加密信息
         * @param filesize 文件流大小
         * @param digest 摘要
         * @param key key
         * @param obejctkey 只有文件上传有
         * */
        let cacheBucket ;
        const dbCache = await CryptUploadDispatcher._cacheManager.getVedioSencondPassCache();

        // 建立数据流缓存，下次直接秒传
        let time = `${timeData.y}/${timeData.m}/${timeData.d} ${timeData.h}:${timeData.min}:${timeData.s}`;
        try {
            cacheBucket = {
                plain_sha: new Uint8Array(allFileInfo.digest).toString(),
                creation_time: time,
                duration_time: allFileInfo.duration.toString(),
                bucket_name: _bucket,
                Complete: {
                    //Bucket: result.Bucket,
                    Key: uploadRet[0].Key,
                    Url: uploadRet[0].Url,
                    cryptInfo: {
                        fileSize: uploadRet[0].cryptInfo.fileSize,
                        key: uploadRet[0].cryptInfo.key,
                        digest: uploadRet[0].cryptInfo.digest,
                        objectKeyPartial: uploadRet[0].cryptInfo.objectKeyPartial
                    }
                },
                CoverComplete:{
                    //Bucket: result.Bucket,
                    Key: uploadRet[1].Key,
                    Url: uploadRet[1].Url,
                    cryptInfo: {
                        fileSize: uploadRet[1].cryptInfo.fileSize,
                        key: uploadRet[1].cryptInfo.key,
                        digest: uploadRet[1].cryptInfo.digest,
                        objectKeyPartial: uploadRet[1].cryptInfo.objectKeyPartial
                    }
                },
                storage_time: (allFileInfo.today.getTime() / (1000 * 60)).toString()
            }
            if (await dbCache.query(new Uint8Array(allFileInfo.digest).toString()) == undefined) {
                dbCache.insert(cacheBucket).then().catch();
            }
        } catch (e) {
            console.debug("参数异常", e);
        }

        return cacheBucket;
    }

    /**
     * 查询秒传
     * @function FigureSencondPassQuery 插图秒传查询
     * @function FileSencondPassQuery 文件秒传查询
     * @function HeadshotSencondPassQuery 头像秒传查询
     * @function ImageSencondPassQuery 图片秒传查询
     * @function VedioSencondPassQuery  视频秒传查询
     * */
    public async SencondPassQuery(mediatype: string, file: string, today): Promise<{ boolean: boolean, StreamBucket: any }> {
        //console.log("mediatype:",mediatype);
        switch (mediatype) {
            case 'headshot':
                return this.HeadshotSencondPassQuery(file, today);
            case 'figure':
                return this.FigureSencondPassQuery(file, today);
            case 'images':
                return this.ImageSencondPassQuery(file, today);
            case 'other' || 'audio':
                return this.FileSencondPassQuery(file, today);
            case 'video':
                return this.VedioSencondPassQuery(file, today);
            default :
                return null;
        }
        return null;
    }

    private async FigureSencondPassQuery(digest: string, today): Promise<{ boolean: boolean, StreamBucket: any }> {
        let recordbucket: FigureSencondPassBucket | undefined;
        let streamNeedUpload = true;
        try {
            console.log("摘要：",digest);
            const dbCache = await CryptUploadDispatcher._cacheManager.getFigureSencondPassCache();
            recordbucket = await dbCache.query(digest);
        } catch (e) {
            console.debug("参数异常", e);
        }
        return {StreamBucket: recordbucket, boolean: streamNeedUpload};
    }

    private async FileSencondPassQuery(digest: string, today): Promise<{ boolean: boolean, StreamBucket: any }> {
        let recordbucket: FileSencondPassBucket | undefined;
        let streamNeedUpload = true;
        try {
            const dbCache = await CryptUploadDispatcher._cacheManager.getFileSencondPassCache();
            recordbucket = await dbCache.query(digest);
        } catch (e) {
            console.debug("参数异常", e);
        }
        return {StreamBucket: recordbucket, boolean: streamNeedUpload};
    }

    private async HeadshotSencondPassQuery(digest: string, today): Promise<{ boolean: boolean, StreamBucket: any }> {
        let recordbucket: HeadshotSencondPassBucket | undefined;
        let streamNeedUpload = true;
        try {
            const dbCache = await CryptUploadDispatcher._cacheManager.getHeadshotSencondPassCache();
            recordbucket = await dbCache.query(digest);
            this.QueryIsTimeOut(recordbucket, streamNeedUpload, dbCache, today);
        } catch (e) {
            console.debug("参数异常", e);
        }
        return {StreamBucket: recordbucket, boolean: streamNeedUpload};
    }

    private async ImageSencondPassQuery(digest: string, today): Promise<{ boolean: boolean, StreamBucket: any }> {
        let recordbucket: ImageSencondPassBucket | undefined;
        let streamNeedUpload = true;
        try {
            const dbCache = await CryptUploadDispatcher._cacheManager.getImageSencondPassCache();
            recordbucket = await dbCache.query(digest);
        } catch (e) {
            console.debug("参数异常", e);
        }
        return {StreamBucket: recordbucket, boolean: streamNeedUpload};
    }

    private async VedioSencondPassQuery(digest: string, today): Promise<{ boolean: boolean, StreamBucket: any }> {
        let recordbucket: VedioSencondPassBucket | undefined;
        let streamNeedUpload = true;
        try {
            const dbCache = await CryptUploadDispatcher._cacheManager.getVedioSencondPassCache();
            recordbucket = await dbCache.query(digest);
        } catch (e) {
            console.log(e);
        }
        return {StreamBucket: recordbucket, boolean: streamNeedUpload};
    }

    private async QueryIsTimeOut(recordbucket, streamNeedUpload, dbCache, today) {
        if (recordbucket) {
            // 判是资源是否过期 -1代表资源永远不过期
            if (-1 == recordbucket.duration_time) {
                streamNeedUpload = false;
            } else if (0 == recordbucket.duration_time) {   //  0代表7天
                //大致判断天数即可，没必要精确秒级别
                let creationtime = new Date(recordbucket.creation_time);
                let difValue = (today.getTime() - creationtime.getTime()) / (1000 * 60 * 60 * 24);
                if (difValue > 6.9) {
                    //  console.log("资源已过期，需重新上传");
                    await dbCache.delete(recordbucket.plain_sha);
                    streamNeedUpload = true;
                } else {
                    streamNeedUpload = false;
                }
            } else if (recordbucket.duration_time > 0) {   //  duration_time以秒为单位
                let creationtime = new Date(recordbucket.creation_time);
                let difValue = (today.getTime() - creationtime.getTime()) / 1000;
                if (difValue > recordbucket.duration_time) {
                    //console.log("资源已过期，需重新上传");
                    await dbCache.delete(recordbucket.plain_sha);
                    streamNeedUpload = true;
                } else {
                    streamNeedUpload = false;
                }
            }
        }
    }

    /**
     * @beif秒传返回信息数据存储
     * @function otherSencondPassResult 其他文件秒传返回值
     * @function videoSencondPassResult 视频文件秒传返回值
     * @function imageSencondPassResult 图片文件秒传返回值
     * */
    public SencondPassResult(recordbucket, mediaType: string): UploadResult[] | undefined {
        if (mediaType == 'image' ||
            mediaType == 'figure' ||
            mediaType == 'headshot') {
            return this.imageSencondPassResult(recordbucket);
        } else if (mediaType == 'video') {
            return this.videoSencondPassResult(recordbucket);
        } else { //if(recordbucket.MediaType == 'other' ||  recordbucket.MediaType == 'audio')
            return this.otherSencondPassResult(recordbucket);
        }
    }

    private otherSencondPassResult(recordbucket): UploadResult[] | undefined {
        let uploadResult = [{
            Bucket: recordbucket[0].Complete.bucket_name,
            Key: recordbucket[0].Complete.key,
            Url: recordbucket[0].Complete.url,
            cryptInfo: {
                digest: recordbucket[0].Complete.crypt_info_digest, //摘要对象
                key: recordbucket[0].Complete.crypt_info_key,
                fileSize: Number(recordbucket[0].Complete.crypt_info_filesize)
            }
        }];
        console.log("recordbucket",uploadResult);
        return uploadResult;
    }

    private videoSencondPassResult(recordbucket): UploadResult[] | undefined {
        //console.log(recordbucket);
        return [{
            Bucket: recordbucket[0].Complete.bucket_name,
            Key: recordbucket[0].Complete.key,
            Url: recordbucket[0].Complete.url,
            cryptInfo: {
                digest: recordbucket[0].Complete.crypt_info_digest, //摘要对象
                key: recordbucket[0].Complete.crypt_info_key,
                fileSize: recordbucket[0].Complete.crypt_info_filesize
            }
        },{
            Bucket: recordbucket[0].Complete.bucket_name,
            Key: recordbucket[0].Complete.cover_key,
            Url: recordbucket[0].Complete.cover_url,
            cryptInfo: {
                digest: recordbucket[0].Complete.cover_crypt_info_digest, //摘要对象
                key: recordbucket[0].Complete.cover_crypt_info_key,
                fileSize: recordbucket[0].Complete.cover_crypt_info_filesize
            }
        }];
    }

    private imageSencondPassResult(recordbucket): UploadResult[] | undefined {
        return [{
            Bucket: recordbucket.Complete.bucket_name,
            Key: recordbucket.Complete.key,
            Url: recordbucket.Complete.url,
            cryptInfo: {
                digest: recordbucket.Complete.crypt_info_digest, //摘要对象
                key: recordbucket.Complete.crypt_info_key,
                fileSize: recordbucket.Complete.crypt_info_filesize
            }
        }];
    }
}