import moment from "moment-jalaali";
import * as path from "path";

const xlsx = require('xlsx');
const User = require('../models/User')
const Job = require('../models/Job')
const StoreInfo = require('../models/StoreInfo')
const Food = require('../models/Food')
const DiscountCode = require('../models/DiscountCode')
const GetTokenLimit = require('../models/GetTokenLimit')
const {body, validationResult} = require('express-validator')
const bcrypt = require('bcryptjs')
const jwt = require('jsonwebtoken')
const sharp = require('sharp')
const {secretKey, getID} = require('./../authentication')
const {sms} = require('../SMSModule')
const {_sr} = require('../plugins/serverResponses')
const {res404, res500, hasWhiteSpaces, isLatinCharactersWithSymbol, generateRandomDigits, removeWhiteSpaces, checkValidations} = require('../plugins/controllersHelperFunctions')
const permissions = require('../plugins/permissions')
const fs = require('fs')
// const path = require('path')
const axios = require('axios')
const {sendSingle, sendMulti} = require('./../plugins/pushNotif').notification

////// variables
const profileWidth = 500
const profileHeight = 500
const profileQuality = 100
const apiKey = 'eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiIsImp0aSI6ImRiYjIwMmRhYzAxYzFjNzgwYjgxNWQyZDgyMWNmNmY1Njk0MThhMGE3N2Q1M2Y0OTZkYzQzYTgxMmNmN2U3ZWJjNzI5MjY5YjkxMjA4MTYyIn0.eyJhdWQiOiIxNDk3OSIsImp0aSI6ImRiYjIwMmRhYzAxYzFjNzgwYjgxNWQyZDgyMWNmNmY1Njk0MThhMGE3N2Q1M2Y0OTZkYzQzYTgxMmNmN2U3ZWJjNzI5MjY5YjkxMjA4MTYyIiwiaWF0IjoxNjI3MzI2Mzc0LCJuYmYiOjE2MjczMjYzNzQsImV4cCI6MTYyOTkxODM3NCwic3ViIjoiIiwic2NvcGVzIjpbImJhc2ljIl19.hyKNSy4fmPps6yIdm33Wof-mES9ujh5lmI3VFWyecbkNCm9ATPwsZ9s53A3a1wPJmHfLBXpCcob5NGL-GjZlVfqfRBiReRMr_iniCjUOnqENfFwVEJutxI-xrzVe7PZzOgx1Vr6WwSUHvQ36eJSS1lBlHlqCgwRbkG0hs4YdZsKhzhfYdlAluNw9djjUAMbRWZVL0EluP9CYko4w8tB0KHUZMZYGQcevCfb_3OU9ygHo7B--Z5aTPfm7IK4eP0gHsZ_t857B3tu3ZJB1mkgxc2R9gZUflKqj1ZqkYiR0uMGP-571enXh6pYQLXL2k-gOxLIedCaE6XytxVXhENnotA';

// user scores
// const userRegistrationScore = 100
// const userEmailVerifyScore = 50
// const invitePoint = 5
const limit = 20


/////////////////////////////////////////////////////////////////////// admin
module.exports.register_admin = [
  [
    body('first_name')
       .notEmpty().withMessage(_sr['fa'].required.first_name),

    body('last_name')
       .notEmpty().withMessage(_sr['fa'].required.last_name),

    body('username')
       .isLength({min: 2}).withMessage(_sr['fa'].min_char.min2)
       .bail()
       .custom((value, {req}) => {
         if (hasWhiteSpaces(value)) return Promise.reject(_sr['fa'].response.whiteSpace)
         else return true
       })
       .bail()
       .custom((value, {req}) => {
         if (!isLatinCharactersWithSymbol(value)) return Promise.reject(_sr['fa'].response.latinChar)
         else return true
       })
       .bail()
       .custom((value, {req}) => {
         return User.findOne({username: value})
            .then(user => {
              if (user) return Promise.reject(_sr['fa'].duplicated.username)
              else return true
            })
       }),

    body('password')
       .isLength({min: 4}).withMessage(_sr['fa'].min_char.min4)
       .custom((value, {req}) => {
         if (value === req.body.password_confirmation) return Promise.resolve()
         else return Promise.reject(_sr['fa'].response.passwords_not_match)
       })
  ],
  async (req, res) => {
    const errors = validationResult(req)
    if (!errors.isEmpty()) return res.status(422).json({validation: errors.mapped()})

    const creatorID = await getID(req)
    const {username, first_name, last_name, email, mobile_number , permissions , branches} = req.body
    const data = {username, first_name, last_name, email, mobile_number}
    data.permissions = JSON.parse(permissions)
    data.branches = JSON.parse(branches)

    if (req.files && req.files.profile_pic) {
      const image = req.files.profile_pic
      const imageName = 'user_' + Date.now() + '_' + req.body.username + '.' + image.mimetype.split('/')[1]
      data.profile_pic = imageName
      try {
        const target = sharp(image.data)
        await target
           .resize(profileWidth, profileHeight, {fit: 'cover'})
           .jpeg({quality: profileQuality})
           .toFile(`./static/uploads/images/users/${imageName}`)
      } catch (e) {
        return res500(res, e)
      }
    }

    bcrypt.genSalt(10, (err, salt) => {
      bcrypt.hash(req.body.password, salt, (err, hash) => {
        if (err) console.log(err)
        data.password = hash
        data.scope = ['admin']
        data._creator = creatorID
        const newAdmin = new User(data)
        newAdmin.save(err => {
          if (err) return res500(res, err)
          return res.json({message: _sr['fa'].response.success_save})
        })
      })
    })
  }
]

module.exports.get_all_admins = [
  (req, res) => {
  const branchId = req?.params?.branchId
    // const filter = req?.user?.permissions.includes('super-admin') ? {scope: ['admin'], private: false} : {scope: ['admin'], private: false , branches : branchId}
    const filter = {scope: ['admin'], private: false, branches: branchId}
    User.paginate(filter, {
      page: req?.query?.page,
      limit,
      select: '-password -token'
    }, (err, users) => {
      if (err) return res500(res, err.message)
      else return res.json(users)
    })
  }
]

