import { ModuleRoot } from "moduse";
import { computed, reactive } from "vue";
import {
  AnyFun,
  ClassType,
  EmptyObj,
  ObjType,
  UnionToIntersectionReturnType,
  UnionToIntersectionType
} from "../../typing";

type IStore = {
  state: () => any;
  getters?: any;
  actions?: any;
};

interface IDefineStore {
  <
    K extends ClassType<any>,
    State extends () => ObjType<any>,
    Getters extends ObjType<(state: ReturnType<State>) => any>,
    Actions extends ObjType<AnyFun>
  >(
    this: K,
    store: {
      state: State;
      getters: Getters & ThisType<InstanceType<K>>;
      actions: Actions & ThisType<InstanceType<K>>;
    }
  ): {
    state: State;
    getters: Getters;
    actions: Actions;
  };
  <
    K extends ClassType<any>,
    State extends () => ObjType<any>,
    Actions extends ObjType<AnyFun>
  >(
    this: K,
    store: {
      state: State;
      actions: Actions & ThisType<InstanceType<K>>;
    }
  ): {
    state: State;
    getters: EmptyObj;
    actions: Actions;
  };
  <
    K extends ClassType<any>,
    State extends () => ObjType<any>,
    Getters extends ObjType<(state: ReturnType<State>) => any>
  >(
    this: K,
    store: {
      state: State;
      getters: Getters & ThisType<InstanceType<K>>;
    }
  ): {
    state: State;
    getters: Getters;
    actions: EmptyObj;
  };

  <K extends ClassType<any>, State extends () => ObjType<any>>(
    this: K,
    store: {
      state: State;
    }
  ): {
    state: State;
    getters: EmptyObj;
    actions: EmptyObj;
  };
}

export const defineStore: IDefineStore = function (store: any) {
  return store;
};

export function useStore<T extends IStore>(
  this: ModuleRoot,
  store: T | T[]
): UnionToIntersectionType<ReturnType<T["state"]>, never> &
  UnionToIntersectionReturnType<T["getters"], never> &
  UnionToIntersectionType<T["actions"], never> {
  const data: any = {},
    actions: any = {};
  const stores = store instanceof Array ? store : [store];
  stores.forEach((store) => {
    Object.assign(data, store.state());
    if (store.getters) {
      Object.entries(store.getters).forEach(([key, value]) => {
        data[key] = computed(() => (value as any).call(this, state));
      });
    }
    if (store.actions) {
      Object.entries(store.actions).forEach(([key, value]) => {
        actions[key] = (value as any).bind(this);
      });
    }
  });
  const state = reactive(data);
  Object.setPrototypeOf(state, actions);
  return state;
}