import { REST } from "vuejs/api/rest-axios";
// import { JSONAPI } from 'vuejs/api/json-axios';
import { MA } from "vuejs/api/ma-axios";
import qs from "querystring-es3";

export default {
  namespaced: true,

  // initial state
  state: {
    uid: null,
    // username: '',
    mail: "",
    csrf_token: null,
    logout_token: null,
    isloggedin: false,
    isAdmin: false,
    isAdherent: false,
    canSearch: false,
    roles: [],
    flagcolls: false
  },

  // getters
  getters: {},

  // mutations
  mutations: {
    SetCsrftoken(state, token) {
      console.log('SetCsrftoken', token);
      state.csrf_token = token;
    },
    setToken(state, data) {
      state.uid = data.current_user.uid;
      // state.username = data.username;
      state.mail = data.current_user.mail;
      state.csrf_token = data.csrf_token;
      state.isloggedin = true;
      state.logout_token = data.logout_token;
    },
    setUid(state, uid) {
      state.uid = uid;
      state.isloggedin = true;
    },
    setUser(state, data) {
      state.mail = data.mail[0].value;
      state.uuid = data.uuid[0].value;
    },
    setRoles(state, roles) {
      console.log("User setRoles", roles);
      state.roles = [];
      for (let i = 0; i < roles.length; i++) {
        state.roles.push(roles[i].target_id);
      }
      // check if admin
      if (
        state.roles.indexOf("admin") !== -1 ||
        state.roles.indexOf("root") !== -1
      ) {
        // console.log('is admin');
        state.isAdmin = true;
      }
      // check if has access to search
      if (state.roles.indexOf("adherent") !== -1) {
        // console.log('is admin');
        state.canSearch = true;
        state.isAdherent = true;
      }
    },
    setLoggedOut(state) {
      console.log("setLoggedOut state", state);
      state.uid = null;
      state.mail = "";
      state.csrf_token = null;
      state.isloggedin = false;
      state.logout_token = null;
      if (state.isAdmin) {
        // TODO: what if on a page where login is needed (as commerce checkout and cart)
        window.location.reload(true);
      }
      state.asAdmin = false;
      state.canSearch = false;
    },
    setFlagColls(state, flagcolls) {
      console.log("User setFlagColls", flagcolls);
      state.flagcolls = flagcolls;
    }
  },

  // actions
  actions: {
    userRegister({ dispatch, commit, state }, credentials) {
      return new Promise((resolve) => {
        REST.get("/session/token").then(({ token }) => {
          commit("SetCsrftoken", token);
          REST.post("/user/register?_format=json", credentials, {
            "X-CSRF-Token": state.csrftoken
          })
            .then(({ data }) => {
              console.log("user REST registered", data);
              dispatch("userLogin", credentials).then(() => {
                resolve();
              });
            })
            .catch(error => {
              console.warn("Issue with register", error);
              Promise.reject(error);
            });
        });
      });
    },
    userLogin({ dispatch, state }, credentials) {
      return new Promise((resolve, reject) => {
        dispatch("getToken", credentials).then(() => {
          dispatch("getUser").then(userdata => {
            console.log("User Loggedin");
            if (state.isAdmin) {
              window.location.reload(true);
            }
            resolve();
          });
        });
      });
    },
    getToken({ dispatch, commit, state }, credentials) {
      return REST.post("/user/login?_format=json", credentials)
        .then(({ data }) => {
          console.log("user REST getToken data", data);
          commit("setToken", data);
        })
        .catch(error => {
          console.warn("Issue with getToken", error);
          Promise.reject(error);
        });
    },
    getUser({ dispatch, commit, state }) {
      return new Promise((resolve, reject) => {
        REST.get("/session/token").then(({ data }) => {
          console.log('csrftoken', data);
          commit("SetCsrftoken", data);
          console.log('state.csrf_token', state.csrf_token);
          const params = {
            token: state.csrf_token
          };
          REST.get(`/user/${state.uid}?_format=json`, params)
            .then(({ data }) => {
              console.log("user REST getUser data", data);
              console.log("roles", data.roles);
              commit("setUser", data);
              if (data.roles) {
                commit("setRoles", data.roles);
              }
              dispatch("getUserFlagColls");
              resolve();
            })
            .catch(error => {
              console.warn("Issue with getUser", error);
              Promise.reject(error);
            });
        });
      });
    },
    getUserFlagColls({ dispatch, commit, state }) {
      // flags
      // REST.get('/flagging_collection/1?_format=json')
      //   .then(( data ) => {
      //     console.log('TEST FLAG REST data', data)
      //   })
      //   .catch(error => {
      //       console.warn('Issue USER TEST FLAG REST', error)
      //       Promise.reject(error)
      //   })

      return MA.get("materio_flag/user_flagging_collections")
        .then(({ data }) => {
          console.log("user MA getFlags data", data);
          commit("setFlagColls", data);
        })
        .catch(error => {
          console.warn("Issue USER MA getFlags", error);
          Promise.reject(error);
        });
    },
    // https://drupal.stackexchange.com/questions/248539/cant-get-flagging-api-to-accept-post-request
    createFlagColl({ dispatch, commit, state }, new_collection_name) {
      console.log("user createFlagColl", new_collection_name);
      return new Promise((resolve, reject) => {
        const params = {
          name: new_collection_name
        };
        MA.post("materio_flag/create_user_flagging_collection", params)
          .then(({ data }) => {
            console.log("user MA createFlagColl data", data);
            if (data.status) {
              dispatch('getUserFlagColls').then(() => {
                resolve();
              })
            }
          })
          .catch(error => {
            console.warn("Issue USER MA createFlag", error);
            reject(error);
          });
      });
    },
    deleteFlagColl({ dispatch, commit, state }, flagcollid) {
      console.log("user deleteFlagColl", flagcollid);
      return new Promise((resolve, reject) => {
        const params = {
          flagcollid: flagcollid
        };
        MA.post("materio_flag/delete_user_flagging_collection", params)
          .then(({ data }) => {
            console.log("user MA deleteFlagColl data", data);
            dispatch('getUserFlagColls').then(() =>{
              resolve();
            });
          })
          .catch(error => {
            console.warn("Issue USER MA createFlag", error);
            reject(error);
          });
      });
    },
    flag({ dispatch, commit, state }, args) {
      console.log("user flag", args.uuid, args.collid);
      return new Promise((resolve, reject) => {
        const params = {
          flagid: state.flagcolls[args.collid].flag_id,
          uuid: args.uuid,
          flagcollid: args.collid
        };
        return MA.post(`materio_flag/flag`, params)
          .then(({ data }) => {
            console.log("user MA flag", data);
            dispatch('getUserFlagColls').then(() =>{
              resolve();
            });
          })
          .catch(error => {
            console.warn("Issue USER MA flag", error);
          });
      });

    },
    unFlag({ dispatch, commit, state }, args) {
      console.log("user unFlag", args.uuid, args.collid);
      return new Promise((resolve, reject) => {
        const params = {
          flagid: state.flagcolls[args.collid].flag_id,
          uuid: args.uuid,
          flagcollid: args.collid
        };
        return MA.post(`materio_flag/unflag`, params)
          .then(({ data }) => {
            console.log("user MA unFlag", data);
            dispatch('getUserFlagColls').then(() =>{
              resolve();
            });
          })
          .catch(error => {
            console.warn("Issue USER MA unFlag", error);
          });
      });
    },
    userLogout({ commit, state }) {
      const credentials = qs.stringify({
        token: state.csrf_token
      });
      REST.post("/user/logout", credentials)
        .then(resp => {
          console.log("userLogout resp", resp);
          commit("setLoggedOut");
        })
        .catch(error => {
          console.warn("Issue with logout", error);
          Promise.reject(error);
        });
    }
  }
};