module.exports.get_all_users = [
  (req, res) => {
  const branchId = req?.params?.branchId
    const filter = {registration_done: true, scope: ['user'], branches : branchId}
    User.paginate(filter, {
      page: req.query.page,
      limit,
      select: '-password -token'
    }, (err, users) => {
      if (err) return res500(res, err)
      else return res.json(users)
    })
  }
]

module.exports.get_all_users_for_reports = [
  async (req, res) => {
    try {
      const branchId = req?.params?.branchId
      const filter = {registration_done: true, scope: ['user'] , branches : branchId}
      const users = await User.find(filter).select('-password -token')
      return res.json(users)
    } catch (error) {
      return res500(res, _sr['fa'].response.unknownError)
    }
  }
]

module.exports.get_all_users_without_paginate = [
  (req, res) => {
    const branchId = req?.params?.branchId
    const filter = {registration_done: true, scope: ['user'] , branches : branchId}
    User.find(filter).select('-password -token').exec((err, users) => {
      if (err) return res500(res, err)
      else return res.json(users)
    })
  }
]

module.exports.get_one_admin = [
  (req, res) => {
    User.findById(req.params.id).select('-password -token ').exec(async (err, user) => {
      if (err || !user) return res404(res, err)
      const clone = JSON.parse(JSON.stringify(user))
      try {
        clone.discount_codes = await DiscountCode.find({discount_user_id: user._id})
        return res.json(clone)
      } catch (e) {
        return res500(res, e)
      }
    })
  }
]

module.exports.permissions = [
  (req, res) => {
    return res.json(permissions)
  }
]

module.exports.update_admin = [
  [
    body('first_name')
       .notEmpty().withMessage(_sr['fa'].required.first_name),

    body('last_name')
       .notEmpty().withMessage(_sr['fa'].required.last_name),

    body('username')
       .isLength({min: 2}).withMessage(_sr['fa'].min_char.min2)
       .bail()
       .custom((value, {req}) => {
         if (hasWhiteSpaces(value)) return Promise.reject(_sr['fa'].response.whiteSpace)
         else return true
       })
       .bail()
       .custom((value, {req}) => {
         if (!isLatinCharactersWithSymbol(value)) return Promise.reject(_sr['fa'].response.latinChar)
         else return true
       })
       .bail()
       .custom((value, {req}) => {
         return User.findOne({username: value})
            .then(user => {
              if (user && user._id.toString() !== req.params.id) return Promise.reject(_sr['fa'].duplicated.username)
              else return true
            })
       }),

    body('password')
       .isLength({min: 4}).withMessage(_sr['fa'].min_char.min4)
       .custom((value, {req}) => {
         if (value === req.body.password_confirmation) return Promise.resolve()
         else return Promise.reject(_sr['fa'].response.passwords_not_match)
       })
  ],
  async (req, res) => {
    const errors = validationResult(req)
    if (!errors.isEmpty()) return res.status(422).json({validation: errors.mapped()})

    const creatorID = await getID(req)
    const {username, first_name, last_name, email, mobile_number, permissions, branches} = req.body
    const data = {username, first_name, last_name, email, mobile_number}
    data._creator = creatorID
    data.permissions = JSON.parse(permissions)
    data.branches = JSON.parse(branches)

    if (req.files && req.files.profile_pic) {
      const image = req.files.profile_pic
      const imageName = 'user_' + Date.now() + '_' + req.body.username + '.' + image.mimetype.split('/')[1]
      data.profile_pic = imageName
      try {
        const target = sharp(image.data)
        await target
           .resize(profileWidth, profileHeight, {fit: 'cover'})
           .jpeg({quality: profileQuality})
           .toFile(`./static/uploads/images/users/${imageName}`)
      } catch (e) {
        return res500(res, e)
      }
    }

    User.findByIdAndUpdate(req.params.id, data, (err, oldData) => {
      if (err || !oldData) return res404(res, err)
      if (req.files && req.files.profile_pic && oldData.profile_pic) {
        fs.unlink(`./static/${oldData.profile_pic}`, err => {
          if (err) console.log(err)
        })
      }
      return res.json({message: _sr['fa'].response.success_save})
    })
  }
]

module.exports.remove_admin = [
  (req, res) => {
    User.findByIdAndDelete(req.params.id, (err, data) => {
      if (err || !data) return res404(res, err)
      if (data.profile_pic) {
        fs.unlink(`./static/${data.profile_pic}`, err => {
          if (err) console.log(err)
        })
      }
      return res.json({message: _sr['fa'].response.success_remove})
    })
  }
]

module.exports.change_admin_password_by_another = [
  [
    body('password')
       .isLength({min: 4}).withMessage(_sr['fa'].min_char.min4)
       .custom((value, {req}) => {
         if (value === req.body.password_confirmation) return Promise.resolve()
         else return Promise.reject(_sr['fa'].response.passwords_not_match)
       })
  ],
  (req, res) => {
    const errors = validationResult(req)
    if (!errors.isEmpty()) return res.status(422).json({validation: errors.mapped()})

    User.findById(req.params.id, (err, user) => {
      if (err || !user) return res404(res, err)
      bcrypt.genSalt(10, (err, salt) => {
        bcrypt.hash(req.body.password, salt, (err, hash) => {
          if (err) console.log(err)
          user.password = hash
          user.save(err => {
            if (err) return res500(res, err)
            return res.json({message: _sr['fa'].response.success_save})
          })
        })
      })
    })
  }
]

