(function(w, _Vue) {
    let Vue;
    let store;

    function install(_Vue) {
        if (Vue && Vue === _Vue) {
            console.log("重复安装");
            return;
        }
        Vue = _Vue;
        applyMixin(Vue);
    }

    function applyMixin(Vue) {
        Vue.mixin({
            beforeCreate: vuexInit
        });
    }

    function vuexInit() {
        // this 指向每一个vue实例
        const { store, parent } = this.$options;
        if (store) {
            this.$store = typeof store === "function" ? store() : store;
        } else if (parent && parent.$store) {
            this.$store = parent.$store;
        }
    }

    function Store({
        state = {},
        getters = {},
        actions = {},
        mutations = {}
    } = {}) {
        store = this;
        let self = this;
        let computed = {};
        Object.keys(getters).forEach(key => {
            computed[key] = function() {
                return getters[key](self._vm.state);
            }
        });
        this._vm = new Vue({
            data: {
                state: state
            },
            methods: {
                ...actions
            },
            computed,
        });

        this.state = {};
        this.getters = {};
        this.actions = {};
        this.commit = function(type, ...args) {
            if (!mutations[type] || typeof mutations[type] !== "function") {
                throw new Error(`unknow mutation type ${type}`);
            }
            mutations[type](self.state, ...args)
        }
        proxyState(this, state);
        proxyGetters(this, getters);
        proxyActions(this, actions);

    }

    function proxyState(store, state) {
        Object.keys(state).forEach(key => {
            Object.defineProperty(store.state, key, {
                get() {
                    return store._vm.state[key]
                },
                set(val) {
                    store._vm.state[key] = val;
                }
            });
        });
    }

    function proxyGetters(store, getters) {
        Object.keys(getters).forEach(key => {
            Object.defineProperty(store.getters, key, {
                get() {
                    return store._vm[key];
                }
            });
        });
    }

    function proxyActions(store, actions) {
        Object.keys(actions).forEach(key => {
            Object.defineProperty(store.actions, key, {
                get() {
                    return function() {
                        return store._vm[key]({ commit: store.commit }, ...arguments)
                    }
                }
            })

        });
    }

    function toMap(arr) {
        let ret = {};
        if (Array.isArray(arr)) {
            arr.forEach(item => {
                ret[item] = item;
            });
        } else if (typeof arr === "object") {
            Object.keys(arr).forEach(key => {
                ret[key] = arr[key];
            });
        } else if (typeof arr === "string") {
            ret[arr] = arr;
        }
        return ret;
    }
    // ...mapState(['firstName', 'lastName'])
    // ...mapState({firstName: "localFirstName"})
    function mapState(state) {
        let ret = {};
        state = toMap(state);
        Object.keys(state).forEach(key => {
            ret[key] = function() {
                return store.state[state[key]]
            }
        });
        return ret;
    }

    function mapGetters(getters) {
        let ret = {};
        getters = toMap(getters);
        Object.keys(getters).forEach(key => {
            ret[key] = typeof store.getters[key] === "function" ? store.getters[key] : (function() {
                return store.getters[key]
            })
        });
        return ret;
    }

    function mapActions(actions) {
        let ret = {};
        actions = toMap(actions);
        Object.keys(actions).forEach(key => {
            ret[key] = store.actions[actions[key]];
        });
        return ret;
    }

    function mapMutations(mutations) {
        let ret = {};
        mutations = toMap(mutations);
        Object.keys(mutations).forEach(key => {
            ret[key] = function(...args) {
                store.commit(mutations[key], args)
            };
        });
        return ret;
    }

    const Vuex = {
        install,
        Store,
        mapState,
        mapGetters,
        mapActions,
        mapMutations,
    }
    window.Vuex = Vuex;
})(window, Vue);