import firebase from "firebase";
import * as db from "./db";
import moment from "moment";
import message from "framework7-vue/components/message";
const ChatGroupModule = {
  state: {

    advert_country: null,
    subscribe_affiliate: false,
    user_country: null,
    chat_groups: null,
    group_members: null,
    friend_members: null,
    group_messages: null,
    chat_group_name: null,
    user_status: null,
    app_state: true,
    ban_status: false,
    typing_message_group: 0,
    number_online: 0,
    total_group_messages: 0,
    user_notifications: [],
    post_chat_messages: []
  },
  getters: {

    subscribe_affiliate: state => state.subscribe_affiliate,
    post_chat_messages: state => state.post_chat_messages,
    friend_members: state => state.friend_members,
    total_group_messages: state => state.total_group_messages,
    chat_groups: state => state.chat_groups,
    number_online: state => state.number_online,
    group_members: state => state.group_members,
    group_messages: state => state.group_messages,
    chat_group_name: state => state.chat_group_name,
    user_status: state => state.user_status,
    app_state: state => state.app_state,
    ban_status: state => state.ban_status,
    typing_message_group: state => state.typing_message_group,
    user_notifications: state => state.user_notifications,
    user_country: state => state.user_country,
  },
  mutations: {

    setAdvertCountry(state, payload) {
      state.advert_country = payload;
    },

    setSubscribeAffiliate(state, payload) {
      state.subscribe_affiliate = payload;
    },

    setPostChatMessages(state, payload) {
      state.post_chat_messages = payload;
    },

    setFriendMembers(state, payload) {
      state.friend_members = payload;
    },
    setNumberOnline(state, payload) {
      state.number_online = payload;
    },
    setTotalGroupMessages(state, payload) {
      state.total_group_messages = payload;
    },
    setChatGroups(state, payload) {
      state.chat_groups = payload;
    },
    setGroupMembers(state, payload) {
      state.group_members = payload;
    },
    setGroupMessages(state, payload) {
      state.group_messages = payload;
    },
    setChatGroupName(state, payload) {
      state.chat_group_name = payload;
    },
    setUserStatus(state, payload) {
      state.user_status = payload;
    },
    setAppState(state, payload) {
      state.app_state = payload;
    },
    setBanStatus(state, payload) {
      state.ban_status = payload
    },
    setTypingMessageGroup(state, payload) {
      // console.log("setTypingMessageGroup")
      state.typing_message_group = payload
    },
    setUserNotifications(state, payload) {
      state.user_notifications = payload
    },
    setUserCountry(state, payload) {
      state.user_country = payload
    },
  },
  actions: {
    async sendLatestGroupMessage({ dispatch }, payload) {
      // var latest_message = payload.img == null? payload.message: 'image file'
      //try {
      //find the owners
      //   var owner = ''
      //await db.firegroups.child(firebase.auth().currentUser.uid)
      // .child(payload.group_name)
      // .once('value',snapshot =>{
      //         owner = snapshot.val().owner;

      //     })
      //send the msg to himself
      //  await db.firegroups.child(firebase.auth().currentUser.uid)
      //  .child(payload.group_name)
      //  .update({
      //    latest_message : latest_message
      //  })
      //if he is not owener, send to the owner
      //if (firebase.auth().currentUser.uid != owner) {
      //    db.firegroups.child(owner).child(payload.group_name).update({
      //      latest_message : latest_message
      //    })
      // }
      //send other members
      // var members = await dispatch('getGroupMembers',payload.group_name)
      // _.forEach(members, member=>{
      //  if(firebase.auth().currentUser.uid != member.uid){
      //     db.firegroups.child(member.uid)
      //    .child(payload.group_name)
      //      .update({
      //        latest_message : latest_message
      //     })
      //    }
      //   })
      //} catch (error) {
      // console.log(error)

      // }
    },
    placeAdvert({ commit }, payload) {

      // Get a key for a new Post.
      var newPostKey = firebase.database().ref().child('/adverts/').push().key;

      // Write the new post's data simultaneously in the posts list and the user's post list.
      var updates = {};
      updates['/adverts/' + newPostKey] = payload;
      firebase.database().ref().update(updates);

      commit('setAlertMessage', "Advert Placed successfully")
    },
    async getGroupMessages({ commit, dispatch }) {
      // console.log("moses")
      var payload = []
      payload.country = await dispatch("getUserCountry")

      var current_user = firebase.auth().currentUser;
      //  db.firegroups.child("C0KUjyHioShrmY646lnmqgs3sFO2").child(payload.name).child('msgboard').on('value', snapshot => {
      db.firegroups.child(payload.country).child('msgboard').on('value', snapshot => {
        var messages = snapshot.val()

        var group_messages = [];
        _.forEach(messages, message => {
          message.type = message.sentby == current_user.uid ? "sent" : "received";
          // message.name = message.sentby = current_user.uid? current_user.displayName: 'friend name';
          message.date = moment(message.timestamp).format("MMMM Do dddd");
          message.smalldate = moment(message.timestamp).format("LTS");
          group_messages.push(message)
        })
        //console.log('group messages',group_messages)
        //group_messages.chatgroup = payload.name
        //commit('setChatGroup',payload)
        // var groupedmessages = _.groupBy(messages, 'date')
        var groupedmessages = _.groupBy(group_messages, 'date')
        // commit('setGroupMessages',group_messages)
        commit('setGroupMessages', groupedmessages)
        //commit('setChatGroup',payload.name)
      }, err => {
        console.log(err)
      })
    },
    async sendGroupMessage({ dispatch }, payload) {
      //console.log('send group message')
      try {


        //var userClub = await dispatch("getUserClub")
        db.firegroups.child(payload.group_name).child('msgboard').push({
          club: userClub,
          sentby: firebase.auth().currentUser.uid,
          displayName: firebase.auth().currentUser.displayName,
          avatar: firebase.auth().currentUser.photoURL,
          image: payload.img,
          text: payload.message,
          timestamp: firebase.database.ServerValue.TIMESTAMP
        })

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



      try {
        var onlinegroup = await dispatch("getTotalGroupMessages")
        // console.log("what is totalgroup value", onlinegroup)
        if (onlinegroup == -5) {
          onlinegroup = 1
        }
        //console.log("total messages", onlinegroup)
        if (onlinegroup != null && onlinegroup > 0) {
          onlinegroup++
          var country = await dispatch("getUserCountry")
          await firebase.database().ref('/appStatistics')
            .child(country)
            .update({
              totalMessages: onlinegroup
            });

        }

        //dispatch("getGroupMembers", payload.group_name);
        //commit('setNumberOnline', onlinegroup)
      } catch (error) {
        console.log(error);
      }

    },
    async leaveGroup({ }, payload) {
      try {
        //find the owner
        var owner = '';
        await db.firegroups.child(firebase.auth().currentUser.uid)
          .child(payload.group_name)
          .once('value', snapshot => {
            owner = snapshot.val().owner;

          })

        //find the member
        var member_ref = await db.firegroups
          .child(owner)
          .child(payload.group_name)
          .child("members");
        member_ref
          .orderByChild("uid")
          .equalTo(firebase.auth().currentUser.uid)
          .once("value", snapshot => {
            let memberkey;
            //console.log(snapshot.val())
            for (var key in snapshot.val()) memberkey = key;
            //remove the member
            //console.log('memberkey',memberkey)
            member_ref.child(memberkey).remove();
          });

        //remove the group that belong to the member before
        await db.firegroups
          .child(firebase.auth().currentUser.uid)
          .child(payload.group_name)
          .remove();
        await dispatch("getGroupMembers", payload.group_name);

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

    },

    async removeMember({ dispatch }, payload) {
      // console.log('remove member',payload)
      try {
        //find the member
        var member_ref = await db.firegroups
          .child(firebase.auth().currentUser.uid)
          .child(payload.group_name)
          .child("members");
        member_ref
          .orderByChild("uid")
          .equalTo(payload.member.uid)
          .once("value", snapshot => {
            let memberkey;
            //console.log(snapshot.val())
            for (var key in snapshot.val()) memberkey = key;
            //remove the member
            //console.log('memberkey',memberkey)
            member_ref.child(memberkey).remove();
          });

        //remove the group that belong to the member before
        await db.firegroups
          .child(payload.member.uid)
          .child(payload.group_name)
          .remove();
        await dispatch("getGroupMembers", payload.group_name);
      } catch (error) {
        console.log(error);
      }
    },
    async getGroupMembers({ commit }, group_name) {
      var owner = '';
      await db.firegroups.child(firebase.auth().currentUser.uid)
        .child(group_name)
        .once('value', snapshot => {
          owner = snapshot.val().owner;
        })
      var promise = new Promise((resolve, reject) => {
        db.firegroups
          .child(owner)
          .child(group_name)
          .once("value", snapshot => {
            var members = snapshot.val().members;
            var groupmembers = [];
            for (var key in members) {
              groupmembers.push(members[key]);
            }
            resolve(members)
            commit("setGroupMembers", groupmembers);
          }, err => {
            reject(err)
          });
      })
      return promise

    },
    async addMember({ dispatch }, payload) {
      try {
        //console.log("Nosa Nosa " + JSON.stringify(payload))
        await db.firegroups
          .child(firebase.auth().currentUser.uid)
          .child(payload.group_name)
          .child("members")
          .push(payload.newmember);

        var url = await dispatch("getGroupImage", payload.group_name);
        await db.firegroups
          .child(payload.newmember.uid)
          .child(payload.group_name)
          .set({
            group_pic: url,
            msgboard: "",
            owner: firebase.auth().currentUser.uid
          });
        dispatch("getGroupMembers", payload.group_name);
      } catch (error) {
        console.log(error);
      }
    },



    async banUser({ }, payload) {
      var uid = payload.uid
      var comments = payload.comments
      try {
        await firebase.database().ref('/users/')
          .child(uid)
          .update({
            userType: "0",
            BanReasons: comments
          });
      } catch (error) {
        console.log(error);
      }
    },

    async unBanUser({ }, payload) {
      try {
        //console.log(JSON.stringify(myPayload))
        await firebase.database().ref('/users/')
          .child(payload)
          .update({
            userType: "1"
          });
      } catch (error) {
        console.log(error);
      }
    },


    async closeAppState({ commit, dispatch }) {
      try {
        var country = await dispatch("getUserCountry")
        await firebase.database().ref('/appState')
          .child(country)
          .update({
            appStateValue: "1"
          });
        //dispatch("getGroupMembers", payload.group_name);
        commit("setAppState", false)
      } catch (error) {
        console.log(error);
      }
    },


    async openAppState({ commit, dispatch }) {
      try {
        var country = await dispatch("getUserCountry")
        await firebase.database().ref('/appState')
          .child(country)
          .update({
            appStateValue: "0"
          });
        commit("setAppState", true)
        //dispatch("getGroupMembers", payload.group_name);
      } catch (error) {
        console.log(error);
      }
    },


    //async addGroupMember({ dispatch }, payload) {
    // try {
    // var group_name = await dispatch("getUserCountry")

    // let user_id = "C0KUjyHioShrmY646lnmqgs3sFO2"
    // await db.firegroups
    //   .child(user_id)
    //   .child(group_name)
    //   .child("members")
    //   .update({
    //     uid: firebase.auth().currentUser.uid
    //   });
    //} catch (error) {
    //console.log(error);
    //  }
    // },

    getGroupImage({ }, group_name) {
      var promise = new Promise((resolve, reject) => {
        db.firegroups
          .child(firebase.auth().currentUser.uid)
          .child(group_name)
          .once("value", snapshot => {
            var group_pic = snapshot.val().group_pic;
            resolve(group_pic);
          })
          .catch(err => {
            reject(err);
          });
      });
      return promise;
    },



    getStaticGroupImage({ }, group_name) {
      let user_id = "C0KUjyHioShrmY646lnmqgs3sFO2"
      var promise = new Promise((resolve, reject) => {
        db.firegroups
          .child(user_id)
          .child(group_name)
          .once("value", snapshot => {
            var group_pic = snapshot.val().group_pic;
            resolve(group_pic);
          })
          .catch(err => {
            reject(err);
          });
      });
      return promise;
    },

    createGroup({ }, group) {
      var promise = new Promise((resolve, reject) => {
        db.firegroups
          .child(firebase.auth().currentUser.uid)
          .child(group.name)
          .set({
            group_pic: group.pic,
            msgboard: "",
            owner: firebase.auth().currentUser.uid
          })
          .then(data => {
            resolve(true);
          })
          .catch(err => {
            reject(err);
          });
      });
      return promise;
    },


    getUserDetails({ 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()))
          resolve(snapshot.val())

        })
      })
      return promise
    },


    getUserCountry({ 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))
          commit("setUserCountry", snapshot.val().country)
          resolve(snapshot.val().country)

        })
      })
      return promise
    },


    getUserEmail({ 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))
          //commit("setUserCountry", snapshot.val().em)
          resolve(snapshot.val().email)

        })
      })
      return promise
    },

    getUserClub({ commit }) {
      var promise = new Promise((resolve, reject) => {
        firebase.database().ref('users').child(firebase.auth().currentUser.uid).once('value', snapshot => {
          resolve(snapshot.val().club)

        })
      })
      return promise
    },


    getGroupName2({ 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))
          var chatgroup = [];
          resolve(snapshot.val().country)
          chatgroup.push(snapshot.val())
          commit("setChatGroupName", snapshot.val().country)
        })

      })
      return promise
    },



    getBanUserStatus({ commit }, user_uid) {
      var promise = new Promise((resolve, reject) => {
        firebase.database().ref('users').child(user_uid).once('value', snapshot => {
          resolve(snapshot.val().userType)
          if (snapshot.val().userType == "0") {
            commit("setBanStatus", true)
            //console.log("nosaban1")
          } else {
            commit("setBanStatus", false)
            //console.log("nosaban2")
          }
          //commit("setUserStatus", snapshot.val().userType)
        })

      })
      return promise
    },

    getUserStatus({ commit }) {
      var promise = new Promise((resolve, reject) => {
        firebase.database().ref('users').child(firebase.auth().currentUser.uid).once('value', snapshot => {
          resolve(snapshot.val().userType)
          //if( snapshot.val().userType=="0"){
          // commit("setBanStatus", true)
          //console.log("userType", snapshot.val().userType)
          // }else{
          // commit("setBanStatus", false)
          // console.log("nosa2")
          //  }
          commit("setUserStatus", snapshot.val().userType)
        })

      })
      return promise
    },

    async getAppState({ commit, dispatch }) {
      var country = await dispatch("getUserCountry")
      var promise = new Promise((resolve, reject) => {
        //console.log("enter get app state")
        firebase.database().ref('appState').child(country).once('value', snapshot => {
          resolve(snapshot.val().appStateValue)
          //console.log("app state", JSON.stringify(snapshot.val().appStateValue))
          if (snapshot.val().appStateValue == "1") {
            commit("setAppState", false)
            //console.log("app status = false")
          } else {
            commit("setAppState", true)
            //console.log("app status = true")
          }

        })

      })
      return promise
    },


    async getOnlineStatistics({ commit, dispatch }) {
      //console.log("getOnlineStatistics")
      var country = await dispatch("getUserCountry")
      //console.log(country)

      var promise = new Promise((resolve, reject) => {
        firebase.database().ref('/appStatistics')
          .child(country).on('value', snapshot => {
            //var members = snapshot.val()
            //console.log("am here" + JSON.stringify(snapshot.val().country))
            // commit('setGroupMessages', groupedmessages)

            //  console.log("online", snapshot.val().online)
            commit('setNumberOnline', snapshot.val().online)
            resolve(snapshot.val().online)

          })

      })

      return promise
    },


    async getTotalGroupMessages({ commit, dispatch }) {
      var country = await dispatch("getUserCountry")
      var promise = new Promise((resolve, reject) => {
        firebase.database().ref('/appStatistics')
          .child(country).on('value', snapshot => {
            //var members = snapshot.val()
            // console.log("Total Group Messages", JSON.stringify(snapshot.val().totalMessages))

            if (snapshot.val().totalMessages == -5) {
              commit('setTotalGroupMessages', 0)
              resolve(snapshot.val().totalMessages)
            } else {
              commit('setTotalGroupMessages', snapshot.val().totalMessages)
              resolve(snapshot.val().totalMessages)
            }


          })

      })
      return promise
    },

    async statisticsUsersOnline({ commit, dispatch }) {
      // console.log("yes")
      try {

        //  console.log("no")
        var onlinegroup = await dispatch("getOnlineStatistics")
        // console.log("statistics", onlinegroup)
        onlinegroup++
        var country = await dispatch("getUserCountry")
        await firebase.database().ref('/appStatistics')
          .child(country)
          .update({
            online: onlinegroup
          }).catch(error => {
            console.log(error)
          });
        //dispatch("getGroupMembers", payload.group_name);
        //commit('setNumberOnline', onlinegroup)
      } catch (error) {
        console.log(error);
      }

    },


    async statisticsUsersOnlineRemove({ dispatch }) {

      try {
        var onlinegroup = await dispatch("getOnlineStatistics")
        //console.log("statistics",onlinegroup)
        if (onlinegroup > 0) {
          onlinegroup--
        }

        var country = await dispatch("getUserCountry")
        await firebase.database().ref('/appStatistics')
          .child(country)
          .update({
            online: onlinegroup
          });
        //dispatch("getGroupMembers", payload.group_name);
      } catch (error) {
        console.log(error);
      }

    },


    async pushNotifications({ commit, dispatch }, payload) {
      // console.log("push routine", JSON.stringify(payload))
      var user_uid = firebase.auth().currentUser.uid // Get a key for a new Post.
      var newPostKey = db.firenotifications.child(user_uid).push().key;

      await db.firenotifications.child(newPostKey)
        .update({
          title: payload.title,
          message_details: payload.message_details,
          uid: user_uid,
          timestamp: firebase.database.ServerValue.TIMESTAMP
        })
      commit("setAlertMessage", "Your broadcast message has been sent!")
    },


    async getFriendMembers({ commit }) {

      var promise = new Promise((resolve, reject) => {
        db.firefriends
          .child(firebase.auth().currentUser.uid)
          .once("value", snapshot => {
            var members = snapshot.val();
            var groupmembers = [];
            for (var key in members) {
              groupmembers.push(members[key]);
            }
            resolve(members)
            commit("setFriendMembers", groupmembers);
          }, err => {
            reject(err)
          });
      })
      return promise

    },

    async sendMessageToFriends({ commit, dispatch }, payload) {

      try {
        //send other members
        var members = await dispatch('getFriendMembers')

        _.forEach(members, member => {
          if (firebase.auth().currentUser.uid != member.uid && member.uid != null && member.uid != undefined) {
            db.firechats.child(firebase.auth().currentUser.uid)
              .child(member.uid)
              .push({
                sentby: firebase.auth().currentUser.uid,
                text: "Post Message:<br>" + payload.msg,
                image: payload.img,
                //avatar: firebase.auth().currentUser.photoURL,
                timestamp: firebase.database.ServerValue.TIMESTAMP
              })


            //db.firechats.child(member.uid)
            //.child(firebase.auth().currentUser.uid)
            // .push({
            // sentby: firebase.auth().currentUser.uid,
            // avatar: firebase.auth().currentUser.photoURL,
            // text: "Post Message:<br>" + payload.msg,
            // image: payload.img,
            //  timestamp: firebase.database.ServerValue.TIMESTAMP
            // })

          }
        })

        db.fireposts.child(firebase.auth().currentUser.uid)
          .push({
            sentby: firebase.auth().currentUser.uid,
            text: "Post Message: " + payload.msg,
            image: payload.img,
            //avatar: firebase.auth().currentUser.photoURL,
            timestamp: firebase.database.ServerValue.TIMESTAMP
          })


      } catch (error) {
        console.log("loop error", error)
      }


    },

    getPostChatMessages({ commit }) {

      var current_user = firebase.auth().currentUser
      db.fireposts.child(current_user.uid).on('value', snapshot => {
        var messages = snapshot.val()
        //console.log("messages",JSON.stringify(messages))
        _.forEach(messages, message => {
          message.type = message.sentby == current_user.uid ? 'sent' : 'received';
          message.name = message.sentby == current_user.uid ? current_user.displayName : current_user.displayName;
          message.date = moment(message.timestamp).format("MMMM Do dddd");
          message.smalldate = moment(message.timestamp).format("LTS");

        })
        var groupedmessages = _.groupBy(messages, 'date')
        //console.log("messages",JSON.stringify(groupedmessages))
        commit('setPostChatMessages', groupedmessages)

      })
    },

    getUserPayout({ commit }) {
      //var promise = new Promise((resolve, reject) => {
      firebase.database().ref('pay4me').child(firebase.auth().currentUser.uid).once('value', snapshot => {
        //var members = snapshot.val()

        if (snapshot.val() != null && snapshot.val() != undefined) {
          //console.log("user subscribe")

          firebase.database().ref('users').child(firebase.auth().currentUser.uid).once('value', datasnapshot => {

            if (datasnapshot.val() != null && datasnapshot.val() != undefined) {
              commit("setUserPayout", datasnapshot.val().payout);
            }

          })
          //commit("setSubscribeAffiliate", true);
        } else {
          //console.log("user not subscribed")
          //commit("setSubscribeAffiliate", false);
        }
        //console.log("am here" + JSON.stringify(snapshot.val().country))
        //commit("setUserCountry",snapshot.val().country)
        //resolve(snapshot.val().country)

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



    getUserAffiliate({ commit }) {
      //var promise = new Promise((resolve, reject) => {
      firebase.database().ref('pay4me').child(firebase.auth().currentUser.uid).once('value', snapshot => {
        //var members = snapshot.val()

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

      })
      //})
      //return promise
    },
    deleteAffiliate({ commit }) {
      //var promise = new Promise((resolve, reject) => {
      var user_uid = firebase.auth().currentUser.uid
      // User deleted.
      var ref = firebase.database().ref(
        "pay4me/".concat(user_uid, "/")
      );
      ref.remove();
      commit("setSubscribeAffiliate", false);
      commit("setAlertMessage", "Your Pay4me Program has been deleted")

    },


    async processModerator({ commit }, payload) {
      var user_uid = firebase.auth().currentUser.uid
      // console.log("payload in affiliate", JSON.stringify(payload))
      try {
        await firebase.database().ref('/beAModerator/')
          .child(user_uid)
          .update({
            twitter_handle: payload.twitter,
            instagram_IG: payload.instagram,
            timestamp: firebase.database.ServerValue.TIMESTAMP

          });
      } catch (error) {
        //console.log(error);
        commit("setAlertMessage", error)
      }
      // commit("setAlertMessage", "Your account activated for Pay4me Program")
    },


    async processAffiliate({ commit }, payload) {
      var user_uid = firebase.auth().currentUser.uid
      //console.log("payload in affiliate",JSON.stringify(payload))
      try {
        await firebase.database().ref('/pay4me/')
          .child(user_uid)
          .update({
            bank_name: payload.bank_name,
            account_name: payload.account_name,
            account_number: payload.account_number,
            paypal: payload.paypal
          });
      } catch (error) {
        console.log(error);
      }
      commit("setAlertMessage", "Your account activated for Gift Program")
    },

    async getMyGroups({ commit, dispatch }) {
      var group_name = await dispatch("getUserCountry")
      db.firegroups
        // .child("C0KUjyHioShrmY646lnmqgs3sFO2")
        .once("value", snapshot => {
          var mygroups = [];
          if (snapshot.val() != null) {

            let cnt = 0
            var groups = snapshot.val();
            for (var key in groups) {
              //console.log(JSON.stringify(key))
              if (key == group_name) {
                if (cnt == 0) {
                  var group = {
                    name: key,
                    pic: groups[key].group_pic,
                    owner: groups[key].owner
                  };
                  cnt = 1
                }
              }
              mygroups.push(group);
            }
          }
          commit("setChatGroups", mygroups);
        });
    }
  }
};
export default ChatGroupModule;