////////////////////////////////////////////////////////////////////// user discount code
module.exports.generate_discount_code_for_users = [
  [
    body('discount_amount')
       .notEmpty().withMessage(_sr['fa'].required.discount_amount)
       .bail()
       .isNumeric().withMessage(_sr['fa'].format.number),

    body('discount_expire_date')
       .notEmpty().withMessage(_sr['fa'].required.discount_expire_date),

    body('discount_user_id')
       .if((value, {req}) => !req.body.newDiscountIsPublic)
       .notEmpty().withMessage(_sr['fa'].required.user_id),

    body('newDiscountIsPublic')
       .notEmpty().withMessage('Discount public status must be specified'),

    body('publicDiscountIsAuto')
       .notEmpty().withMessage('Discount public code method must be specified'),

    body('customDiscountCode')
       .if((value, {req}) => req.body.newDiscountIsPublic && !req.body.publicDiscountIsAuto)
       .notEmpty().withMessage(_sr['fa'].required.discount_code),

    body('branchId')
        .notEmpty().withMessage(_sr['fa'].required.field)
        .bail()
        .custom((value, {req}) => {
          return StoreInfo.findOne({_id: value})
              .then(store => {
                if (!store) return Promise.reject(_sr['fa'].not_found.item_id)
                else return true
              })
        })

  ],
  checkValidations(validationResult),
  async (req, res) => {
    const {branchId , discount_amount, discount_expire_date, discount_user_id, newDiscountIsPublic, publicDiscountIsAuto, customDiscountCode, menuTypeId} = req.body

    async function generateDiscountCode() {
      try {
        let code = generateRandomDigits(6)
        const checkDiscountCodes = await DiscountCode.findOne({discount_code: code, discount_user_id: discount_user_id, isPublic: false})
        if (checkDiscountCodes) generateDiscountCode()
        else return code
      } catch (e) {
        return res500(res, e)
      }
    }

    async function generatePublicDiscountCode() {
      try {
        let code = generateRandomDigits(6)
        const checkDiscountCodes = await DiscountCode.findOne({discount_code: code, isPublic: true})
        if (checkDiscountCodes) generatePublicDiscountCode()
        else return code
      } catch (e) {
        return res500(res, e)
      }
    }

    const data = {
      branchId,
      discount_amount,
      menuTypeId,
      discount_expire_date: discount_expire_date
    }

    if (newDiscountIsPublic) {
      data.isPublic = true
      if (publicDiscountIsAuto) data.discount_code = await generatePublicDiscountCode()
      else {
        try {
          const checkDiscountCodes = await DiscountCode.findOne({discount_code: customDiscountCode, isPublic: true})
          if (checkDiscountCodes) return res.status(422).json({validation: {discount_code: {msg: 'کد تخفیف تکراری است'}}})
          else data.discount_code = customDiscountCode
        } catch (e) {
          return res500(res, e)
        }
      }

      const users = await User.find({registration_done : true , test : true}) //, test : true

      const tokens = []
      let mobiles = []

      for (const user of users) {
        if (user.fcmToken) tokens.push(user.fcmToken)
        if (user.mobile_number) mobiles.push(user.mobile_number)
      }


      const smsTemplate = `با سلام یک عدد کد تخفیف ${data.discount_amount} درصدی تا تاریخ ${moment(data.discount_expire_date, 'X').format('jYYYY/jMM/jDD')} به شما اختصاص داده شد کد: ${data.discount_code} رستوران برگ لغو11`

      //--------------------- send notif to user --------------------------
      const messageUser = {
        title: 'کد تخفیف',
        body: smsTemplate
      }
      const payloadUser = {
        notification: messageUser,
      };
      const inputUser = {
        registrationTokens: tokens,
        payload: payloadUser
      }
      await sendMulti(inputUser)
      //-------------------------------------------------------------------

      const smsResult = await sms(mobiles, smsTemplate)

      if (!smsResult || !smsResult.data.IsSuccessful) {
        console.log(smsResult)
        // return res500(res, `مشکلی در ارسال پیامک پیش آمده است`)
      }

    } else {
      data.discount_code = await generateDiscountCode()
      data.discount_user_id = discount_user_id

      const user = await User.findById(discount_user_id)

      if (user) {
        let smsTemplate = ''
        if (user?.fromWhere === 'app') smsTemplate = `با سلام یک عدد کد تخفیف ${data.discount_amount} درصدی تا تاریخ ${moment(data.discount_expire_date, 'X').format('jYYYY/jMM/jDD')} به شما اختصاص داده شد کد: ${data.discount_code}
         رستوران برگ
         لینک : https://app.bargrestaurant.com/discountCode`
        else smsTemplate = `با سلام یک عدد کد تخفیف ${data.discount_amount} درصدی تا تاریخ ${moment(data.discount_expire_date, 'X').format('jYYYY/jMM/jDD')} به شما اختصاص داده شد کد: ${data.discount_code} رستوران برگ 
        لینک : https://app.bargrestaurant.com/discountCodes
        `


        //--------------------- send notif to user --------------------------
        const messageUser = {
          title: 'کد تخفیف',
          body: smsTemplate
        }
        const payloadUser = {
          notification: messageUser,
        };
        const inputUser = {
          registrationTokens: user.fcmToken,
          payload: payloadUser
        }
        await sendSingle(inputUser)
        //-------------------------------------------------------------------

        const smsResult = await sms(user.mobile_number, smsTemplate)

        if (!smsResult || !smsResult.data.IsSuccessful) {
          console.log(smsResult)
          // return res500(res, `مشکلی در ارسال پیامک پیش آمده است`)
        }
      }
    }

    const newDiscount = DiscountCode(data)
    newDiscount.save((err, data) => {
      if (err) return res500(res, err)
      else return res.json(data)
    })
  }
]

module.exports.get_all_discounts_for_admin = [
  (req, res) => {
    const filter = {branchId: req?.params?.branchId}
    DiscountCode.paginate(filter, {
      page: req.query.page,
      limit,
      populate: {
        path: 'discount_user_id',
        select: 'first_name last_name business_code mobile_number score'
      }
    }, (err, data) => {
      if (err) return res500(res, err)
      else return res.json(data)
    })
  }
]

module.exports.delete_discount_code = [
  (req, res) => {
    DiscountCode.findByIdAndRemove(req.params.id, (err, oldData) => {
      if (err || !oldData) return res404(res, err)
      else return res.json({message: _sr['fa'].response.success_save})
    })
  }
]

module.exports.getAllDiscountCodeOfUser = [
  async (req, res) => {
    try {
      const discounts = await DiscountCode.find({
        branchId: req?.params?.branchId,
        $or : [
          {isPublic : true},
          {
            discount_user_id: req.user._id,
            used_by: {'$nin': req.user._id},
            discount_expire_date: {'$gte': +new Date().setHours(0, 0, 0, 0)}
          }
        ]
      })
      const user = await User.findById(req.user._id).select('first_name last_name')

      if (!user) return res404(res, 'اطلاعات کاربر یافت نشد')

      const clone = JSON.parse(JSON.stringify(discounts))

      clone.map(item => {
        item.user = user
        item.used = item.used_by.includes(req.user._id)
      })

      return res.json(clone)
    } catch (error) {
      return res500(res, _sr['fa'].response.unknownError)
    }
  }
]

