import axios from 'axios';
import S3, { ClientConfiguration } from 'aws-sdk/clients/s3';
import OSS from 'ali-oss';
import { CredentialsOptions } from 'aws-sdk/lib/credentials';
import {
    FileExistingResult,
    ApplyUploadRequest,
    ApplyUploadResult,
    SdkSettingsResult,
} from './BackendServerModel';

export default class BackendServer {
    static API_CREDENTIAL = "cred";
    static API_ALIYUNOSS_CREDENTIAL = "OssSignature";
    static API_UPLOAD_QUERY = "upload_query";
    static API_UPLOAD_APPLY = "upload_request";
    static API_UPLOAD_UPDATE = "upload_update";
    static API_FILE_UPDATE = "file_info_update";
    static API_SDKSETTINGS = "SDKSettings";
    url :string;
    token :string;

    constructor(url :string, token :string) {
        if(url.charAt(url.length - 1) == '/')
            this.url = url;
        else
            this.url = url + '/';

        this.token = token;
    }

    async CreateS3(region:string) {
        let fullurl = this.url + BackendServer.API_CREDENTIAL;
        let resp = await axios.get(fullurl, {
            headers: { "token": this.token }
        });
        let json = resp.data;
        
        let credential: CredentialsOptions = {
            accessKeyId: json.AccessKeyId, 
            secretAccessKey: json.SecretAccessKey, 
            sessionToken: json.SessionToken
        };
        let config: ClientConfiguration = {
            region: region,//'ap-northeast-1',
            credentials: credential
        };
        let s3 :S3 = new S3(config);
        return s3;
    }

    async CreateOSSClient(region:string, bucket:string) {
        let fullurl = this.url + BackendServer.API_ALIYUNOSS_CREDENTIAL;
        let resp = await axios.get(fullurl, {
            headers: { "token": this.token }
        });
        let token = resp.data;
        let client = new OSS({
            //region: 'oss-'+region,
            endpoint: `https://oss-${region}.aliyuncs.com`,
            //endpoint: 'https://oss-accelerate.aliyuncs.com',
            accessKeyId: token.AccessKeyId,
            accessKeySecret: token.AccessKeySecret,
            stsToken: token.SecurityToken,
            bucket: bucket,
            timeout: 1000 * 60 * 5
        });
        return client;
    }

    /**
     * 秒传查询
     * @param md5 文件md5值
     * @param fileSize 文件大小
     * @param duration 时长
     */
    async QueryFileExistingOnServer(md5 :string, fileSize:number, duration?:number) {
        let fullurl = this.url + BackendServer.API_UPLOAD_QUERY;// + '?Md5=' + md5;
        let param = 'Md5='+ md5 + '&FileSize=' + fileSize;
        if(duration == undefined) {
            ;
        } else if(duration > 0) {
            param += '&StorageDuration=' + duration;
        } else if(duration < 0) {
            param += '&StorageDuration=-1';
        }
        let resp = await axios.post(fullurl, param, {
            headers: { "Content-Type" :'application/x-www-form-urlencoded' }
        });
        let result = resp.data;
        if(result.MediaInfo) {
            result.MediaInfo = JSON.parse(result.MediaInfo);
        }
        return result as FileExistingResult;
    }

    /** 上传申请 */
    async ApplyUpload(request :ApplyUploadRequest) {
        let fullurl = this.url + BackendServer.API_UPLOAD_APPLY;
        let param = this.GetUrlParam(request);
        //console.log('ApplyUpload param:' + param);
        let resp = await axios.post(fullurl, param, {
            headers: { "Content-Type" :'application/x-www-form-urlencoded' }
        });
        let result:ApplyUploadResult = resp.data;
        //console.log('ApplyUpload result:' + result);
        return result;
    }

    /** 上传申请 */
    async CryptApplyUpload(request :ApplyUploadRequest) {
        let fullurl = this.url + BackendServer.API_UPLOAD_APPLY;
        let param = this.GetUrlParam(request);
        //console.log('ApplyUpload param:' + param);
        let resp = await axios.post(fullurl, param, {
            headers: { "Content-Type" :'application/x-www-form-urlencoded' }
        });
        let result:ApplyUploadResult = resp.data;
        //console.log('ApplyUpload result:' + result);
        return result;
    }

    /**
     * 更新上传状态
     * @param mediaId 
     * @param fileStatus 1-成功 2-未完成
     */
    async UpdateByMediaId(mediaId :string, fileStatus :number) {
        let fullurl = this.url + BackendServer.API_UPLOAD_UPDATE;
        let param = 'MediaID=' + mediaId + '&FileStatus=' + fileStatus.toString();
        let resp = await axios.post(fullurl, param, {
            headers: { "Content-Type" :'application/x-www-form-urlencoded' }
        });
        let result :{Status:number} = resp.data;
        return result.Status;
    }

    /**
     * 更新文件时长
     * @param mediaId 
     * @param duration 时长 
     */
    async UpdateFileInfo(mediaId:string, duration:number) {
        let fullurl = this.url + BackendServer.API_FILE_UPDATE;
        let param = 'MediaID=' + mediaId;
        if(duration > 0) {
            param += '&StorageDuration=' + duration;            
        } else if(duration < 0) {
            param += '&StorageDuration=-1';
        }

        let resp = await axios.post(fullurl, param, {
            headers: { "Content-Type" :'application/x-www-form-urlencoded' }
        });

        let result :{States:number} = resp.data;
        return result.States;
    }

    /** 获取sdk设置 */
    async GetSdkSettings() {
        let fullurl:string[] = [];
        fullurl = fullurl.concat(this.url).concat(BackendServer.API_SDKSETTINGS);
        //console.log("开始获取SDK设置信息");
        let resp = (await axios.get(fullurl.join(''))).data;
        //console.log("获取SDK设置成功");
        let result :SdkSettingsResult = resp;
        return result;
    }

    /** 转换url参数 */
    private GetUrlParam(param :any) :string {
        let strarr :Array<string> = [];
        let i = 0;
        for(let field in param) {
            let token = i++ == 0 ? '' : '&';
            if(field == 'MediaInfo') {
                let obj = param[field];
                let json = JSON.stringify(obj);
                json = encodeURI(json);
                strarr = strarr.concat(token).concat(field).concat('=').concat(json);
            } else {
                strarr = strarr.concat(token).concat(field).concat('=').concat(param[field]);
            }
        }
        return strarr.join('');
    }
}