exports.registerUser = (payload, callbackRegister)=> {
    let userId = '',
        dataToUpdate = {
            "boatDetails.boatImage" : {
                original : "",
                thumbnail : ""
            },
            profilePic : {
                original : "",
                thumbnail : ""
            }
        },
        dataToSet = {
            firstName: payload.firstName.replace(/\b./g, (a) => a.toUpperCase()),
            lastName: payload.lastName.replace(/\b./g, (a) => a.toUpperCase()),
            DOB : payload.DOB,
            email: payload.email.toLowerCase(),
            countryCode : payload.countryCode,
            phoneNumber: payload.phoneNumber,
            homeMarina : payload.homeMarina,
            homeLake : payload.homeLake,
            registeredBy : payload.registeredBy,
            deviceDetails: {
                deviceType: payload.deviceType,
                deviceToken: payload.deviceToken
            },
            appVersion: payload.appVersion,
            registrationDate: new Date(),
            boatDetails : {
                boatImage : {
                    original : "",
                    thumbnail : ""
                },
                boatName : payload.boatName.replace(/\b./g, (a) => a.toUpperCase()),
                boatRegNum : payload.boatRegNum,
                year : payload.year,
                size : payload.size,
                type : payload.type,
                bio : payload.bio,
                tieUpPreference : payload.tieUpPreference
            },
            userBio : ""
        };

    if(payload.withoutVessel != undefined) dataToSet.withoutVessel = payload.withoutVessel;

    if(payload.socialId && payload.socialImageURL != null) {

        dataToSet.profilePic = {
            original: payload.socialImageURL,
            thumbnail: payload.socialImageURL
        };

        dataToUpdate.profilePic = {
            original: payload.socialImageURL,
            thumbnail: payload.socialImageURL
        };
    }

    if(payload.userBio) dataToSet.userBio = payload.userBio;

    if(payload.count) dataToSet.profileMeter = (16 - payload.count) * 6.25;

    async.auto({
        CHECK_REGISTER_WITH_SOCIAL_OR_EMAIL : (callback)=>{
            if (payload.socialId) {
                dataToSet.socialId = payload.socialId;
                callback()
            }
            else {
                util.cryptData(payload.password,(err,result)=>{
                    if(err) callback(err);
                    else {
                        dataToSet.password = result;
                        callback()
                    }
                });
            }
        },
        GENERATE_OTP : (callback)=>{
            util.generateUniqueCode(4, CONSTANTS.USER_TYPE.USER, (err, numberObj)=> {
                if (err) callback(err);
                else {
                    if (!numberObj || numberObj.number == null) callback();
                    else {
                        // dataToSet.OTPCode = numberObj.number;
                        dataToSet.OTPCode = 4444;
                        callback();
                    }
                }
            })
        },
        CHECK_BOAT_REG_NUM : (callback)=>{
            if(payload.boatRegNum != "")
            {
                DAO.getData(Models.user,{"boatDetails.boatRegNum" : payload.boatRegNum},{_id : 1},{lean : true},(err,res)=>{
                    if(err) callback(err);
                    else if(res.length == 0) callback(null,res);
                    else callback(ERROR.BOAT_REG_NUM_ALREADY_EXISTS)
                })
            }
            else callback(null,{})
        },
        CREATE_USER : ['CHECK_REGISTER_WITH_SOCIAL_OR_EMAIL','GENERATE_OTP','CHECK_BOAT_REG_NUM',(previousData,callback)=>{

            DAO.saveData(Models.user, dataToSet, (err, res) => {
                if (err) {
                    if (err.code == 11000 && err.message.indexOf('socialId_1') > -1) callback(ERROR.ALREADY_REGISTER);
                    else if (err.code == 11000 && err.message.indexOf('email_1') > -1) callback(ERROR.USER_ALREADY_REGISTERED);
                    else if (err.code == 11000 && err.message.indexOf('phoneNumber_1') > -1) callback(ERROR.PHONE_NUMBER_ALREADY_EXISTS);
                    else callback(err);
                }
                else {
                    userId = res._id;
                    dataToUpdate.accessToken = tokenManager.generateToken({
                        _id: userId,
                        timestamp: dataToSet.registrationDate,
                        userType: CONSTANTS.USER_TYPE.USER
                    });

                    callback();
                }
            })
        }]
        //SEND_SMS : ['GENERATE_OTP','CREATE_USER',(previousResult,callback)=>{
        //    util.sendSMSToMobile(payload.countryCode,payload.phoneNumber,dataToSend.OTPCode,(err,res)=>
        //    {
        //        if(err) callback(ERROR.ENTER_VALID_NUMBER);
        //        else callback(null,res)
        //    })
        //}],
    }, (err,previousResult)=> {
        if (err) {
            if (userId) {
                DAO.remove(Models.user, {_id: userId}, (error, result)=> {
                    callbackRegister(err);
                });
            }
            else callbackRegister(err);
        }
        else {
            callbackRegister(null, {
                OTPCode : dataToSet.OTPCode,
                email : payload.email,
                countryCode : payload.countryCode,
                phoneNumber: payload.phoneNumber
            });

            async.auto({
                UPLOAD_PROFILE_PIC : (callback)=>{
                    if (payload.isFile == true && !payload.socialImageURL) {
                        if(payload.profilePic && payload.profilePic.hapi.filename) {
                            if (payload.profilePic.hapi.headers['content-type'].split("/")[0] === 'image')
                            {
                                util.uploadProfilePicture(payload.profilePic, "user_" + payload.email, userPicFolder, (error, urls)=> {
                                    logger.error("profile image err---->>>>>>", error);
                                    logger.fatal("profile image url---->>>>>>", urls);
                                    dataToUpdate.profilePic = urls;
                                    callback(error, urls)
                                });
                            }
                            else callback(null,{})
                        }
                        else callback(null,{});
                    }
                    else callback(null,{});
                },
                UPLOAD_BOAT_PIC : (callback)=>{
                    if (payload.isFile == true) {
                        if(payload.boatImage && payload.boatImage.hapi.filename) {
                            if (payload.boatImage.hapi.headers['content-type'].split("/")[0] === 'image')
                            {
                                util.uploadProfilePicture(payload.boatImage, "boat_" + payload.email, boatPicFolder, (error, urls)=> {
                                    logger.error("boat image err---->>>>>>", error);
                                    logger.fatal("boat image url---->>>>>>", urls);
                                    dataToUpdate["boatDetails.boatImage"] = urls;
                                    callback(error, urls)
                                });
                            }
                            else callback(null,{})
                        }
                        else callback(null,{});
                    }
                    else callback(null,{});
                }
            },(err,finalUpdate)=>{
                DAO.update(Models.user,{_id : userId},{$set : dataToUpdate},{lean : true},(err,res)=>{
                    logger.error("update query err---->>>>",err);
                    logger.info("update query result---->>>>",res)
                })
            })
        }
    })
};