/////////////////////////////////////////////////////////////////////// user

/////////////// user registration
module.exports.get_phone_number = [
  [
    body('mobile_number')
       .notEmpty().withMessage(_sr['fa'].required.phone_number)
       .bail()
       .isMobilePhone().withMessage(_sr['fa'].format.phone_number)
  ],
  checkValidations(validationResult),
  async (req, res) => {
    try {
      let getTokenLimit = await GetTokenLimit.find({phone: req.body.mobile_number})

      if (getTokenLimit.length) return res.status(429).json({message: 'شما هر دو دقیقه یکبار مجاز به گرفتن کد تایید می باشید'})

      const user = await User.findOne({mobile_number: req.body.mobile_number})
      if (user) {
        if (user.registration_done) {
          return res.json({
            // hasAccount: true,
            registration_done: user.registration_done
          })
        } else {
          user.token = await generateRandomDigits(6)
          user.save(err => {
            if (err) return res500(res, err)
          })

          const smsTemplate = `
        با تشکر از ثبت نام شما در برگ من
        کد فعال سازی شما: ${user.token}
        لغو11
        `

          const smsResult = await sms(req.body.mobile_number, smsTemplate)

          if (!smsResult || !smsResult.data.IsSuccessful) {
            console.log(smsResult)
            return res500(res, `مشکلی در ارسال پیامک پیش آمده است`)
          }

          await GetTokenLimit.create({
            phone: req.body.mobile_number
          });

          return res.json({
            // hasAccount: true,
            registration_done: user.registration_done
          })
        }
      } else {
        const data = {
          mobile_number: req.body.mobile_number,
          registration_done: false
        }
        let token = await generateRandomDigits(6)
        data.token = token

        const smsTemplate = `
        با تشکر از ثبت نام شما در برگ من
        کد فعال سازی شما: ${token}
        لغو11
        `

        const smsResult = await sms(req.body.mobile_number, smsTemplate)

        if (!smsResult || !smsResult.data.IsSuccessful) {
          console.log(smsResult)
          return res500(res, `مشکلی در ارسال پیامک پیش آمده است`)
        }

        await GetTokenLimit.create({
          phone: req.body.mobile_number
        });

        const newUser = new User(data)
        newUser.save((err, data) => {
          if (err) return res500(res, err)
          return res.json({registration_done: false})
        })
      }
    } catch (e) {
      console.log(e.message)
      return res500(res, _sr['fa'].response.unknownError)
    }
  }
]

module.exports.resend_user_resgistration_token = [
  async (req, res) => {
    try {
      const getTokenLimit = await GetTokenLimit.find({phone: req.params.mobile_number});

      if (getTokenLimit.length) return res.status(429).json({message: 'شما هر دو دقیقه یکبار مجاز به گرفتن کد تایید می باشید'})

      const user = await User.findOne({mobile_number: req.params.mobile_number})
      if (user) {
        const smsTemplate = `
        با تشکر از ثبت نام شما در برگ من
        کد فعال سازی شما: ${user.token}
        لغو11
        `
        const smsResult = await sms(req.params.mobile_number, smsTemplate)

        if (!smsResult || !smsResult.data.IsSuccessful) {
          return res500(res, `مشکلی در ارسال پیامک پیش آمده است`)
        }

        await GetTokenLimit.create({
          phone: req.params.mobile_number
        });

        return res.json({message: 'کد فعال سازی دوباره برای شما ارسال شد.'})
      } else return res404(res, 'برای این شماره هیچ کد تایید ای یافت نشد.')

    } catch (e) {
      console.log('resend_user_resgistration_token', error.message)
      return res404(res, 'برای این شماره هیچ کد تایید ای یافت نشد.')
    }
  }
]

module.exports.generate_temp_token_for_user = [
  async (req, res) => {
    try {
      const getTokenLimit = await GetTokenLimit.find({phone: req.params.mobile_number});

      if (getTokenLimit.length) return res.status(429).json({message: 'شما هر دو دقیقه یکبار مجاز به گرفتن کد تایید می باشید'})

      const user = await User.findOne({mobile_number: req.params.mobile_number})
      if (user) {

        const token = await generateRandomDigits(6)
        const smsTemplate = `
        با تشکر از ثبت نام شما در برگ من
        کد فعال سازی شما: ${token}
        لغو11
        `

        user.token = token

        await user.save()

        const smsResult = await sms(req.params.mobile_number, smsTemplate)

        if (!smsResult || !smsResult.data.IsSuccessful) {
          return res500(res, `مشکلی در ارسال پیامک پیش آمده است`)
        }

        await GetTokenLimit.create({
          phone: req.params.mobile_number
        });

        return res.json({message: 'کد فعال سازی برای شما ارسال شد.'})
      } else return res404(res, 'کاربر مورد نظر وجود ندارد')
    } catch (error) {
      console.log('generate_temp_token_for_user', error.message)
      return res500(res, _sr['fa'].response.unknownError);
    }
  }
]

module.exports.validate_user_temp_token = [
  [
    body('mobile_number')
       .notEmpty().withMessage(_sr['fa'].required.phone_number),

    body('token')
       .notEmpty().withMessage(_sr['fa'].required.token)
  ],
  checkValidations(validationResult),
  async (req, res) => {
    try {
      const user = await User.findOne({mobile_number: req.body.mobile_number, token: req.body.token})
      if (user) {
        user.token = null
        const response = {registration_done: user.registration_done}
        if (user.registration_done) {
          response.token = await jwt.sign({_id: user._id}, secretKey, {expiresIn: '1000d'})
          user.token = response.token;
          user.fromWhere = req.body?.fromWhere;
          user.save((err, newUserData) => {
            if (err) return res500(res, _sr['fa'].response.unknownError)
            return res.json(response)
          })
        } else {
          return res.json(response)
        }
      } else return res404(res, 'کد تایید معتبر نمیباشد.')
    } catch (e) {
      return res404(res, 'برای این شماره هیچ کد تایید ای یافت نشد.')
    }
  }
]

