var stats = require('../helper/stats.js'); 
var validatorHelper = require('../helper/validator.js');
var connection = require('../helper/connection.js');
var responseMsg = require('../helper/responseMsg.js');
var log = require('../helper/log.js');

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

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

const getCmd = "CustomerMembership";

const sendCustomerCmd = "Customer";
const sendMemberCardCmd = "MemberCard";
const d01 = "D01";
const postMethod = constant.METHOD.POST;
const putMethod = constant.METHOD.PUT;
const getMethod = constant.METHOD.GET;

exports.postMembership = async function (req,  res,  next){

    var customerId;

    if(req.params.customerId){
        customerId = req.params.customerId

    } else if(req.params.userData && req.params.userType){

        customerId = req.params.userData+"@"+req.params.userType

    } else if(req.body.clientName && req.body.commandId){

        customerId = req.body.clientName+"@"+req.body.commandId;

    }

    log.startlog(req,postMethod+"_"+getCmd, req.body.commandId, customerId);
    log.logDetail.addInput(req,req.body.clientName, postMethod+"_"+getCmd, constant.REQUEST, req, req.body);

    var err = await validator(req, getCmd);

    if(err.length > 0)

    {
        log.addErrorSummary(req,req.body.clientName, postMethod+"_"+getCmd, "null", "Fail");
        var response = responseMsg.error(req, getCmd, 40300);

    }else

    {

        log.addSuccessSummary(req,req.body.clientName, postMethod+"_"+getCmd, "null", "Success");

        var objectData = {

            cardId : req.body.cardId, 

            cardOwnerIdList : customerId,

        }

        //GET Customer with cardId and cardOwnerIdList
        const result = await connection.requestJsonToD01(req,objectData, sendMemberCardCmd, getMethod, "or");
        log.logDetail.addInput(req,d01, getMethod+"_"+sendMemberCardCmd, constant.RESPONSE, result, result.response);

        var objDataGetCustomer = {

            req : req, 
            reqCustomer : {

                customerId : customerId

            }, 
            cmd : sendCustomerCmd, 

            method : getMethod, 
            resultData : result.response.resultData
        }

        var objDataMembership = {
            customerId : customerId,

            POST : {

                req : req, 

                reqMembership : {
                    cardId : req.body.cardId, 
                    cardOwnerIdList : [customerId]
                }, 
                cmd : sendMemberCardCmd, 
                method : postMethod, 

                resultData : result.response.resultData

            }, 
            PUT : {
                req : req, 
                reqMembership : {
                    // {"add":{"@cardOwnerIdList":"testAddedCard"}}
                    add : {
                        cardOwnerIdList : customerId
                    }
                }, 
                cmd : sendMemberCardCmd, 
                method : putMethod, 

                resultData : result.response.resultData,

                filter : {

                    cardId : req.body.cardId
                }
            }
        }

        try {
            if(typeof result.err === 'undefined'){

                var resultObj = result.response;
                if(resultObj.resultCode.startsWith("2")){
                    if(resultObj.resultData && resultObj.resultData.length>0){
    
                        stats.receiveRestResponse(d01,getMethod,sendMemberCardCmd,constant.SUCCESS);
                        log.addSuccessSummary(req,d01,getMethod+"_"+sendMemberCardCmd,resultObj.resultCode,resultObj.resultDescription);
    
                        var todo = await checkOwnerCard(resultObj.resultData,objectData);
                        if(todo){
                            var getCustomer = await getCustomerD01(req, objDataGetCustomer);
                            var response = await getCustomerHandler(req, getCustomer, resultObj, objDataMembership);
                        } else {
                            stats.receiveRestResponse(d01,getMethod,sendMemberCardCmd,constant.SUCCESS);
                            var response = responseMsg.direct(req,getCmd,constant.RESPONSECONN.MESSAGE.EXCEED);
                            log.addSuccessSummary(req,d01, getMethod+"_"+sendMemberCardCmd, response.resultCode, response.developerMessage);
                        }
    
                    } else { //data not found
    
                        stats.receiveRestResponse(d01,getMethod,sendMemberCardCmd,constant.RESPONSERESULT.DATA_NOT_FOUND.developerMessage);
                        log.addErrorSummary(req,d01,getMethod+"_"+sendMemberCardCmd,constant.RESPONSERESULT.DATA_NOT_FOUND.resultCode,constant.RESPONSERESULT.DATA_NOT_FOUND.developerMessage);
    
                        //get customer
                        
                        var getCustomer = await getCustomerD01(req, objDataGetCustomer);
                        var response = await getCustomerHandler(req, getCustomer, resultObj, objDataMembership);

                    }

                } else if(resultObj.resultCode.startsWith("404")){ //data not found

                    stats.receiveRestResponse(d01,getMethod,sendMemberCardCmd,constant.RESPONSERESULT.DATA_NOT_FOUND.developerMessage);
                    log.addErrorSummary(req,d01,getMethod+"_"+sendMemberCardCmd,constant.RESPONSERESULT.DATA_NOT_FOUND.resultCode,constant.RESPONSERESULT.DATA_NOT_FOUND.developerMessage);

                    //get customer

                    var getCustomer = await getCustomerD01(req, objDataGetCustomer);

                    var response = await getCustomerHandler(req, getCustomer, resultObj, objDataMembership);

                } else if(resultObj.resultCode.startsWith("5")){

                    stats.receiveRestResponse(d01, getMethod, sendMemberCardCmd, constant.ERROR);
                    var response = responseMsg.direct(req, getCmd, resultObj);
                    log.addErrorSummary(req,d01, getMethod+"_"+sendMemberCardCmd, response.resultCode, response.developerMessage);
                } else {
                    stats.receiveRestResponse(d01, getMethod, sendMemberCardCmd, constant.ERROR);
                    var response = responseMsg.error(req, getCmd, 50000);
                }
            } else {

                stats.receiveRestResponse(d01,getMethod,sendMemberCardCmd,constant.ERROR);

                var response = responseMsg.error(req,getCmd,50000);

            }
        } catch (err) {

            log.log(err);

            stats.receiveRestResponse(d01,getMethod,sendMemberCardCmd,constant.ERROR);
            var response = responseMsg.error(req,getCmd,50000);

        }

    }

    log.logDetail.addOutput(req,req.body.clientName, postMethod+"_"+getCmd, constant.RESPONSE, response, response); 
    res.status(200).json(response);

    next();

};

