/*
 * @Author: 张一一
 * @Date: 2020-3-6 17:29:44
 * @Last Modified by:   张一一
 * @Last Modified time: 2020-3-6 17:29:44
 */
import qs from 'qs';
import config from '@/lib/config'
import {
    getPlatform // 获取平台信息
} from '@/lib/utils/index'

/**
 * 通用uni-app网络请求
 * 基于 Promise 对象实现更简单的 request 使用方式，支持请求和响应拦截
 */
export class Http {
    constructor() {
        this.config = {
            baseUrl: config.api, // 请求域名
            header: {
                // multipart/form-data
                // 'Content-Type': 'multipart/form-data',
                // application/x-www-form-urlencoded
                'Content-Type': 'application/x-www-form-urlencoded',
            },
            data: {},
            method: 'POST',
            // dataType: 'json' /* 如设为json，会对返回的数据做一次 JSON.parse */,
            // responseType: 'text',
            success() {},
            fail() {},
            complete() {}
        }
        this.interceptor = {
            before:  null,
            after: null
        }

        this.instance = null
    }

    static getInstance() {
        if (!this.instance) {
            this.instance = new Http()
        }
        return this.instance
    }

    request(options) {
        let that = this

        if (!options) {
            options = {}
        }
        options.baseUrl = options.baseUrl ||
            this.config.baseUrl
        //if (process.env.NODE_ENV ===
        //	'development') {
        //	options.url = this.addTemp(options.baseUrl +
        //		'devapi/' + options.url) // 增加时间戳
        //} else {
        options.url = this.addTemp(options.baseUrl +
            options.url) // 增加时间戳
        //}
 /*       options.url = this.addPlatform(
            options.url) // 增加使用平台*/
        options.data = qs.stringify(options.data ||
            {})
        options.method = options.method ||
            this.config.method
        if (options.method === 'get' ||
            options.method === 'GET') {
            options.url = objParseUrlAndParam(
                options.url, options.data)
        }
        // TODO 加密数据

        // TODO 数据签名

        return new Promise((resolve, reject) => {
            let _config = null

            options.complete = response => {
                let statusCode = response.statusCode
                response.config = _config
                // 请求后的拦截器
                if (this.interceptor.after) {
                    let newResponse = this.interceptor
                        .after(response)
                    if (newResponse) {
                        response = newResponse
                    }
                }
                // 统一的响应日志记录
                that._reslog(response)
                if (statusCode === 200) {
                    // 成功
                    resolve(response.data)
                } else {
                    reject({code: 0, msg: '请求出错'})
                }
            }

            _config = Object.assign({}, this.config,
                options)
            _config.requestId = new Date().getTime()
            // 请求前的拦截器
            if (this.interceptor.before) {
                let newConfig = this.interceptor
                    .before(_config)
                if (newConfig) {
                    _config = newConfig
                } else {
                    return
                }
            }

            // 统一的请求日志记录
            that._reqlog(_config)

            uni.request(_config)
        })
    }

    get(options) {
        if (!options) {
            options = {}
        }
        options.method = options.method || 'GET';
        return this.request(options)
    }

    post(options) {
        if (!options) {
            options = {}
        }
        options.method = options.method || 'POST';
        return this.request(options)
    }
    /**
     * 统一的响应日志记录
     * @param {*} req
     */
    _reqlog(req) {
        if (process.env.NODE_ENV == 'development') {
            if (req.data) {

            }
        }
        // TODO 调接口异步写入日志数据库
    }
    /**
     * 统一的请求日志记录
     * @param {*} res
     */
    _reslog(res) {
        let _statusCode = res.statusCode
        if (process.env.NODE_ENV == 'development') {
            // console.log(`请求类型: ${res.config.method}`);
            // console.log(`请求地址: ${res.config.url}`);
            // console.log(`请求参数: ${res.config.data}`);
        }
        // TODO 除了接口服务错误外，其他日志调接口异步写入日志数据库
        switch (_statusCode) {
            case 200:
                // console.log(`响应: ${JSON.stringify(res.data)}`);
                break
            case 401:
                break
            case 404:
                console.log(`请求地址错误404`);
                break
            default:
                break
        }
    }
    /**
     * 增加时间戳，用于防止请求缓存
     * @param {String} url
     * @return {String}
     */
    addTemp(url) {
        let new_url;
        if (url.indexOf('?') === -1) {
            new_url = `${url}?_now_=${new Date().getTime()}`;
        } else {
            new_url = url.replace('?', `?_now_=${new Date().getTime()}&`);
        }
        return new_url;
    }
    /**
     * 增加使用平台信息
     * @param {String} url
     * @return {String}
     */
/*    addPlatform(url) {
        let new_url;
        if (url.indexOf('?') === -1) {
            new_url = `${url}?_platform_=${getPlatform()}`;
        } else {
            new_url = url.replace('?', `?_platform_=${getPlatform()}&`);
        }
        return new_url;
    }*/
    /**
     * 增加参数到地址
     * */
    addParams(url, params) {
        let new_url;
        if (url.indexOf('?') === -1) {
            new_url = `${url}?${params}`;
        } else {
            new_url = url.replace('?', `?${params}&`);
        }
        return new_url;
    }
}


let _myHttp = Http.getInstance();
export default _myHttp;