module.exports.add_name_to_user_registration = [
  [
    body('first_name')
       .notEmpty().withMessage(_sr['fa'].required.first_name)
       .bail()
       .custom((value, {req}) => {
         if (removeWhiteSpaces(value).length < 3) return Promise.reject(_sr['fa'].min_char.min2)
         else return true
       }),
    body('last_name')
       .notEmpty().withMessage(_sr['fa'].required.last_name)
       .bail()
       .custom((value, {req}) => {
         if (removeWhiteSpaces(value).length < 3) return Promise.reject(_sr['fa'].min_char.min2)
         else return true
       }),

    body('job')
       .notEmpty().withMessage(_sr['fa'].required.field),

    body('invitation')
       .custom((value, {req}) => {
         if (value) {
           return User.findOne({business_code: value, registration_done: true})
              .then(user => {
                if (!user) return Promise.reject('کد دعوت وارد شده صحیح نمی باشد')
                else return true
              })
         } else {
           return true
         }
       }),
  ],
  checkValidations(validationResult),
  (req, res) => {
    User.findOne({mobile_number: req.body.mobile_number}, (err, user) => {
      if (err || !user) return res404(res, _sr['fa'].not_found.user_id)
      user.first_name = req.body.first_name
      user.last_name = req.body.last_name
      user.job = req.body.job
      user.invitation = req.body.invitation
      user.save((err, newUserData) => {
        if (err) return res500(res, err)
        return res.json({message: _sr['fa'].response.success_save})
      })
    })
  }
]

module.exports.add_password_to_user_registration = [
  [
    body('password')
       .custom((value, {req}) => {
         if (removeWhiteSpaces(value).length < 4) return Promise.reject(_sr['fa'].min_char.min4)
         else return true
       }),

    body('password_confirmation')
       .custom((value, {req}) => {
         if (removeWhiteSpaces(value).length < 4) return Promise.reject(_sr['fa'].min_char.min4)
         else return true
       })
       .custom((value, {req}) => {
         if (value === req.body.password) return true
         else return Promise.reject(_sr['fa'].response.passwords_not_match)
       }),

    body('branchId')
        .notEmpty().withMessage(_sr['fa'].required.field)
        .bail()
        .custom((value, {req}) => {
          return StoreInfo.findOne({_id: value})
              .then(store => {
                if (!store) return Promise.reject(_sr['fa'].not_found.item_id)
                else return true
              })
        })
  ],
  checkValidations(validationResult),
  async (req, res) => {
    try {
      const {branchId, mobile_number, password, deviceId, platform ,fromWhere} = req.body
      const user = await User.findOne({mobile_number: mobile_number})
      if (!user) return res404(res, _sr['fa'].not_found.user_id)

      const storeInfo = await StoreInfo.findOne({_id : branchId})

      const userInvite = await User.findOne({business_code: user.invitation, registration_done: true})

      // generate user password hash
      const salt = await bcrypt.genSalt(10)
      const hash = await bcrypt.hash(password, salt)

      // generate user business code
      const users = await User.find({registration_done: true, scope: ['user']})
      const businessCode = new Date().getFullYear().toString() + (users.length + 1).toString()

      // add new fields to user
      const token = jwt.sign({_id: user._id}, secretKey, {expiresIn: '1000d'})
      user.token = token
      user.password = hash
      user.business_code = businessCode
      user.registration_done = true
      user.score = storeInfo?.userRegistrationScore
      user.scoreLogs = [
        {
          score: storeInfo?.userRegistrationScore,
          forWhat: 'register',
          action: 'increase'
        }
      ]
      user.deviceId = deviceId
      user.platform = platform
      user.fromWhere = fromWhere
      user.branches = [branchId]

      if (userInvite) {
        userInvite.score = userInvite.score + storeInfo?.invitePoint
        userInvite.scoreLogs = [
          {
            score: storeInfo?.invitePoint,
            forWhat: 'invite',
            action: 'increase'
          }
        ]

        await userInvite.save()
      }

      // save user
      user.save((err, newUserData) => {
        if (err) return res500(res, err)
        return res.json({token: token})
      })
    } catch (e) {
      return res500(res, e.message)
    }
  }
]

module.exports.change_user_password = [
  [
    body('password')
       .custom((value, {req}) => {
         if (removeWhiteSpaces(value).length < 4) return Promise.reject(_sr['fa'].min_char.min4)
         else return true
       }),

    body('password_confirmation')
       .custom((value, {req}) => {
         if (removeWhiteSpaces(value).length < 4) return Promise.reject(_sr['fa'].min_char.min4)
         else return true
       })
       .custom((value, {req}) => {
         if (value === req.body.password) return true
         else return Promise.reject(_sr['fa'].response.passwords_not_match)
       })
  ],
  checkValidations(validationResult),
  async (req, res) => {
    try {
      const userID = await getID(req)
      const user = await User.findById(userID)
      if (!user) return res404(res, _sr['fa'].not_found.user_id)
      // generate user password hash
      const salt = await bcrypt.genSalt(10)
      user.password = await bcrypt.hash(req.body.password, salt)
      user.token = null
      user.save((err, newUserData) => {
        if (err) return res500(res, err)
        return res.json({message: _sr['fa'].response.success_save})
      })
    } catch (e) {
      return res500(res, e)
    }
  }
]