function validator(req, api)
{

    var list = [];

    list.push([true, "body", "commandId", "int"]);

    list.push([true, "body", "clientName", "string"]);

    list.push([true, "body", "cardId", "string"]);
    // list.push([true, "body", "clientName", "string"]);
    // list.push([true, "body", "firstName", "string"]);
    // list.push([true, "body", "lastName", "string"]);
    // list.push([true, "body", "mobile", "string"]);
    // list.push([true, "body", "emailAddress", "string"]);
    var err = validatorHelper(req, list, api)

    if(err.length > 0)

        stats.receiveBadRequest(req.method, api);    
    else

        stats.receiveRequest(req.method, api);

    return err;

}

async function getCustomerD01(req, data){

    var responseData = {

        isErr : false, 
        isDataNotFound : false, 

        isDirect : false
    };

    const resultCustomer = await connection.requestJsonToD01(req, data.reqCustomer, data.cmd, data.method);
    log.logDetail.addInput(req,d01, getMethod+"_"+sendCustomerCmd, constant.RESPONSE, resultCustomer, resultCustomer.response);

    var resultObj = resultCustomer.response

    if(typeof resultCustomer.err === 'undefined'){
        if(resultObj.resultCode.startsWith("2")){
            if(resultObj.resultData && resultObj.resultData.length>0){
                responseData.response = resultObj;
            } else {
                responseData.response = resultObj;
                responseData.isDataNotFound = true;
            }
        } else if(resultObj.resultCode.startsWith("404") || resultObj.resultCode.startsWith("5")){
            responseData.response = resultObj;
            responseData.isDirect = true;
        } else {
            responseData.response = resultObj;
            responseData.isErr = true;
        }
    } else {
        responseData.response = resultObj;
        responseData.isErr = true;
    }

    return responseData;
}

async function postMemberCardD01(req, data){

    var responseData = {

        isErr : false, 
        isDataNotFound : false, 

        isDirect : false
    };

    const resultCustomer = await connection.requestJsonToD01(req,data.reqMembership, data.cmd, data.method, data.filter);

    log.logDetail.addInput(req,d01, data.method+"_"+sendMemberCardCmd, constant.RESPONSE, resultCustomer, resultCustomer.response);

    var resultObj = resultCustomer.response

    if(typeof resultCustomer.err === 'undefined'){
        if(resultObj.resultCode.startsWith("2")){
            responseData.response = resultObj;
        } else if(resultObj.resultCode.startsWith("404") || resultObj.resultCode.startsWith("5")){
            responseData.response = resultObj;
            responseData.isDirect = true;
        } else {
            responseData.response = resultObj;
            responseData.isErr = true;
        }
    } else {
        responseData.response = resultObj;
        responseData.isErr = true;
    }

    return responseData;
}

