var env = process.env.NODE_ENV || 'development'; 
var cfg = require('../../config/config.js').get(env);
var stats = require('../helper/stats.js'); 
var request = require('request');
var messageSOAP = require('../helper/messageSOAP.js'); 

var log = require('../helper/log.js');

var constants = require('../helper/constants.js');

var connection = [];

connection.requestSoapToSACF = async function (req,soap,cmd,myMethod) {

    try {

        log.log("Connect to SACF")

        var service = cfg.service.SACF;
        var retry = service[myMethod+"_"+cmd+"_Retry"];    

        var params = {
            url                 : service[myMethod+"_"+cmd+"_URL"],
            body                : messageSOAP.objectToSOAP(soap,cmd),

            method              : myMethod,

            timeout             : cfg.service.SACF[myMethod+"_"+cmd+"_Timeout"]*1000
        }

        log.log("requestData : "+JSON.stringify(params))

        if(!retry)                

            retry = cfg.Default_Retry;

        var objectData = {

            maxRetry : retry,

            curRetry : 1
        }
        
        var funS = function(){
            stats.sendSACFRequest(service.Name,cmd);

            log.logDetail.addOutput(req,service.Name,myMethod+"_"+cmd,constants.REQUEST,params,soap);

        };
        

        var funStats = {
            start : funS,
            error : function(response){log.addErrorSummary(req,service.Name,myMethod+"_"+cmd,response.resultCode,response.resultDescription);}
        };

        var result = await asyncRequest(params,objectData,funStats);

        return checkResponse(result,funStats);
    }
    catch(err) {
        log.log(err);

        var result = {
            response : constants.RESPONSECONN.MESSAGE.ERROR
        };
        return result;

    }
};

connection.requestJsonToD01 = async function (req,obj,cmd,myMethod) {
    try {
    
        log.log("Connect to D01")

        var service = cfg.service.D01;    
        var retry = service[myMethod+"_"+cmd+"_Retry"];
        if(!retry)                
            retry = cfg.Default_Retry;

        var objectData = {
            maxRetry : retry,
            curRetry : 1
        }

        // JSON.stringify(json)
        var params = {
            url                 : service[myMethod+"_"+cmd+"_URL"],
            body                : obj,
            method              : myMethod,
            timeout             : service[myMethod+"_"+cmd+"_Timeout"]*1000
        }

        log.log("requestData : "+JSON.stringify(params))

        var funStats = function(){
            stats.sendRestRequest(service.Name,myMethod,cmd);
            log.logDetail.addOutput(req,service.Name,myMethod+"_"+cmd,constants.Request,params,obj);
        };
        

        var funStats = {
            start : funStats,

            error : function(response){log.addErrorSummary(req,service.Name,myMethod+"_"+cmd,response.resultCode,response.resultDescription);}

        };

        var result = {};
        result.response = {};

        result.response.resultData = [];

        if(params.method == constants.METHOD.GET)
        {
            var genUrl = getUrl(params,service["searchRecordLimit"]);   
            if(genUrl.length > 1)

            {

                console.log("multi Send");

                var multiSend = [];

                for(var i=0;i<genUrl.length;i++)

                    multiSend.push({url:genUrl[i],method:params.method});

            
                var parallelRes = await parallelRequest(multiSend,objectData,funStats); 

                var dataRes = {};

                for(var i=0;i<multiSend.length;i++)
                {
                    // console.log("start loop");

                    var loopRes = parallelRes[i];
                    
                    if(loopRes.response)
                    {

                        var data = JSON.parse(loopRes.response.body);

                        dataRes[i] = {};

                        if(!data.resultCode)
                            dataRes[i].err = "Miss resultCode";

                        if(!data.resultDescription)
                            dataRes[i].err = "Miss resultDescription"

                        
                        dataRes[i].data = data.resultData;
                    
                    }

                }

                for (var i = 0; i < multiSend.length; i++) {

                        
                    result.response.resultData = result.response.resultData.concat(dataRes[i].data);
                    if(dataRes[i].err)
                        result.err = dataRes[i].err;
                }

                if(!result.err)
                {
                    result.response = constants.RESPONSECONN.MESSAGE.SUCCESS;
                    // result.response.resultCode = "20000";
                    // result.response.developerMessage = "Success";
                }

                
            }else
            {
                // console.log("single Send");
                params.url = genUrl[0];
                delete params.body;

                var resultRes = await asyncRequest(params,objectData,funStats);

                // console.log(resultRes);
                if(resultRes.response)
                {

                    var data = JSON.parse(resultRes.response.body);
                    result.response = data;

                
                } else {
                    result = resultRes;
                }
            }

            
        } else if(params.method == constants.METHOD.POST) {
            params.body = JSON.stringify(params.body);

            var resultRes = await asyncRequest(params,objectData,funStats);

            if(resultRes.response){

                result.response = JSON.parse(resultRes.body);
            } else {
                result = resultRes;
            }
        } else if(params.method == constants.METHOD.PUT) {

            params.body = JSON.stringify(params.body);

            var resultRes = await asyncRequest(params,objectData,funStats);

            if(resultRes.response){
                result.response = JSON.parse(resultRes.body);
            } else {
                result = resultRes;
            }
        }

        // console.log(result);
        
        if(result.response)
        {
            if(!result.response.resultCode){
                result.err = "Missing resultCode";
            } else if(!result.response.resultDescription){
                result.err = "Missing resultDescription";
            }

        }

        return checkResponse(result,funStats);

    }
    catch(err) {
        log.log(err);

        var result = {
            response : constants.RESPONSECONN.MESSAGE.ERROR
        };

        return result;

    }
};