module.exports.update_user = [
  [
    body('first_name')
       .notEmpty().withMessage(_sr['fa'].required.first_name)
       .bail()
       .custom((value, {req}) => {
         if (removeWhiteSpaces(value).length < 3) return Promise.reject(_sr['fa'].min_char.min2)
         else return true
       }),
    body('last_name')
       .notEmpty().withMessage(_sr['fa'].required.last_name)
       .bail()
       .custom((value, {req}) => {
         if (removeWhiteSpaces(value).length < 3) return Promise.reject(_sr['fa'].min_char.min2)
         else return true
       }),

    body('birth_date')
       .optional()
       .isString().withMessage(_sr['fa'].required.birthdate),

    body('marriage_date')
       .optional()
       .isString().withMessage(_sr['fa'].required.field),

    body('job')
       .optional()
       .isString().withMessage(_sr['fa'].required.field),

    body('national_code')
       .optional()
       .isString().withMessage(_sr['fa'].required.national_code)
       .bail()
       .custom((value, {req}) => {
         if (value && removeWhiteSpaces(value).length !== 10) return Promise.reject(_sr['fa'].min_char.min10)
         else return true
       }),
  ],
  checkValidations(validationResult),
  async (req, res) => {
    try {
      const {first_name, last_name, email, birth_date, marriage_date, job, national_code, showBirthDate} = req.body
      const userID = await getID(req)
      User.findById(userID, (err, user) => {
        if (err || !user) return res404(res, err)
        user.first_name = first_name
        user.last_name = last_name
        user.email = email
        user.birth_date = birth_date
        // user.showBirthDate = showBirthDate
        user.marriage_date = marriage_date
        user.job = job
        user.national_code = national_code
        // if (email?.length){
        //   user.score += userEmailVerifyScore
        //   user.scoreLogs = [
        //     {
        //       score : userEmailVerifyScore,
        //       forWhat : 'emailVerify',
        //       action : 'increase'
        //     }
        //   ]
        // }
        user.save(err => {
          if (err) return res500(res, err)
          return res.json({message: _sr['fa'].response.success_save})
        })
      })
    } catch (e) {
      return res500(res, e)
    }
  }
]

module.exports.exportExel = [
  async (req, res) => {
    try {
      const admin = await User.findOne({_id : req?.params?.id , scope : 'admin'})

      if (!admin) return res.status(403).json({message : 'شما اجازه گرفتن خروجی اکسل را ندارید'})

      const users = await User.find({scope: 'user', registration_done: true}).select('first_name last_name business_code birth_date marriage_date national_code bagAmount score mobile_number')

      const data = users.map(user => {
        return [
          user.mobile_number,
          user.first_name,
          user.last_name,
          user.business_code,
          moment(user.birth_date).format('jYYYY/jMM/jDD') === 'Invalid date' ? '' : moment(user.birth_date).format('jYYYY/jMM/jDD'),
          moment(user.marriage_date).format('jYYYY/jMM/jDD') === 'Invalid date' ? '' : moment(user.marriage_date).format('jYYYY/jMM/jDD'),
          user.national_code,
          user.bagAmount.toLocaleString() + ' ریال',
          user.score
        ];
      });

      const workSheetColumn = [
        'شماره موبایل','نام','نام خانوادگی', 'کد مشتری', 'تاریخ تولد', 'سالگرد ازدواج', 'کد ملی', 'کیف پول', 'امتیاز'
      ];

      const workbook = xlsx.utils.book_new()
      const workSheetData = [
        workSheetColumn,
        ...data
      ];


      const workSheet = xlsx.utils.aoa_to_sheet(workSheetData)
      xlsx.utils.book_append_sheet(workbook, workSheet, "لیست کاربران")
      xlsx.writeFile(workbook, path.resolve('./static/export/usersList.xlsx'))

      return res.download(`./static/export/usersList.xlsx`)
    } catch (e) {
      return res500(res, _sr['fa'].response.unknownError)
    }
  }
]

/////////////// user addresses
module.exports.add_address_to_user = [
  [
    body('title')
       .optional().isString().withMessage(`فرمت عنوان از نوع رشته می باشد`),

    body('province')
       .notEmpty().withMessage(_sr['fa'].required.province),

    body('city')
       .notEmpty().withMessage(_sr['fa'].required.city),
       // .bail()
       // .custom((value, {req}) => {
       //   if (req.body.city.localeCompare('اراک') !== 0) return Promise.reject('آدرس خارج از محدوده مد نظر می باشد')
       //   else return true
       // }),

    body('address')
       .notEmpty().withMessage(_sr['fa'].required.address),

    body('location')
       .isObject().withMessage(`لوکیشن از نوع آبجکت می باشد`),
  ],
  checkValidations(validationResult),
  async (req, res) => {
    const errors = validationResult(req)
    if (!errors.isEmpty()) return res.status(422).json({validation: errors.mapped()})

    try {
      const {title, province, city, address, location} = req.body
      const newAddress = {title, province, city, address, location, useRate: 1};

      const targetUser = await User.findById(req?.user?._id);

      if (!targetUser) return res404(res, `کاربر مورد نظر یافت نشد`)

      for (const item of targetUser.addresses) {
        item.used = false;
      }

      targetUser.addresses.push(newAddress)

      await targetUser.save();

      return res.json({message: _sr['fa'].response.success_save});
    } catch (error) {
      return res500(res, _sr['fa'].response.unknownError);
    }
  }
]

module.exports.update_user_address = [
  [
    body('title')
       .optional().isString().withMessage(`فرمت عنوان از نوع رشته می باشد`),

    body('province')
       .notEmpty().withMessage(_sr['fa'].required.province),

    body('city')
       .notEmpty().withMessage(_sr['fa'].required.city),
       // .bail()
       // .custom((value, {req}) => {
       //   if (req.body.city.localeCompare('اراک') !== 0) return Promise.reject('آدرس خارج از محدوده مد نظر می باشد')
       //   else return true
       // }),

    body('address')
       .notEmpty().withMessage(_sr['fa'].required.address),

    body('location')
       .isObject().withMessage(`لوکیشن از نوع آبجکت می باشد`),
  ],
  checkValidations(validationResult),
  (req, res) => {
    User.findOne({'addresses._id': req?.params?.id}, (err, user) => {
      if (err || !user) return res404(req, res)
      const oldAddress = user.addresses.id(req?.params?.id)
      oldAddress.remove()

      const {title, province, city, address, location} = req.body
      const newAddress = {title, province, city, address, location}

      user.addresses.push(newAddress)
      user.save(err => {
        if (err) return res500(res, err)
        else return res.json({message: _sr['fa'].response.success_save})
      })
    })
  }
]

