import {MEDIA_TYPE, MEDIA_TYPE_MAP, MIME_TYPE} from "../@types/types";

export interface REQUEST_PARAM{
    [key:string]:string
}

export interface URI_INFO{
    uri:string,
    protocol?:string,
    param?:REQUEST_PARAM
}

export default class RequestUtil{
    constructor() {
    }

    public static getRequestPath(req:any, isExt?:boolean):string {
        let path:string = req.url;
        path = path.replace(req.contextPath, "");
        if(path.indexOf("?") != -1){
            path = path.substring(0, path.indexOf("?"));
        }
        if (isExt && isExt == true && path.lastIndexOf(".") > -1) {
            path = path.substring(0, path.lastIndexOf("."));
        }
        return path;
    }

    public static getRequestParam(req:any):string {
        let path:string = req.url;
        let paramString:string = "";
        if(path.indexOf("?") != -1){
            paramString = path.substring(path.indexOf("?")+1, path.length);
        }
        return paramString;
    }

    public static getRequestParamMap(req:any):REQUEST_PARAM {
        let paramString:string = this.getRequestParam(req);
        let paramMap:REQUEST_PARAM = {};
        if(paramString == ""){
            const paramFair = paramString.split("&");
            if (paramFair) {
                paramFair.forEach((element,index)=>{
                    const pSet = element.split("=");
                    if (pSet && pSet.length == 2) {
                        if(!pSet[1]) pSet[1] = "";
                        let val:string = decodeURIComponent(pSet[1]);
                        paramMap[pSet[0]] = val;
                    }
                })
            }
        }
        return paramMap;
    }


    public static parseUri(uri:string|undefined):URI_INFO {
        let parseUri:URI_INFO = {} as URI_INFO;

        if (uri && uri.indexOf("?") > -1) {
            let uriArr = uri.split("?");
            parseUri.uri = uriArr[0];

            let paramString:string = uriArr[1];
            let paramMap:REQUEST_PARAM = {};
            if(paramString != ""){
                const paramFair = paramString.split("&");
                if (paramFair) {
                    paramFair.forEach((element,index)=>{
                        const pSet = element.split("=");
                        if (pSet && pSet.length == 2) {
                            if(!pSet[1]) pSet[1] = "";
                            let val:string = decodeURIComponent(pSet[1]);
                            paramMap[pSet[0]] = val;
                        }
                    })
                }
            }
            parseUri.param = paramMap;


        }
        else
        {

            parseUri.uri = !uri ? "" :uri;
        }


        if(parseUri.uri.indexOf("://") > -1)
        {
            let protocolParseArr = parseUri.uri.split("://");
            parseUri.uri = protocolParseArr[0];
            parseUri.protocol = protocolParseArr[1];
        }

        return parseUri;
    }


    public static parseRequestParamMap(uri:string|undefined):REQUEST_PARAM {
        let paramString:string = "";
        if (uri && uri.indexOf("?") > -1) {
            paramString = uri.split("?")[1];
        }
        let paramMap:REQUEST_PARAM = {};
        if(paramString != ""){
            const paramFair = paramString.split("&");
            if (paramFair) {
                paramFair.forEach((element,index)=>{
                    const pSet = element.split("=");
                    if (pSet && pSet.length == 2) {
                        if(!pSet[1]) pSet[1] = "";
                        let val:string = decodeURIComponent(pSet[1]);
                        paramMap[pSet[0]] = val;
                    }
                })
            }
        }
        return paramMap;
    }

    public static getRequestService(req:any):string {
        let path:string = this.getRequestPath(req);
        let service:string = "";
        if(path.indexOf("/bicns/transaction/") != -1){
            service = path.substring(path.indexOf("/bicns/transaction/")+"/bicns/transaction/".length, path.length);
            service = "/"+service.replace(/\./gi, "/");
        }else if(path.indexOf("/bicns/excel/") != -1){
            service = path.substring(path.indexOf("/bicns/excel/")+"/bicns/excel/".length, path.length);
            service = "/"+service.replace(/\./gi, "/");
        }else if(path.indexOf("/bicns/stream/") != -1){
            service = path.substring(path.indexOf("/bicns/stream/")+"/bicns/stream/".length, path.length);
            service = "/"+service.replace(/\./gi, "/");
        }else{
            service = path;
        }
        return service;
    }

    public static getRequestMimeType(req:any):MIME_TYPE {
        const url:string = this.getRequestPath(req);
        let mime:MIME_TYPE = "any";
        if(url.indexOf("/bicns/stream/") != -1 || url.indexOf("/bicns/excel/") != -1) {
            mime = "bin";
        }else if(url.indexOf("/bicns/transaction/") != -1){
            mime = "rest";
        }else if (url.lastIndexOf(".") > -1) {
            try{
                const ext:string = url.substring(url.lastIndexOf(".") + 1, url.length).toLowerCase();
                mime = ext as MIME_TYPE;
            }catch(e){
                console.log(e);
            }
        }else{
            mime = "view";
        }
        return mime;
    }

    public static getRequestMediaType(req:any):string {
        if(!req) return MEDIA_TYPE_MAP.any;
        const mimeType:MIME_TYPE = this.getRequestMimeType(req);
        return MEDIA_TYPE_MAP[mimeType];
    }
}