async function parallelRequest(multiParams,objectData,funStat)
{
   
    var promises = [];

    for(var i=0;i<multiParams.length;i++)

        promises.push(asyncRequest (multiParams[i],objectData,funStat));

    var res = await Promise.all(promises);
    // for(var i=0;i<res.length;i++)
    // {
    //     if(!res[i].err)
    //         stats.receiveResponse(node,cmd,"Success");

    // }

    return res;
}

function asyncRequest (params = {},objectData,funStat) {

    // console.log(objectData);  

    funStat.start();

    // console.log("Start : "+new Date().toISOString());
    return new Promise((resolve, reject) => {
        request(params, function (error, response, body) {

            if (error) {

                if( objectData.maxRetry == objectData.curRetry-1)
                {
                    resolve({
                        'body'  : body,
                        'err'   : error
                    });
                }else
                {

                    var errRes = {};

                    log.log(error,'error');

                    if(error.code == constants.RESPONSECONN.STATS.ETIMEDOUT){

                        errRes.response = constants.RESPONSECONN.MESSAGE.ETIMEDOUT;

                    } else if(error.code == constants.RESPONSECONN.STATS.ECONNREFUSED){
                        errRes.response = constants.RESPONSECONN.MESSAGE.ECONNREFUSED;

                    } else if(error.code == constants.RESPONSECONN.STATS.ESOCKETTIMEDOUT){

                        errRes.response = constants.RESPONSECONN.MESSAGE.ESOCKETTIMEDOUT;

                    } else {
                        errRes.response = constants.RESPONSECONN.MESSAGE.ERROR;                        

                    }
                  
                    // console.log("retry "+objectData.curRetry);
                    funStat.error(errRes);                    
                    objectData.curRetry++; 
                    resolve(asyncRequest(params,objectData,funStat));
                }

               
            } else {
               
                // stats.receiveResponse(node,cmd,"Success");
                resolve({
                    'body'      : body,
                    'response'  : response
                });
            }

        });

    });
};

