import Vue from 'vue';
const mode = 'dev';
var paths = [
  { name: 'local', url: 'http://127.0.0.1:8000/' },
  { name: 'dev', url: 'https://api.bigdatatech.cloud/' },
  { name: 'prod', url: 'https://api.bigdatatech.cloud/' },
];
const path = paths.find((v) => v.name === mode).url;
const apis = [
  { name: 'upload', url: 'upload/', params: {} },
  { name: 'image', url: 'data/Image/', url_detail: 'data-detail/Image/', params: {} },
  { name: 'file', url: 'data/File/', url_detail: 'data-detail/File/', params: {} },

  {
    name: 'user',
    url: 'data/User/',
    url_detail: 'data-detail/User/',
    params: {
      sort: '-id',
      values:
        'id,auth_method__code,blocked,auth_status__code,username,register_method__code,fullname,type,type__code,type__name,create_time,create_time__date,auth_method,auth_status,register_method,create_time,update_time',
    },
  },

  {
    name: 'blockreason',
    commit: 'updateBlockReason',
    url: 'data/Block_Reason/',
    url_detail: 'data-detail/Block_Reason/',
    params: { page: -1 },
  },
  {
    name: 'authstatus',
    commit: 'updateAuthStatus',
    url: 'data/Auth_Status/',
    url_detail: 'data-detail/Auth_Status/',
    params: { page: -1 },
  },
  {
    name: 'authmethod',
    commit: 'updateAuthMethod',
    url: 'data/Auth_Method/',
    url_detail: 'data-detail/Auth_Method/',
    params: { page: -1 },
  },
  {
    name: 'usertype',
    commit: 'updateUserType',
    url: 'data/User_Type/',
    url_detail: 'data-detail/User_Type/',
    params: {},
  },
  {
    name: 'registermethod',
    commit: 'updateRegisterMethod',
    url: 'data/Register_Method/',
    url_detail: 'data-detail/Register_Method/',
    params: { page: -1 },
  },
  {
    name: 'langchoice',
    commit: 'updateLangChoice',
    url: 'data/Lang_Choice/',
    url_detail: 'data-detail/Lang_Choice/',
    params: {},
  },
  { name: 'userauth', url: 'data/User_Auth/', url_detail: 'data-detail/User_Auth/', params: { sort: '-id' } },
  { name: 'accountrecovery', url: 'data/Account_Recovery/', url_detail: 'data-detail/Account_Recovery/', params: {} },
  {
    name: 'login',
    url: 'login/',
    params: {
      values:
        'id,username,email,password,avatar,fullname,display_name,type,type__code,type__name,blocked,block_reason,block_reason__code,block_reason__name,blocked_by,last_login,auth_method,auth_method__code,auth_method__name,auth_status,auth_status__code,auth_status__name,register_method,register_method__code,register_method__name,create_time,update_time',
    },
  },
  { name: 'authtoken', url: 'auth-token/', params: {} },

  { name: 'emailsetup', url: 'data/Email_Setup/', url_detail: 'data-detail/Email_Setup/', params: { sort: '-id' } },
  {
    name: 'emailsent',
    url: 'data/Email_Sent/',
    url_detail: 'data-detail/Email_Sent/',
    params: {
      values:
        'id,receiver,content,content__sender__email,content__subject,content__content,status__code,status,status__name,create_time',
      sort: '-id',
    },
  },
  { name: 'sendemail', url: 'send-email/', params: {} },
  { name: 'token', url: 'data/Token/', url_detail: 'data-detail/Token', params: { filter: { expiry: 0 } } },
  {
    name: 'common',
    commit: 'updateCommon',
    url: 'data/Common/',
    url_detail: 'data-detail/Common/',
    params: { sort: 'index' },
  },
  { name: 'sex', url: 'data/Sex/', url_detail: 'data-detail/Sex/', params: {} },
  { name: 'downloadfile', url: 'download-file/', params: {} },
  { name: 'download', url: 'download/', params: {} },
  { name: 'gethash', url: 'get-hash/', params: {} },
  { name: 'userapps', url: 'data/User_Apps/', url_detail: 'data-detail/User_Apps/', params: {} },
  { name: 'customer', url: 'data/Customer/', url_detail: 'data-detail/Customer/', params: {} },
];

