import { RequestMetadata, Method, Header } from "./RequestMetadata.js";

/**
 * Abstração do XMLHttpRequest. Este serviço é responsável por realizar as requisições
 * ao backend. Todos os métodos são estáticos.
 */
export class HttpProvider {

    /**
     * Faz uma requisição usando o método GET do HTTP para uma URL específica.
     *
     * @param {string} url A URL que deve ser chamada.
     * @param {Array<Header>} headers [Opcional] Cabeçalhos HTTP.
     * @returns {Promise<Object>} Uma promessa de que a requisição será preenchida.
     */
    public static get(url: string, headers?: Array<Header>): Promise<Object> {
        return this.dispatch(new RequestMetadata(url, Method.GET, headers));
    }

    /**
     * Faz uma requisição usando o método POST do HTTP para uma URL específica.
     *
     * @param {string} url A URL que deve ser chamada.
     * @param {Object} payload Informações a serem enviadas.
     * @param {Array<Header>} headers [Opcional] Cabeçalhos HTTP.
     * @returns {Promise<Object>} Uma promessa de que a requisição será preenchida.
     */
    public static post(url: string, payload:Object, headers?: Array<Header>): Promise<any> {
        return this.dispatch(new RequestMetadata(url, Method.POST, headers), payload);
    }

    private static dispatch(requestMetadata: RequestMetadata, payload?: Object): Promise<any> {

        return new Promise<Object>((resolve, reject) => {

            const request = new XMLHttpRequest();            

            request.timeout = requestMetadata.timeout;

            request.onerror = function handleError() {
                reject({
                    status: 404,
                    statusText: 'Not Found'
                });
            };

            request.ontimeout = function handleTimeout() {
                reject({
                    status: 408,
                    statusText: 'Request Timeout'
                });
            };

            request.onreadystatechange = () => {

                // While readState isn't done, there's nothing to do...
                if (request.readyState != 4) {
                    return;
                }

                const status = request.status;

                // The request has failed so we'll handled by onerror instead
                if (status === 0) {
                    return;
                }

                const response = {
                    status,
                    statusText: request.statusText,
                };

                // Anything out of this range is an error, so we just send the status and statusText.
                if (status >= 200 && status < 300) {
                    resolve({
                        ...response,
                        data: request.response,
                        dataAsString: request.responseText
                    });
                } else {
                    reject(response);
                }

            };

            request.open(requestMetadata.method.toString(), requestMetadata.url, true);
            requestMetadata.headers.map((h: Header) => request.setRequestHeader(h.name, h.value));

            if(payload != null){
                request.send(JSON.stringify(payload));
            }
        });
    }
}