module.exports.update_user_address_by_admin = [
  [
    body('title')
       .optional().isString().withMessage(`فرمت عنوان از نوع رشته می باشد`),

    body('province')
       .notEmpty().withMessage(_sr['fa'].required.province),

    body('city')
       .notEmpty().withMessage(_sr['fa'].required.city),
       // .bail()
       // .custom((value, {req}) => {
       //   if (req.body.city.localeCompare('اراک') !== 0) return Promise.reject('آدرس خارج از محدوده مد نظر می باشد')
       //   else return true
       // }),

    body('address')
       .notEmpty().withMessage(_sr['fa'].required.address)
  ],
  checkValidations(validationResult),
  (req, res) => {
    User.findOne({'addresses._id': req?.params?.id}, (err, user) => {
      if (err || !user) return res404(req, res)
      const targetAddress = user.addresses.id(req?.params?.id)

      const {title, province, city, address} = req.body
      targetAddress.title = title
      targetAddress.province = province
      targetAddress.city = city
      targetAddress.address = address

      user.save(err => {
        if (err) return res500(res, err)
        else return res.json({message: _sr['fa'].response.success_save})
      })
    })
  }
]

module.exports.remove_user_address = [
  (req, res) => {
    User.findOne({'addresses._id': req?.params?.id}, (err, user) => {
      if (err || !user) return res404(res, `کاربر مورد نظر یافت نشد`)
      const oldAddress = user.addresses.id(req?.params?.id)
      oldAddress.remove()
      if (user.addresses.length && user.addresses.find(item => item.used !== true)) {
        user.addresses[0].used = true;
        user.addresses[0].useRate = user.addresses[0].useRate + 1;
      }
      user.save(err => {
        if (err) return res500(res, _sr['fa'].response.unknownError)
        else return res.json({message: _sr['fa'].response.success_remove})
      })
    })
  }
]

module.exports.getAlladdress = [
  async (req, res) => {
    try {
      const storeId = req.params.storeId
      const user = await User.findById(req?.user?._id)
      const addresses = [];
      const getStoreInfo = await StoreInfo.findOne({_id : storeId})
      const storeLocation = getStoreInfo?.location

      if (!user) return res404(res, `کاربر مورد نظر پیدا نشد`);

      for (const address of user.addresses) {
        const newAddress = JSON.parse(JSON.stringify(address));
        if (getStoreInfo) {
          if (getStoreInfo?.shippingType) {
            newAddress.cost = getStoreInfo?.shippingCost || 0
            addresses.push(newAddress);
          } else {
            if (storeLocation) {
              const lng = newAddress.location.coordinates[0]
              const lat = newAddress.location.coordinates[1]

              const storeLng = storeLocation.coordinates[0]
              const storeLat = storeLocation.coordinates[1]

              const getDistance = await axios.get(`https://map.ir/routes/route/v1/driving/${lng},${lat};${storeLng},${storeLat}`, {
                headers: {
                  'x-api-key': apiKey
                }
              });

              if (getDistance.data.code !== 'Ok') return res500(_sr['fa'].response.unknownError);

              const distance =getDistance.data.routes[0].distance<=1000 ? 0 : Math.round(getDistance.data.routes[0].distance / 1000) || 0

              newAddress.cost = distance * (getStoreInfo?.shippingCost || 0) || 0
              addresses.push(newAddress)
            } else {
              newAddress.cost = 0
              addresses.push(newAddress);
            }
          }
        } else {
          newAddress.cost = 0;
          addresses.push(newAddress);
        }
      }

      return res.json(addresses);
    } catch (error) {
      return res500(res, _sr['fa'].response.unknownError)
    }
  }
]

module.exports.setDefaultAddress = [
  async (req, res) => {
    try {
      const checkAddress = await User.findOne({'addresses._id': req?.params?.id})

      if (!checkAddress) return res404(res, `آدرس انتخاب شده وجود ندارد`)

      for (const item of checkAddress.addresses) {
        item.used = false;
      }

      let address = checkAddress.addresses.id(req?.params?.id)

      address.used = true
      address.useRate = address.useRate++

      await checkAddress.save()

      return res.json({message: _sr['fa'].response.success_save});
    } catch (error) {
      return res500(res, _sr['fa'].response.unknownError)
    }
  }
]

////////////// user comments
module.exports.getAllComments = [
  async (req, res) => {
    try {
      const branchId = req?.params?.branchId
      const comments = [];
      const allComments = await Food.find({branchId , 'ratings.user_id': req.user._id})
         .populate({path: 'ratings.user_id', select: 'first_name last_name'});

      for (const comment of allComments) {
        for (const item of comment.ratings) {
          if (item?.user_id?._id.toString() === req?.user?._id.toString() && item.comment) {
            comments.push(item)
          }
        }
      }

      return res.json(comments)
    } catch (error) {
      console.log(error.message)
      return res500(res, _sr['fa'].response.unknownError);
    }
  }
]

/////////////////////////////////////////////////////////////////////// login (Admin)
module.exports.login = [
  [
    body('username')
       .isLength({min: 4}).withMessage(_sr['fa'].min_char.min4)
       .bail()
       .if((value, {req}) => {
         return req.body.password && req.body.password.length >= 4
       })
       .custom((value, {req}) => {
         return User.findOne({$or: [{email: value.toLowerCase()}, {username: value}]})
            .then(user => {
              if (!user) return Promise.reject(_sr['fa'].not_found.password)
              else return true
            })
       }),

    body('password')
       .notEmpty().withMessage(_sr['fa'].required.password)
       .bail()
       .isLength({min: 4}).withMessage(_sr['fa'].min_char.min4),

    body('remember_me')
       .exists().withMessage(_sr['fa'].required.remember_me)
       .bail()
       .isBoolean().withMessage(_sr['fa'].format.boolean)
  ],
  (req, res) => {
    const errors = validationResult(req)
    if (!errors.isEmpty()) return res.status(422).json({validation: errors.mapped()})
    const {deviceId, platform , fromWhere} = req.body
    User.findOne({$or: [{email: req.body.username.toLowerCase()}, {username: req.body.username}]}, (err, user) => {
      if (err || !user) return res404(res, err)
      bcrypt.compare(req.body.password, user.password, async (err, isMatch) => {
        if (err || !isMatch) return res.status(422).json({validation: {username: {msg: _sr['fa'].not_found.password}}})
        if (user.token) {
          jwt.verify(user.token.replace(/^Bearer\s/, ''), secretKey, async (err, decoded) => {
            if (err) {
              let token = await jwt.sign({_id: user._id}, secretKey, {expiresIn: req.body.remember_me ? '7d' : '1h'})
              user.token = token
              user.deviceId = deviceId
              user.fromWhere = fromWhere
              user.save(err => {
                if (err) console.log(err)
                return res.json({token: token})
              })
            } else {
              user.deviceId = deviceId
              user.platform = platform
              user.fromWhere = fromWhere
              user.save(err => {
                if (err) console.log(err)
                return res.json({token: user.token})
              })
            }
          })
        } else {
          let token = await jwt.sign({_id: user._id}, secretKey, {expiresIn: req.body.remember_me ? '7d' : '1h'})
          user.token = token
          user.deviceId = deviceId
          user.fromWhere = fromWhere
          user.save(err => {
            if (err) console.log(err)
            return res.json({token: token})
          })
        }
      })
    })
  }
]

