import { ClientConfig, getDefaultRequestConfig } from '../config/ClientConfig';
import { commonResult } from '../grpc-web-index';

const defaultResponse = {
    code: 0,
    message: '',
    data: undefined
};

const transformParams = ({ params, transformMaps = {}, transformer }) => {
    if (!params || typeof params !== 'object') return params;

    const results = Object.prototype.toString.call(params) === '[object Array]' ? [] : {};
    Object.keys(params).forEach((key) => {
        const targetKey = transformMaps[key] || (typeof transformer === 'function' && transformer(key));
        results[targetKey || key] = transformParams({ params: params[key], transformMaps, transformer });
    });
    return results;
};


const responseTransformer = (params) => {
    const res = transformParams({
        params,
        transformer(key) {
            let newKey = '';
            key.split('_').forEach((ele, index) => {
                newKey += index > 0 ? ele[0].toUpperCase() + ele.substring(1) : ele;
            });
            return newKey;
        },
    });
    if (params.msg) {
        res.message = params.msg;
    }
    return Object.assign({}, defaultResponse, res);
};

export interface HttpMessage<T = any> {
    code: number
    message: string
    data: T
}
export function sendHttpsRequest<T>(request, meta: {
    url: string,
    'Content-Type'?: string,
    __avoidDefaultParams?: boolean
}, timeOut?: number): Promise<HttpMessage<T>> {
    return new Promise((resolve: (body: HttpMessage) => void, reject: (reason?: HttpMessage) => void) => {

        const errorMsg: HttpMessage = { code: 0, message: '', data: null }

        try {
            const xhr = new XMLHttpRequest();
            xhr.timeout = timeOut || 5000;
            xhr.open('post', ClientConfig.baseUrl + meta.url, true);
            if (!meta['Content-Type']) {
                xhr.setRequestHeader('content-type', 'application/json');

            } else {
                xhr.setRequestHeader('Content-Type', meta['Content-Type']);

            }
            let sendData = transformParams({
                params: request.toObject ? request.toObject() : request,
                transformer(key) {
                    return key.replace(/sList$/, 's');
                },
            });
            if (!meta.__avoidDefaultParams) {
                sendData = { ...getDefaultRequestConfig(), ...sendData };
            }
            xhr.ontimeout = () => {
                console.error('ontimeout');
                errorMsg.code = commonResult.TxStatusCode.TIMEOUT;
                errorMsg.message = `timeout`;
                reject(errorMsg);
            };
            xhr.onerror = (err) => {
                console.error('onerror', err);
                errorMsg.code = commonResult.TxStatusCode.INTERNAL_ERROR;
                errorMsg.message = `xhr request onabort,status:${err}`;
                reject(errorMsg);
            };
            xhr.onabort = (err) => {
                console.error('onerror', err);
                errorMsg.code = commonResult.TxStatusCode.INTERNAL_ERROR;
                errorMsg.message = `xhr request onabort,status:${err}`;
                reject(errorMsg);
            };
            xhr.send(typeof sendData === 'object' ? JSON.stringify(sendData) : sendData);
            xhr.onload = function () {
                if (xhr.status === 200) {
                    resolve(responseTransformer(JSON.parse(xhr.responseText)));
                } else {
                    errorMsg.code = commonResult.TxStatusCode.INTERNAL_ERROR;
                    errorMsg.message = `xhr request failed,status:${xhr.status}`;
                    reject(errorMsg);
                }
            };
        } catch (error) {
            errorMsg.code = commonResult.TxStatusCode.INTERNAL_ERROR;
            errorMsg.message = `call sendRequest error: ${error}`;
            reject(errorMsg);
        }
    });
}