async function getCustomerHandler(req, getCustomer, getMemberCard, objDataMembership){

    if(!getCustomer.isErr){
        //if get data exits post membercard

        if(!getCustomer.isDataNotFound){
            //post membercard
            stats.receiveRestResponse(d01, getMethod, sendCustomerCmd, constant.SUCCESS);
            log.addSuccessSummary(req,d01, getMethod+"_"+sendCustomerCmd, getCustomer.response.resultCode, getCustomer.response.resultDescription);

            //check post or put

            function getResultTodo(req, getMemberCard, objDataMembership){

                var result = {
                    doPost : true,
                    doNothing : false
                }
                
                for(var i = 0 ; i < getMemberCard.resultData.length ; i++){
                    if(req.body.cardId === getMemberCard.resultData[i].cardId){
                        if(getMemberCard.resultData[i].cardOwnerIdList.includes(objDataMembership.customerId)){
                            result.doNothing = true;
                            break;
                        } else {
                            result.doPost = false;
                            break;
                        }
                    } else if(i == getMemberCard.resultData.length-1){
                        result.doPost = true;
                        break;
                    }
                }

                return result;
            }

            if(!getMemberCard.resultData){ // get membercard data not found do post
                var getResult = {

                    doPost : true,
                    doNothing : false
                }
            } else { // get data exits check todo
                var getResult = await getResultTodo(req, getMemberCard, objDataMembership);
            }
            
            if(getResult.doNothing){

                var response = responseMsg.success(req,getCmd)
            } else {
                if(getResult.doPost){
                    var postMemberCard = await postMemberCardD01(req, objDataMembership.POST);
                    var response = await postMemberCardHandler(req, postMemberCard)
                } else {
                    var putMemberCard = await postMemberCardD01(req, objDataMembership.PUT);
                    var response = await postMemberCardHandler(req, putMemberCard)
                }
            }
            
        } else {
            stats.receiveRestResponse(d01, getMethod, sendCustomerCmd, constant.RESPONSERESULT.DATA_NOT_FOUND.resultDescription);

            var response = responseMsg.error(req, getCmd, 40401);
            log.addErrorSummary(req,d01, getMethod+"_"+sendCustomerCmd, response.resultCode, response.developerMessage);
        }

    } else if(getCustomer.isDirect){

        stats.receiveRestResponse(d01, getMethod, sendCustomerCmd, constant.ERROR);
        var response = responseMsg.direct(req, getCmd, getCustomer.response);
        log.addErrorSummary(req,d01, getMethod+"_"+sendCustomerCmd, getCustomer.response.resultCode, getCustomer.response.resultDescription);
    } else {

        stats.receiveRestResponse(d01, getMethod, sendCustomerCmd, constant.ERROR);

        var response = responseMsg.error(req, getCmd, 50000);
    }
    //else end flow

    return response;
};

async function postMemberCardHandler(req, memberCard){

    if(!memberCard.isErr){
        stats.receiveRestResponse(d01, postMethod, sendMemberCardCmd, constant.SUCCESS);
        var response = responseMsg.direct(req, getCmd, memberCard.response);
        log.addSuccessSummary(req,d01, postMethod+"_"+sendMemberCardCmd, response.resultCode, response.developerMessage);
    } else if(memberCard.isDirect){

        stats.receiveRestResponse(d01, postMethod, sendMemberCardCmd, constant.ERROR);
        var response = responseMsg.direct(req, getCmd, memberCard.response);

        log.addErrorSummary(req,d01, postMethod+"_"+sendMemberCardCmd, response.resultCode, response.developerMessage);
    } else {

        stats.receiveRestResponse(d01, postMethod, sendMemberCardCmd, constant.ERROR);

        var response = responseMsg.error(req, getCmd, 50000);
    }

    return response;
};

async function checkOwnerCard(resultData,objectData){

    var userOwnerCardLimit = cfg.service.D01.userOwnerCardLimit
    var userMembershipCardLimit = cfg.service.D01.userMembershipCardLimit

    var cardId = objectData.cardId;
    var customerId = objectData.cardOwnerIdList;
    
    var countf = async function (resultData){
        var dataCount = {
            userOwnCardCount : 0,
            cardOwnUserCount : 0
        }

        for(var i = 0 ; i < resultData.length ; i++){
            if(resultData[i].cardOwnerIdList.includes(customerId)){
                dataCount.userOwnCardCount = dataCount.userOwnCardCount++;

            }
            if(resultData[i].cardId === cardId){
                dataCount.cardOwnUserCount = resultData[i].cardOwnerIdList.length;
            }
        }

        return dataCount;
    };
    var count = await countf(resultData);

    if(count.userOwnCardCount < userMembershipCardLimit 

        && count.cardOwnUserCount < userOwnerCardLimit){
            return true
    } else {
        return false;
    }
};