/////////////////////////////////////////////////////////////////////// login (User)
module.exports.login_user = [
  [
    body('mobile_number')
       .notEmpty().withMessage(_sr['fa'].required.phone_number)
       .bail()
       .isMobilePhone().withMessage(_sr['fa'].format.phone_number)
       .bail()
       .if((value, {req}) => {
         return req.body.password && req.body.password.length >= 4
       })
       .custom((value, {req}) => {
         return User.findOne({mobile_number: value})
            .then(user => {
              if (!user) return Promise.reject('کلمه عبور اشتباه است')
              else return true
            })
       }),

    body('password')
       .notEmpty().withMessage(_sr['fa'].required.password)
       .bail()
       .isLength({min: 4}).withMessage(_sr['fa'].min_char.min4),

    body('branchId')
        .notEmpty().withMessage(_sr['fa'].required.field)
        .bail()
        .custom((value, {req}) => {
          return StoreInfo.findOne({_id: value})
              .then(store => {
                if (!store) return Promise.reject(_sr['fa'].not_found.item_id)
                else return true
              })
        })
  ],
  checkValidations(validationResult),
  (req, res) => {
    const {branchId, deviceId, platform , fromWhere} = req.body
    User.findOne({mobile_number: req.body.mobile_number}, (err, user) => {
      if (err || !user) return res404(res, 'کلمه عبور اشتباه است')
      bcrypt.compare(req.body.password, user.password, async (err, isMatch) => {
        if (err || !isMatch) return res.status(422).json({validation: {password: {msg: 'کلمه عبور اشتباه است'}}})
        let token = await jwt.sign({_id: user._id}, secretKey, {expiresIn: '1000d'})
        user.token = token
        user.deviceId = deviceId
        user.platform = platform
        user.fromWhere = fromWhere
        if(!user.branches.includes(branchId)) user.branches.push(branchId)
        user.save(err => {
          if (err) console.log(err.message)
          return res.json({token: token})
        })
      })
    })
  }
]

/////////////////////////////////////////////////////////////////////// logout (Admin)
module.exports.logout = [
  (req, res) => {
    const token = req.headers.authorization
    if (token) {
      User.findOneAndUpdate({token: token}, {token: null}, (err, oldData) => {
        if (err || !oldData) res.status(401).json({message: 'Your not logged in'})
        else return res.json({message: 'You are logged out.'})
      })
    } else {
      return res.status(401).json({message: 'Your not logged in'})
    }
  }
]

/////////////////////////////////////////////////////////////////////// get user (Admin)
// module.exports.getUser = [
//   (req, res) => {
//     const token = req?.headers?.authorization?.replace(/^Bearer\s/, '')
//     if (token) {
//       jwt.verify(token, secretKey, (err, decoded) => {
//         if (err) return res.status(401).json({message: 'unauthenticated'})
//         User.findById(decoded._id).select('-token -password').exec(async (err, user) => {
//           if (err || !user) return res404(res, err)
//           const clone = JSON.parse(JSON.stringify(user))
//           try {
//             clone.discount_codes = await DiscountCode.find({discount_user_id: user._id})
//             return res.json({user: clone})
//           } catch (e) {
//             return res500(res, e)
//           }
//         })
//       })
//     } else {
//       return res.status(401).json({message: 'unauthenticated'})
//     }
//   }
// ]

module.exports.getUser = [
  async (req, res) => {
    try {
      const result = {}
      const token = req?.headers?.authorization?.replace(/^Bearer\s/, '')
      if (token) {
        const decoded = await jwt.verify(token, secretKey)
        if (decoded) {
          const getUser = await User.findById(decoded._id).select('-token -password')
          if (!getUser) return res404(res, `کاربر مورد نظر پیدا نشد`)

          const clone = JSON.parse(JSON.stringify(getUser))
          clone.discount_codes = await DiscountCode.find({discount_user_id: getUser._id})

          result.user = clone
          result.jobs = await Job.find()

          return res.json(result)
        } else {
          res.status(401).json({message: 'unauthenticated'})
        }
      } else {
        return res.status(401).json({message: 'unauthenticated'})
      }
    } catch (error) {
      console.log(error.message)
      return res500(res, _sr['fa'].response.unknownError)
    }
  }
]

module.exports.addFcmToken = [
  async (req, res) => {
    try {
      const fcmToken = req.body.fcmToken
      const admin = await User.findOne({_id: req.user._id, scope: 'admin'})

      if (!admin) return res404(res, 'اطلاعات ادمین پیدا نشد با پشتیبانی تماس بگیرید')

      admin.fcmToken = fcmToken

      await admin.save()

      return res.json({message: _sr['fa'].response.success_save})
    } catch (error) {
      return res500(res, _sr['fa'].response.unknownError)
    }
  }
]

module.exports.addFcmTokenUser = [
  async (req, res) => {
    try {
      const {token, deviceId, platform, deviceName ,fromWhere} = req.body
      const user = await User.findOne({_id: req.user._id, scope: 'user'})

      if (!user) return res404(res, 'اطلاعات کاربر پیدا نشد با پشتیبانی تماس بگیرید')

      user.fcmToken = token
      user.deviceId = deviceId
      user.platform = platform
      user.fromWhere = fromWhere
      user.deviceName = deviceName

      await user.save()

      return res.json({message: _sr['fa'].response.success_save})
    } catch (error) {
      return res500(res, _sr['fa'].response.unknownError)
    }
  }
]