import axios, { AxiosRequestHeaders } from 'axios';
import SessionManager                 from './SessionManager';
import FormData                       from 'form-data';
import GitlabManager                  from './GitlabManager';
import { StatusCodes }                from 'http-status-codes';
import ClientsSharedConfig            from '../sharedByClients/config/ClientsSharedConfig';
import { version }                    from '../config/Version';
import DojoBackendResponse            from '../shared/types/Dojo/DojoBackendResponse';
import DojoStatusCode                 from '../shared/types/Dojo/DojoStatusCode';
import boxen                          from 'boxen';
import Config                         from '../config/Config';


class HttpManager {
    public handleAuthorizationCommandErrors: boolean = true;

    registerAxiosInterceptor() {
        this.registerRequestInterceptor();
        this.registerResponseInterceptor();
    }

    private registerRequestInterceptor() {
        axios.interceptors.request.use((config) => {

            if ( config.data instanceof FormData ) {
                config.headers = { ...config.headers, ...(config.data as FormData).getHeaders() } as AxiosRequestHeaders;
            }

            if ( config.url && (config.url.indexOf(ClientsSharedConfig.apiURL) !== -1) ) {
                config.headers['Accept-Encoding'] = 'gzip';

                if ( config.data && Object.keys(config.data).length > 0 ) {
                    config.headers['Content-Type'] = 'multipart/form-data';
                }

                if ( SessionManager.isLogged ) {
                    config.headers.Authorization = `Bearer ${ SessionManager.token }`;
                }

                config.headers['client'] = 'DojoCLI';
                config.headers['client-version'] = version;
            }

            if ( GitlabManager.isLogged && config.url && config.url.indexOf(ClientsSharedConfig.gitlab.apiURL) !== -1 ) {
                config.headers['PRIVATE-TOKEN'] = GitlabManager.token;
            }

            return config;
        });
    }

    private requestError(message: string) {
        console.log(boxen(message, {
            title         : 'Request error',
            titleAlignment: 'center',
            borderColor   : 'red',
            borderStyle   : 'bold',
            margin        : 1,
            padding       : 1,
            textAlignment : 'left'
        }));
        process.exit(1);
    }

    private registerResponseInterceptor() {
        axios.interceptors.response.use((response) => {
            if ( response.data && response.data.sessionToken ) {
                SessionManager.token = response.data.sessionToken;
            }

            return response;
        }, (error) => {
            if ( error.response ) {
                if ( error.response.status === StatusCodes.METHOD_NOT_ALLOWED && error.response.data ) {
                    const data: DojoBackendResponse<{}> = error.response.data;

                    switch ( data.code ) {
                        case DojoStatusCode.CLIENT_NOT_SUPPORTED:
                            this.requestError('Client not recognized by the server. Please contact the administrator.');
                            break;
                        case DojoStatusCode.CLIENT_VERSION_NOT_SUPPORTED:
                            this.requestError(`CLI version not anymore supported by the server. Please update the CLI.\nYou can download the latest stable version (latest release without "-dev" suffix) on this page:\n${ Config.gitlab.cliReleasePage }`);
                            break;
                        default:
                            break;
                    }
                }

                if ( this.handleAuthorizationCommandErrors ) {
                    if ( error.response.url && error.response.url.indexOf(ClientsSharedConfig.apiURL) !== -1 ) {
                        switch ( error.response.status ) {
                            case StatusCodes.UNAUTHORIZED:
                                this.requestError('Session expired or does not exist. Please login again.');
                                break;
                            case StatusCodes.FORBIDDEN:
                                this.requestError('Forbidden access.');
                                break;
                        }
                    }
                } else {
                    this.handleAuthorizationCommandErrors = true;
                }
            } else {
                this.requestError('Error connecting to the server. Please check your internet connection. If the problem persists, please contact the administrator.');
            }

            return Promise.reject(error);
        });
    }
}


export default new HttpManager();