import { requestThrottleGetters, requestThrottleMutations, requestThrottleState } from "../composables/requestThrottle";
import AddressService from "../../services/addressService";
import ErrorHandler from "../../errorHandler";
import Vue from 'vue';

const addressService = new AddressService();

export const addressState = {
    ...requestThrottleState,
    accountAddress: null,
    addresses: []
}

export const addressMutations = {
    ...requestThrottleMutations,
    storeAddresses(state, addresses) {
        Vue.set(state, 'addresses', addresses);
    },
    storeAccountAddress(state, address) {
        state.accountAddress = address;
    },
};

export const addressGetters = {
    ...requestThrottleGetters
};

export const addressActions = {
    loadAddresses({ commit, getters }) {
        commit('requesting', 'loadAddresses')
        let promise = addressService.addresses().then((response) => {
            commit('storeAddresses', response.data.data);
            return response.data.data;
        })

        promise.catch(ErrorHandler.logFor('loadAddresses')).finally(() => {
            commit('clearRequest', 'loadAddresses')
        })

        return promise;
    },
    loadAccountAddress({ commit, getters }) {
        commit('requesting', 'loadAccountAddress')
        let promise = addressService.accountAddress().then((response) => {
            commit('storeAccountAddress', response.data.data);
            return response.data.data;
        })

        promise.catch(ErrorHandler.logFor('loadAccountAddress')).finally(() => {
            commit('clearRequest', 'loadAccountAddress')
        })

        return promise;
    },
    markAsAccountAddress({ commit, getters, dispatch }, address) {
        commit('requesting', 'markAsAccountAddress')
        let promise = addressService.markAsAccountAddress(address).then((response) => {
            dispatch('loadAccountAddress');
            return null;
        })

        promise.catch(ErrorHandler.logFor('markAsAccountAddress')).finally(() => {
            commit('clearRequest', 'markAsAccountAddress')
        })

        return promise;
    },
    clearAccountAddress({ commit, getters, dispatch }, address) {
        commit('requesting', 'clearAccountAddress')
        let promise = addressService.clearAccountAddress(address).then((response) => {
            dispatch('loadAccountAddress');
            return null;
        })

        promise.catch(ErrorHandler.logFor('clearAccountAddress')).finally(() => {
            commit('clearRequest', 'clearAccountAddress')
        })

        return promise;
    },
    update({ commit, state, getters }, address) {
        commit('requesting', 'update')
        let promise = addressService.update(address).then((response) => {
            commit('clearRequest', 'update')
            return null;
        })

        promise.catch(ErrorHandler.logFor('update')).finally(() => {
            commit('clearRequest', 'update');
            return null;
        })

        return promise;
    },
    store({ commit, state, getters }, address) {
        commit('requesting', 'store')
        let promise = addressService.store(address).then((response) => {
            commit('clearRequest', 'store')
            return null
        })

        promise.catch(ErrorHandler.logFor('store')).finally(() => {
            commit('clearRequest', 'store');
            return null;
        })

        return promise;
    },
    delete({ commit, state, getters }, address) {
        commit('requesting', 'delete')
        let promise = addressService.delete(address).then((response) => {
            commit('clearRequest', 'delete')
        })

        promise.catch(ErrorHandler.logFor('delete')).finally(() => {
            commit('clearRequest', 'delete');
            return null;
        })

        return promise;
    }
};