import firebase, { app } from "firebase";
import * as db from './db';
import moment from 'moment';
import f7 from "framework7-vue/utils/f7";
import message from "framework7-vue/components/message";
const ChatModule = {

  state: {
    subscribe_affiliate_friend: false,
    reference:null,
    contacts: [],
    friends: [],
    friend_requests: [],
    message_count: [],
    chat_messages: [],
    typing_message: 0,
    friend_status: 0,
    block_by_friend: 0,
    members: [],
    user_details:[],
    

  },
  getters: {
    subscribe_affiliate_friend: state => state.subscribe_affiliate_friend,
    reference: state => state.reference,
    contacts: state => state.contacts,
    friends: state => state.friends,
    members: state => state.members,
    friend_requests: state => state.friend_requests,
    message_count: state => state.message_count,
    chat_messages: state => state.chat_messages,
    typing_message: state => state.typing_message,
    friend_status: state => state.friend_status,
    block_by_friend: state => state.block_by_friend,
    user_details: state => state.user_details,
    

  },
  mutations: {
    setSubscribeAffiliateFriend(state, payload) {
      state.subscribe_affiliate_friend = payload;
    },
    setReference(state, payload) {
      state.reference = payload;
    },
    setContacts(state, payload) {
      state.contacts = payload;
    },
    setFriends(state, payload) {
      state.friends = payload;
    },
    setMembers(state, payload) {
      state.members = payload;
    },
    setFriendRequests(state, payload) {
      state.friend_requests = payload;
    },
    setMessageCount(state, payload) {
      state.message_count = payload;
    },
    setChatMessages(state, payload) {
      state.chat_messages = payload
    },
    setTypingMessage(state, payload) {
      //console.group(" setTypingMessage_module")
      state.typing_message = payload
    },
    setFriendStatus(state, payload) {
      //console.group(" setTypingMessage_module")
      state.friend_status = payload
    },
    setBlockByFriend(state, payload) {
      state.block_by_friend = payload
    },
    setUserDetails(state, payload) {
      state.user_details = payload
    },
  },
  actions: {
    async sendLatestMessage({ dispatch }, payload) {
       
      var user_id = firebase.auth().currentUser.uid
      var user_key = payload.userkey;
      var frd_id = payload.friend.uid;
      var frd_key = payload.friend.frd_key;
      var latest_message = '';
      let messcount = await dispatch("getUserMessageCount", payload)
      if (messcount != null) {
        if (isNaN(messcount)) {
          messcount = 0
        } else {
          messcount++
        }
      } else {
        messcount = 0
      }
      if (payload.img != null) {
        latest_message = 'photo'
      } else {
        latest_message = payload.msg
      }

      try {
        if(latest_message != null && frd_id != null){
        await db.firefriends.child(user_id)
          .child(frd_key)////
          .update({
            latest_message: latest_message,
            uid: frd_id
          })
        }

        if(latest_message != null && frd_id != null){
        await db.firefriends.child(frd_id)
          .child(user_key)
          .update({
            message_count: messcount,
            latest_message: latest_message,
            uid: user_id
          })
        }

      } catch (error) {
        console.log(error)
      }

    },


    


    getFriendAffiliate({ commit },payload) {
      //console.log("affiliate",JSON.stringify(payload))
      var frd_uid = payload;
      //var promise = new Promise((resolve, reject) => {
      firebase.database().ref('pay4me').child(frd_uid).once('value', snapshot => {
        //var members = snapshot.val()

        if (snapshot.val() != null && snapshot.val() != undefined) {
          //console.log("user subscribe")
          commit("setSubscribeAffiliateFriend", true);
        } else {
          //console.log("user not subscribed")
          commit("setSubscribeAffiliateFriend", false);
        }
        //console.log("am here" + JSON.stringify(snapshot.val().country))
        //commit("setUserCountry",snapshot.val().country)
        //resolve(snapshot.val().country)

      })
      //})
      //return promise
    },


    async resetMessageCount({ dispatch }, payload) {
     
      var user_id = firebase.auth().currentUser.uid
      var user_key = payload.userkey;
      var frd_id = payload.uid;
      var frd_key = payload.frd_key;
      var latest_message = '';
      var messcount = 0;
      //console.log("blue",frd_key,user_id)
      try {
        await db.firefriends.child(user_id)
          .child(frd_key)////
          .update({
            message_count: 0
          })
      } catch (error) {

      }
    },




    getUserMessageCount({ }, payload) {
     
      var promise = new Promise((resolve, reject) => {
        var frd_id = payload.friend.uid;
        var userkey = payload.userkey;
        db.firefriends.child(frd_id).child(userkey)
          .once('value', snapshot => {
            if (snapshot.val()) {
              resolve(snapshot.val().message_count)
            }else{
              resolve("0")
            }
          })
          .catch(err => {
            reject(err)
          })
      })
      return promise
    },



    confirmFriendRequest({ dispatch }, payload) {
      try{
        db.firefriends.child(firebase.auth().currentUser.uid)
          .push({
            uid: payload.friend.uid,
            message_count: "0",
            latest_message: " ",
          })

          db.firefriends.child(payload.friend.uid)
          .push({
            message_count: "0",
            latest_message: " ",
            uid: firebase.auth().currentUser.uid

          })
        }catch(error) {
            reject(err)
          }
      //})
      let result ="010220"
      return result
    },

   

    createFriendTables({ dispatch }, payload) {
      
      try{
        var userKey  =   db.firefriends.child(firebase.auth().currentUser.uid).push().key
        db.firefriends.child(firebase.auth().currentUser.uid).child(userKey)
          .update({
            uid: payload.friend.uid,
            message_count: "0",
            latest_message: " ",
          })

          db.firefriends.child(payload.friend.uid).child( userKey  )
          .update({
            message_count: "0",
            latest_message: " ",
            uid: firebase.auth().currentUser.uid

          })
          
        }catch(error) {
            console.log(error)
          }
      //})
      
      return  userKey
    },

    async sendDownTypingMessage({ }, payload) {
      var user_id = firebase.auth().currentUser.uid
      var frd_uid = payload.uid;
      var frd_key = payload.frd_key;
      
      try {
        await db.firetyping.child(user_id)
          .child(frd_uid)////
          .update({
            friend_name: firebase.auth().currentUser.displayName,
            friend_photo_url: firebase.auth().currentUser.photoURL,
            typingMessage: "1",
            timestamp: firebase.database.ServerValue.TIMESTAMP
          })

      } catch (error) {
        console.log(error.message)
      }

    },

    async sendUpTypingMessage({ }, payload) {
     
      var frd_uid = payload.uid
      var user_uid = firebase.auth().currentUser.uid;
     
      try {
        await db.firetyping.child(user_uid)
          .child(frd_uid)////
          .update({
            friend_name: firebase.auth().currentUser.displayName,
            friend_photo_url: firebase.auth().currentUser.photoURL,
            typingMessage: "0",
            timestamp: firebase.database.ServerValue.TIMESTAMP
          })

      } catch (error) {
        console.log(error.message)
      }

    },

    getTypingMessages({ commit }, payload) {

      var current_user = firebase.auth().currentUser.uid
      db.firetyping.child(payload.uid).child(current_user).on('value', snapshot => {
        if (snapshot.val()) {
          if (snapshot.val().typingMessage == "1") {
            commit('setTypingMessage', "1")
          }
          else {
            commit('setTypingMessage', '0')
          }
        } else {

          commit('setTypingMessage', '0')
        }
      })

    },

    getUserKey({ }, payload) {
      var promise = new Promise((resolve, reject) => {
        var frd_id = payload.friend.uid;
        db.firefriends.child(frd_id).orderByChild("uid")
          .equalTo(firebase.auth().currentUser.uid)
          .once('value', snapshot => {
            let userkey;
            for (var key in snapshot.val()) userkey = key;
            resolve(userkey)

          })
          .catch(err => {
            reject(err)

          })
      })
      return promise

    },




    getUserMessageCount2({ }, payload) {

      var promise = new Promise((resolve, reject) => {

        var frd_id = payload.friend.uid;
        var userKey = payload.friend.userKey;
        db.firemessagecount.child(frd_id).child(userKey).orderByChild("uid")
          .equalTo(firebase.auth().currentUser.uid)
          .on('value', snapshot => {
            resolve(snapshot.message_count)
          })
          .catch(err => {
            reject(err)

          })
      })
      return promise

    },

    getChatMessages({ commit }, payload) {
      var current_user = firebase.auth().currentUser
      db.firechats.child(current_user.uid).child(payload.uid).on('value', snapshot => {
        var messages = snapshot.val()
        _.forEach(messages, message => {
          message.type = message.sentby == current_user.uid ? 'sent' : 'received';
          message.name = message.sentby == current_user.uid ? current_user.displayName : payload.name;
          message.date = moment(message.timestamp).format("MMMM Do dddd");
          message.smalldate = moment(message.timestamp).format("LTS");
        })
        var groupedmessages = _.groupBy(messages, 'date')
        commit('setChatMessages', groupedmessages)
      })
    },

    getTotalMessage({ commit }) {
      var current_user_uid = firebase.auth().currentUser.uid
      db.firefriends.child(current_user_uid).on('value', snapshot => {
        var totalMessage = 0
        var messages = snapshot.val()
        _.forEach(messages, message => {
          if (message.message_count > 0) {
            totalMessage = totalMessage + Number(message.message_count)
          }

        })
        commit("setTotalMessage", totalMessage)
      })

    },




    confirmRequest({ dispatch }, payload) {
      var promise = new Promise((resolve, reject) => {
        db.firefriends.child(firebase.auth().currentUser.uid)
          .push({ uid: payload.uid })
          .then(() => {
            db.firefriends.child(payload.uid)
              .push({ uid: firebase.auth().currentUser.uid })
          })
          .then(() => {
            dispatch('deleteRequest', payload).then(() => {
              resolve(true)
            })
          })
          .catch(err => {
            reject(err)
          })
      })
      return promise
    },
    deleteRequest({ }, payload) {
      var promise = new Promise((resolve, reject) => {
        db.firerequest.child(firebase.auth().currentUser.uid)
          .orderByChild('sender')
          .equalTo(payload.uid)
          .once('value', snapshot => {
            let userkey;
            for (var key in snapshot.val()) userkey = key
            db.firerequest.child(firebase.auth().currentUser.uid)
              .child(userkey)
              .remove()
              .then(() => {
                resolve(true)
              })
              .catch(err => {
                reject(err)
              })

          }).catch(err => {
            reject(err)
          })
      })
      return promise
    },
    async getMyRequests({ commit, dispatch }) {
      var users = await dispatch('getAllUsers')
      db.firerequest.child(firebase.auth().currentUser.uid)
        .on('value', snapshot => {

          var frd_request_id = _.map(snapshot.val(), "sender")
          var userdetails = []
          _.forEach(frd_request_id, uid => {
            var user = _.find(users, ["uid", uid])
            userdetails.push(user)
          })
          commit('setFriendRequests', userdetails)
        })
    },

  getUserDetails({ commit }) {
      
      firebase.database().ref('users').child(firebase.auth().currentUser.uid)
        .on('value', snapshot => {
          commit('setUserDetails', snapshot.val())
        })
    },
    async getMyFriends({ commit, dispatch }) {
      var users = await dispatch('getAllUsers')
      db.firefriends.child(firebase.auth().currentUser.uid)
        .on('value', snapshot => {
          var friends = snapshot.val()
          var userdetails = []
          _.forEach(friends, (frd, key) => {
            var user = _.find(users, ["uid", frd.uid])

            try {
              if ((user != null) && (user != undefined)) {

                if (frd.latest_message != null) {
                  user.latest_message = frd.latest_message
                  user.message_count = frd.message_count
                }

              } else {
                if ((user != null) && (user != undefined)) {
                  user.latest_message = ''
                  user.message_count = ''
                }
              }
              if ((user != null) && (user != undefined)) {
                user.frd_key = key;
                userdetails.push(user)
              }
            } catch (error) {
            }

          })
          commit('setFriends', userdetails)
        })
    },



    async sendMessage({ dispatch }, payload) {
      var userkey = await dispatch('getUserKey', payload)
      payload.friend.userKey = userkey
      var frd_info = payload;
      frd_info.userkey = userkey
      var friendExist = await dispatch('getMyFriendsList', payload)
      if (friendExist) {
        dispatch('sendLatestMessage', frd_info)
      } else {
        let newUserKey = await dispatch('createFriendTables', frd_info)
       payload.friend.userKey = newUserKey
        frd_info.userkey = newUserKey
        frd_info.frd_key = newUserKey
        payload.friend.frd_key = newUserKey
        await dispatch('sendLatestMessage', frd_info)
      }
      try {
        await db.firechats.child(firebase.auth().currentUser.uid)
          .child(payload.friend.uid)
          .push({
            sentby: firebase.auth().currentUser.uid,
            text: payload.msg,
            image: payload.img,
            timestamp: firebase.database.ServerValue.TIMESTAMP
          })
        await db.firechats.child(payload.friend.uid)
          .child(firebase.auth().currentUser.uid)
          .push({
            sentby: firebase.auth().currentUser.uid,
            avatar: firebase.auth().currentUser.photoURL,
            text: payload.msg,
            image: payload.img,
            timestamp: firebase.database.ServerValue.TIMESTAMP
          })

      } catch (error) {
        console.log(error.message)
      }

    },

    getMyFriendsList({ }, payload) {
      var promise = new Promise((resolve, reject) => {
        var frd_id = payload.friend.uid;
        db.firefriends.child(frd_id).orderByChild("uid")
          .equalTo(firebase.auth().currentUser.uid)
          .once('value', snapshot => {
            let userkey =null;
            for (var key in snapshot.val()) userkey = key;
            resolve(userkey)

          })
          .catch(err => {
            reject(err)

          })
      })
      return promise

    },


    async getAllUsers({ commit, dispatch }) {
      //var user_id = firebase.auth().currentUser.uid
      var payload = []
      payload.name = await dispatch("getUserCountry")
      var promise = new Promise((resolve, reject) => {
        firebase.database().ref('users').orderByValue().on('value', function (snapshot) {
          var members = snapshot.val()
          var myContacts = []
          _.forEach(members, member => {
            if (member.country == payload.name) {
              if (firebase.auth().currentUser.uid !== member.uid) {
                myContacts.push(member)
              }
            }
          })
          commit('setContacts', myContacts)
          //resolve(snapshot.val()) 
          resolve(myContacts)
        })
      })
      return promise

    },

    getMessageCount({ commit }) {
      var promise = new Promise((resolve, reject) => {
        firebase.database().ref('users').child(firebase.auth().currentUser.uid).once('value', snapshot => {
          //var members = snapshot.val()
          //console.log("am here" + JSON.stringify(snapshot.val().country))
          resolve(snapshot.val().country)

        })
      })
      return promise
    },

    checkUserInFriendList({ commit }, payload) {
      var user_uid = firebase.auth().currentUser.uid
      if (payload.frd_key == null) {
        commit("setAlertMessage", "User not in your friend list")
        return
      }
      var frd_key = payload.frd_key
      var promise = new Promise((resolve, reject) => {
        db.firefriends.child(user_uid).child(frd_key)
          .once('value', snapshot => {
            if (snapshot.val()) {
              resolve(snapshot.val().message_count)
            }
          })
          .catch(err => {
            reject(err)
          })
      })
      return promise
    },

    async blockUser({ commit, dispatch }, payload) {
      var friendlist = await dispatch("checkUserInFriendList", payload)
      if (friendlist == null) {
        commit("setAlertMessage", "User not in your friend list")
      } else {
        var user_uid = firebase.auth().currentUser.uid
        var frd_uid = payload.uid
        await db.fireblockfriends.child(user_uid).child(frd_uid)
          .update({
            flag: "1"
          })
        commit("setAlertMessage", "User has been blocked")
      }

    },


    async unBlockUser({ commit, dispatch }, payload) {
      
      var friendlist = await dispatch("checkUserInFriendList", payload)

      if (friendlist == null) {
        commit("setAlertMessage", "User not in your friend list")
      } else {
        var user_uid = firebase.auth().currentUser.uid
        var frd_uid = payload.uid
        var frd_key = payload.frd_key
        //console.log("james",frd_uid)
        await db.fireblockfriends.child(user_uid).child(frd_uid)
          .update({
            flag: "0"
          })
        commit("setAlertMessage", "User has been unblocked")
      }

    },


    async checkUserBlocked({ commit }, payload) {
      
      if (payload.frd_key == null) {
        var flag = "0"
        commit("setFriendStatus", flag)
        return flag
      }
      var user_uid = firebase.auth().currentUser.uid
      var frd_uid = payload.uid
      
      var promise = new Promise((resolve, reject) => {
        db.fireblockfriends.child(user_uid).child(frd_uid)
          .once('value', snapshot => {
            if (snapshot.val()) {
              commit("setFriendStatus", snapshot.val().flag)
            }
            
            resolve(snapshot.val())
          })
          .catch(err => {
            reject(err)
          })
      })
      return promise
    },

    async checkBlockByFriend({ commit }, payload) {
      
      if (payload.frd_key == null) {
        var flag = "0"
        commit("setBlockByFriend", flag)
        return flag
      }
      var user_uid = firebase.auth().currentUser.uid
      var frd_uid = payload.uid
        var promise = new Promise((resolve, reject) => {
        db.fireblockfriends.child(frd_uid).child(user_uid)
          .once('value', snapshot => {
            if (snapshot.val()) {
              commit("setBlockByFriend", snapshot.val().flag)
            }
            resolve(snapshot.val())
          })
          .catch(err => {
            reject(err)
          })
      })
      return promise

    },
    async reportUserToAdmin({ commit, dispatch }, payload) {
      
      var friendlist = await dispatch("checkUserInFriendList", payload)

      if (friendlist == null) {
        commit("setAlertMessage", "User not in your friend list")
      } else {
        var user_uid = firebase.auth().currentUser.uid
        var frd_uid = payload.uid
        var report_id = payload.report_id
        await db.firereportfriends.child(user_uid).child(frd_uid)
          .update({
            report_flag: report_id
          })
        commit("setAlertMessage", "Your report has been submitted and will be reviewed by Admin")
      }

    },
    async editLocation({ commit }, payload) {
      //console.log("location", JSON.stringify(payload))
      if (payload.location.length < 2) {
        commit("setAlertMessage", "Your Location is too short");
        return;
      }
      
      if (payload.location.length > 50) {
        commit("setAlertMessage", "Your Location is too long");
        return;
      }
      //console.log("location",payload.location)
      var user_uid = firebase.auth().currentUser.uid
      await firebase.database().ref('users/' + user_uid).update({
        location: payload.location
      })
      commit("setUserLocation", payload.location);
      commit("setAlertMessage", "Your location has been updated.")
    },

    async editProfileMessage({ commit }, payload) {

      if (payload.profileMessage.length < 10) {
        commit("setAlertMessage", "profile message is too short");
        return;
      }
      
      if (payload.profileMessage.length > 200) {
        self.$store.commit("setAlertMessage", "profile message is too long");
        return;
      }
      
      var user_uid = firebase.auth().currentUser.uid
      await firebase.database().ref('users/' + user_uid).update({
        profileMessage: payload.profileMessage
      })
      commit("setProfileMessage", payload.profileMessage);
      commit("setAlertMessage", "Your new Profile Message has been updated.")
    },

     getReference({commit},payload){
      let text = "";
      if(payload =="100000")
      {
        text ="1"
      }
      if(payload =="300000")
      {
        text ="3"
      }
      if(payload =="500000")
      {
        text ="5"
      }

     
      let possible =
        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";

      for (let i = 0; i < 10; i++)
        text += possible.charAt(Math.floor(Math.random() * possible.length));

      commit("setReference",text)

     },
    async deleteAccount({ commit, dispatch }) {
      
      var user_uid = firebase.auth().currentUser.uid


      // User deleted.
      var ref = firebase.database().ref(
        "users/".concat(user_uid, "/")
      );
      ref.remove();

      //remove user from auth table
      firebase.auth().currentUser.delete()

      //logout user

      firebase
        .auth()
        .signOut()
        .then(() => {
          commit("setSignedIn", false);
          //logout out

        });
      commit("setAlertMessage", "Your Account has been deleted")
    },
    sendRequest({ commit }, payload) {
      var promise = new Promise((resolve, reject) => {
        db.firerequest.child(payload.recipient).push({ sender: payload.sender })
          .then(() => {

            resolve({ success: true })

          })
          .catch(err => {
            reject(err)
          })
      })
      return promise
    }
  }
};
export default ChatModule;