function getUrl(params,limit)
{

    var returnData = [];
    var url = params.url;

    var fields = "";

    var filter = {

        base : "",
        multi : []

    };

    // params.body = {};

    // params.body.a = "aaa";

    // params.body.b = "bbb";

    // params.body.papa = [];

    // params.body.papa.push("1");

    // params.body.papa.push("2");

    // params.body.commandId = [];
    // params.body.commandId.push("1");

    // params.body.commandId.push("2");
    // params.body.commandId.push("3");

    // params.body.commandId.push("4");
    // params.body.commandId.push("5");

    // params.body.commandId.push("6");

    // params.body.commandId.push("7");
    // params.body.commandId.push("8");    

    // params.body.c = "ccc";
    // params.body.fields = "a,b,c,d";

    // console.log(params.body);  

    if(params.body)

    {
        var first = true;
        for (key in params.body) {

            if(key == "fields")
                fields = getFields(params.body.fields,first);
            else

                filter = getFilter(filter,key,params.body[key]);

            first = false;

        }

        if(first)
            fields += "?limit="+limit;

        else
            fields += "&limit="+limit;

    }   

    if(filter.multi.length > 0)
    {
        //have multi

        var careData = filter.multi[0];
        // console.log(freeSpace);

        for(var i=0;i<filter.multi.length;i++)
        {
            if(filter.multi[i].length > careData.length)

            {

                filter.base = filter.base+"(|"+careData.data+")";

                careData = filter.multi[i];

                
            }
        }


        var myUrl = url+"?filter=("+filter.base+")"+fields;
        var freeSpace = cfg.Uri_length - myUrl.length;
        

        var arr = careData.data.split(")(");

        for(var j=0;j<arr.length;j++)

        {

            if(j==0)

                arr[j] = arr[j].substring(1);
            if(j==arr.length-1)
                arr[j] = arr[j].substring(0,arr[j].length-1);

            arr[j] = "("+arr[j]+")";

                // returnData.push(url+"?filter=("+newBasefilter+"(|"+arr[j]+")"+fields);
        }

        returnData = arrayUrl(returnData,url,filter.base,fields,freeSpace,arr);

    }else

    {

        var myUrl = url+"?filter=("+filter.base+")"+fields;
        returnData.push(myUrl);
    }

    // console.log(url);
    // console.log(filter);
    // console.log(fields);

    for(var i=0;i<returnData.length;i++)

        log.log("URL "+[i+1]+" : "+returnData[i]);

    return returnData;

}

function getFields(fields,first)
{

    var returnData;

    var prefix;
    if(first)
        prefix = "?fields=";
    else

        prefix = "&fields=";

    returnData = prefix+fields;

    return returnData;

}

function getFilter(filter,key,data)

{
   
    // console.log(key);

    // console.log(newfilter);

    if(!Array.isArray(data))

    {

        // var newfilter = {
        //     data : "("+key+"="+data+")",
        //     type : "single",

        //     length : ("("+key+"="+data+")").length
        // };

        if(filter.base != "")    
            filter.base = filter.base+"("+key+"="+data+")";

        else

            filter.base = "&"+filter.base+"("+key+"="+data+")";

    }else

    {

        var line = "";
        for(var i=0;i<data.length;i++)

        {
            line += "("+key+"="+data[i]+")";

        }

        var newfilter = {

            data : line,

            length : line.length

        };

    }

    if(newfilter)

        filter.multi.push(newfilter);
    return filter;
}

function arrayUrl(arrUrl,url,filter,fields,freeSpace,arrData)

{
    var loopUrl = "";
    var loopSpace = freeSpace;
    for(var i=0;i<arrData.length;i++)
    {
        if(loopSpace > (arrData[i].length+3))
        {
            loopUrl = loopUrl + arrData[i];
            loopSpace = loopSpace - arrData[i].length;
        }else
        {
            if(loopUrl != "")
            {
                arrUrl.push(url+"?filter=("+filter+"(|"+loopUrl+")"+fields);

                loopUrl = arrData[i];
                loopSpace = freeSpace - arrData[i].length;
            }
            
        }

    }

    if(loopUrl != "")
        arrUrl.push(url+"?filter=("+filter+"(|"+loopUrl+")"+fields);

    return arrUrl;
}

function checkResponse(result,funStats)
{
    if(result.err)
    {
        log.log(result.err,'error');

        if(result.err.code == constants.RESPONSECONN.STATS.ETIMEDOUT){

            result.response = constants.RESPONSECONN.MESSAGE.ETIMEDOUT;
            // result.response.resultCode = "50003";
            // result.response.resultDescription = "Timeout";
        } else if(result.err.code == constants.RESPONSECONN.STATS.ECONNREFUSED){
            result.response = constants.RESPONSECONN.MESSAGE.ECONNREFUSED;
            // result.response.resultCode = "50002";

            // result.response.resultDescription = "Reject";

        } else if(result.err.code == constants.RESPONSECONN.STATS.ESOCKETTIMEDOUT){
            result.response = constants.RESPONSECONN.MESSAGE.ESOCKETTIMEDOUT;
        } else {
            if(result.err.resultDescription && result.err.resultDescription.indexOf(constants.RESPONSECONN.STATS.MISSING) != -1){
                result.response.resultCode = constants.RESPONSERESULT.MISSING_INVALID.resultCode;
                result.response.resultDescription = result.err;
            } else {
                result.response = constants.RESPONSECONN.MESSAGE.ERROR;
            }
        }
        funStats.error(result.response)
    }else
       log.log(JSON.stringify(result));

    return result;

}

module.exports = connection;