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 = validator(req, getCmd);

    if(err.length > 0)

    {
        log.addErrorSummary(req,req.body.clientName, postMethod+"_"+getCmd, "null", "Fail");
        // console.log(err);

        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

            // _flag : "or"

        }

        //GET Customer with cardId and cardOwnerIdList

        const result = await connection.requestJsonToD01(req,objectData, sendMemberCardCmd, getMethod);

        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
                }

            }

            
        }

        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);
                    // console.log(todo);
                    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.addSuccessSummary(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

                //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, resultObj.resultCode, resultObj.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);

        }

    }

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

    res.status(200).json(response);
    next();
};

function validator(req, api)

{

    // console.log(req.body);

    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);
    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
    };

    // console.log(data)

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

    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){

    // console.log(getCustomer.response)
    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;
            }

            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.resultDescription);

        }
    } 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, memberCard.response.resultCode, memberCard.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++){
            // console.log(resultData[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);
    // console.log(count);

    if(count.userOwnCardCount < userMembershipCardLimit 
        && count.cardOwnUserCount < userOwnerCardLimit){
            return true

    } else {
        return false;
    }
};