Vue.use({
  install(Vue) {
    Vue.prototype.$path = function (name) {
      return name ? paths.find((v) => v.name === name).url : path;
    };

    Vue.prototype.$findapi = function (name) {
      const result = Array.isArray(name)
        ? apis.filter((v) => name.findIndex((x) => v.name === x) >= 0)
        : apis.find((v) => v.name === name);
      return this.$copy(result);
    };

    Vue.prototype.$readyapi = function (list) {
      var array = [];
      list.forEach((element) => {
        let found = apis.find((v) => v.name === element);
        if (found) {
          let ele = JSON.parse(JSON.stringify(found));
          ele.ready = this.$store.state[element] ? true : false;
          array.push(ele);
        }
      });
      return array;
    };

    // get data
    Vue.prototype.$getapi = async function (list) {
      try {
        let arr = list.map((v) => {
          let found = apis.find((v) => v.name === v.name);
          let url = (v.path ? paths.find((x) => x.name === v.path).url : path) + (v.url ? v.url : found.url);
          let params = v.params ? v.params : found.params === undefined ? {} : found.params;
          params.login = this.$store.state.login ? this.$store.state.login.id : undefined;
          return { url: url, params: params };
        });
        let data = await Promise.all(arr.map((v) => this.$axios.get(v.url, { params: v.params })));
        data.map((v, i) => {
          list[i].data = v.data;
          if (list[i].commit) {
            let payload = {};
            payload[list[i].name] = v.data.rows ? v.data.rows : v.data;
            this.$store.commit(list[i].commit, payload);
          }
        });
        return list;
      } catch (err) {
        console.log(err);
        return 'error';
      }
    };

    // insert data
    Vue.prototype.$insertapi = async function (name, data, values) {
      try {
        let found = this.$findapi(name);
        let curpath = found.path ? paths.find((x) => x.name === found.path).url : path;
        var rs;
        if (!Array.isArray(data))
          rs = await this.$axios.post(`${curpath}${found.url}`, data, { params: { values: values } });
        else {
          let params = { action: 'import', values: values };
          rs = await this.$axios.post(`${curpath}import-data/${found.url.substring(5, found.url.length - 1)}/`, data, {
            params: params,
          });
        }

        // update store
        if (found.commit) {
          if (this.$store.state[found.name]) {
            let copy = JSON.parse(JSON.stringify(this.$store.state[found.name]));
            let rows = Array.isArray(rs.data) ? rs.data : [rs.data];
            rows.map((v) => {
              if (v.id && !v.error) {
                let idx = copy.findIndex((x) => x.id === v.id);
                if (idx >= 0) copy[idx] = v;
                else copy.push(v);
              }
            });
            this.$store.commit('updateStore', { name: found.name, data: copy });
          }
        }
        return rs.data;
      } catch (err) {
        console.log(err);
        return 'error';
      }
    };

    // update api
    Vue.prototype.$updateapi = async function (name, data, values) {
      try {
        let found = this.$findapi(name);
        let rs = await this.$axios.put(`${path}${found.url_detail}${data.id}/`, data, {
          params: { values: values ? values : found.params.values },
        });
        if (found.commit) {
          let index = this.$store.state[found.name]
            ? this.$store.state[found.name].findIndex((v) => v.id === rs.data.id)
            : -1;
          if (index >= 0) {
            var copy = JSON.parse(JSON.stringify(this.$store.state[found.name]));
            if (Array.isArray(rs.data) === false) Vue.set(copy, index, rs.data);
            else {
              rs.data.forEach((v) => {
                let index = copy.findIndex((v) => v.id === v.id);
                if (index >= 0) Vue.set(copy, index, v);
              });
            }
            this.$store.commit('updateStore', { name: found.name, data: copy });
          }
        }
        return rs.data;
      } catch (err) {
        console.log(err);
        return 'error';
      }
    };

    // delete data
    Vue.prototype.$deleteapi = async function (name, id) {
      try {
        let found = this.$findapi(name);
        var rs;
        if (!Array.isArray(id)) rs = await this.$axios.delete(`${path}${found.url_detail}${id}`);
        else {
          let params = { action: 'delete' };
          rs = await this.$axios.post(`${path}import-data/${found.url.substring(5, found.url.length - 1)}/`, id, {
            params: params,
          });
        }
        if (found.commit) {
          let copy = JSON.parse(JSON.stringify(this.$store.state[found.name]));
          if (!Array.isArray(id)) {
            let index = copy.findIndex((v) => v.id === id);
            if (index >= 0) this.$delete(copy, index);
          } else {
            rs.data.forEach((element) => {
              let index = copy.findIndex((v) => v.id === element.id);
              if (index >= 0) this.$delete(copy, index);
            });
          }
          this.$store.commit('updateStore', { name: found.name, data: copy });
        }
        return rs.data;
      } catch (err) {
        console.log(err);
        return 'error';
      }
    };

    // insert row
    Vue.prototype.$insertrow = async function (name, data, values, pagename) {
      let result = await this.$insertapi(name, data, values);
      if (result === 'error') return;
      let arr = Array.isArray(result) ? result : [result];
      let copy = this.$copy(this.$store.state[pagename].data);
      arr.map((x) => {
        let index = copy.findIndex((v) => v.id === x.id);
        index >= 0 ? (copy[index] = x) : copy.unshift(x);
      });
      this.$store.commit('updateState', { name: pagename, key: 'data', data: copy });
      let pagedata = this.$store.state[pagename];
      if (pagedata.filters ? pagedata.filters.length > 0 : false) {
        this.$store.commit('updateState', { name: pagename, key: 'filterby', data: this.$copy(pagedata.filters) });
      }
    };

    // update row
    Vue.prototype.$updaterow = async function (name, data, values, pagename) {
      let result = await this.$updateapi(name, data, values);
      if (result === 'error') return;
      let arr = Array.isArray(result) ? result : [result];
      let copy = this.$copy(this.$store.state[pagename].data);
      arr.map((x) => {
        let index = copy.findIndex((v) => v.id === x.id);
        index >= 0 ? (copy[index] = x) : copy.unshift(x);
      });
      this.$store.commit('updateState', { name: pagename, key: 'data', data: copy });
      let pagedata = this.$store.state[pagename];
      if (pagedata.filters ? pagedata.filters.length > 0 : false) {
        this.$store.commit('updateState', { name: pagename, key: 'filterby', data: this.$copy(pagedata.filters) });
      }
    };

    // delete row
    Vue.prototype.$deleterow = async function (name, id, pagename, ask) {
      let self = this;
      var remove = async function () {
        let result = await self.$deleteapi(name, id);
        if (result === 'error') return;
        let arr = Array.isArray(id) ? id : [id];
        let copy = self.$copy(self.$store.state[pagename].data);
        arr.map((x) => {
          let index = copy.findIndex((v) => v.id === x);
          index >= 0 ? self.$delete(copy, index) : false;
        });
        self.$store.commit('updateState', { name: pagename, key: 'data', data: copy });
        let pagedata = this.$store.state[pagename];
        if (pagedata.filters ? pagedata.filters.length > 0 : false) {
          this.$store.commit('updateState', { name: pagename, key: 'filterby', data: this.$copy(pagedata.filters) });
        }
      };

      // ask confirm
      if (ask) {
        this.$buefy.dialog.confirm({
          message: 'Bạn muốn xóa bản ghi: ' + id,
          onConfirm: () => remove(),
        });
      } else remove();
    };

    // update page
    Vue.prototype.$updatepage = function (pagename, row, action) {
      let pagedata = this.$store.state[pagename];
      let copy = this.$copy(pagedata.data);
      let idx = copy.findIndex((v) => v.id === row.id);
      if (action === 'delete') this.$delete(copy, idx);
      else if (action === 'insert') copy.unshift(row);
      else copy[idx] = row;
      this.$store.commit('updateState', { name: pagename, key: 'data', data: copy });
      if (pagedata.filters ? pagedata.filters.length > 0 : false) {
        this.$store.commit('updateState', { name: pagename, key: 'filterby', data: this.$copy(pagedata.filters) });
      }
    };

    Vue.prototype.$getdata = async function (name, filter, params, first) {
      let found = this.$findapi(name);
      if (params) found.params = params;
      else if (filter) found.params.filter = filter;
      let rs = await this.$getapi([found]);
      return first ? (rs[0].data.rows.length > 0 ? rs[0].data.rows[0] : undefined) : rs[0].data.rows;
    };

    Vue.prototype.$getpage = function (showFilter) {
      return {
        data: [],
        fields: [],
        filters: [],
        update: undefined,
        action: undefined,
        filterby: undefined,
        api: { full_data: true },
        origin_api: { full_data: true },
        tablesetting: undefined,
        setting: undefined,
        tabfield: true,
        setpage: {},
        showFilter: this.$empty(showFilter) ? true : showFilter,
      };
    };

    Vue.prototype.$setpage = function (pagename, row, api) {
      if (!this.$store.state[pagename]) return;
      let json = row.detail;
      let fields = this.$updateSeriesFields(json.fields);
      this.$store.commit('updateState', { name: pagename, key: 'fields', data: fields });
      this.$store.commit('updateState', { name: pagename, key: 'setting', data: this.$copy(row) });
      if (json.filters)
        this.$store.commit('updateState', { name: pagename, key: 'filters', data: this.$copy(json.filters) });
      if (json.tablesetting)
        this.$store.commit('updateState', { name: pagename, key: 'tablesetting', data: json.tablesetting });
      if (api) {
        let copy = this.$copy(api);
        delete copy.data;
        copy.full_data = api.data.full_data;
        copy.total_rows = api.data.total_rows;
        this.$store.commit('updateState', { name: pagename, key: 'api', data: copy });
        this.$store.commit('updateState', { name: pagename, key: 'origin_api', data: copy });
      }
    };

    Vue.prototype.$findpage = function (arr) {
      var copy = this.$copy(this.$store.state.pagetrack);
      var doFind = function () {
        let found = undefined;
        for (let i = 1; i <= 30; i++) {
          let name = `pagedata${i}`;
          if (!copy[name]) {
            found = name;
            copy[name] = true;
            break;
          }
        }
        if (!found) console.log('pagename not found');
        return found;
      };
      let result;
      if (arr) {
        result = [];
        arr.map((v) => {
          result.push({ name: v, value: doFind() });
        });
      } else {
        result = doFind(copy);
      }
      this.$store.commit('updateStore', { name: 'pagetrack', data: copy });
      return result;
    };

    Vue.prototype.$clearpage = function (pagename) {
      if (!pagename) return;
      if (pagename === 'reset') return this.$store.commit('updateStore', { name: 'pagetrack', data: {} });
      let copy = this.$copy(this.$store.state.pagetrack);
      let arr = Array.isArray(pagename) ? pagename : [pagename];
      arr.map((v) => {
        copy[v] = false;
        this.$store.commit('updateStore', { name: v, data: undefined });
      });
      this.$store.commit('updateStore', { name: 'pagetrack', data: copy });
    };

    Vue.prototype.$updatepath = function (val) {
      path = `https://${val}/`;
    };
  },
});