import { computed, ComputedRef, ref, Ref, UnwrapRef } from 'vue';
import { useGuids } from './use-guids';

const noFactoryErrorMsg = 'no valid factory was provided';
const noKeyErrorMsg = 'no valid key was provided';

const refs: { [key: string]: any } = {};

function useSingleton<T>(key: string): T;
function useSingleton<T>(key: string, factory: () => T): T;
function useSingleton<T>(key: string, factory?: () => T): T {
  if (!key) {
    throw new Error(noKeyErrorMsg);
  }

  if (!!refs[key]) {
    return refs[key] as T;
  }

  if (!!factory && typeof factory === 'function') {
    const ref = factory();
    refs[key] = ref;
    return ref;
  }

  throw new Error(noFactoryErrorMsg);
}

function useSingletonRef<T>(key: string): Ref<UnwrapRef<T>>;
function useSingletonRef<T>(key: string, factory: () => T): Ref<UnwrapRef<T>>;
function useSingletonRef<T>(key: string, factory?: () => T): Ref<UnwrapRef<T>> {
  if (!key) {
    throw new Error(noKeyErrorMsg);
  }

  if (!!refs[key]) {
    return refs[key] as Ref<UnwrapRef<T>>;
  }

  if (!!factory && typeof factory === 'function') {
    const refFactory = () => ref(factory());
    const item: any = useSingleton(key, refFactory);
    return item;
  }

  throw new Error(noFactoryErrorMsg);
}

function useSingletonComputed<T>(key: string): ComputedRef<T>;
function useSingletonComputed<T>(key: string, factory: () => T): ComputedRef<T>;
function useSingletonComputed<T>(key: string, factory?: () => T): ComputedRef<T> {
  if (!key) {
    throw new Error(noKeyErrorMsg);
  }

  if (!!refs[key]) {
    return refs[key] as ComputedRef<T>;
  }

  if (!!factory && typeof factory === 'function') {
    const refFactory = () => computed(factory);
    return useSingleton(key, refFactory);
  }

  throw new Error(noFactoryErrorMsg);
}

type Lazy<T> = { value: T };

function useLazy<T>(factory: () => T): Lazy<T>;
function useLazy<T>(key: string, factory: () => T): Lazy<T>;
function useLazy<T>(keyOrFactory: string | (() => T), factory?: () => T): Lazy<T> {
  if (typeof keyOrFactory === 'function') {
    const { generateGuid } = useGuids();
    const key = generateGuid();
    return {
      get value() {
        return useSingleton(key, keyOrFactory);
      },
    };
  } else if (!!factory) {
    return {
      get value() {
        return useSingleton(keyOrFactory, factory);
      },
    };
  } else {
    throw new Error(noFactoryErrorMsg);
  }
}

function useLazyRef<T>(factory: () => T): Lazy<Ref<UnwrapRef<T>>>;
function useLazyRef<T>(key: string, factory: () => T): Lazy<Ref<UnwrapRef<T>>>;
function useLazyRef<T>(keyOrFactory: string | (() => T), factory?: () => T): Lazy<Ref<UnwrapRef<T>>> {
  const factoryToUse: () => T = (factory || keyOrFactory) as any;
  if (typeof factoryToUse !== 'function') {
    throw new Error(noFactoryErrorMsg);
  }

  const { generateGuid } = useGuids();
  const key = typeof keyOrFactory === 'string' ? keyOrFactory : generateGuid();
  const refFactory = () => ref(factoryToUse());
  const item: any = useLazy(key, refFactory);
  return item;
}

function useLazyComputed<T>(factory: () => T): Lazy<ComputedRef<T>>;
function useLazyComputed<T>(key: string, factory: () => T): Lazy<ComputedRef<T>>;
function useLazyComputed<T>(keyOrFactory: string | (() => T), factory?: () => T): Lazy<ComputedRef<T>> {
  const factoryToUse: () => T = (factory || keyOrFactory) as any;
  if (typeof factoryToUse !== 'function') {
    throw new Error(noFactoryErrorMsg);
  }

  const { generateGuid } = useGuids();
  const key = typeof keyOrFactory === 'string' ? keyOrFactory : generateGuid();
  const refFactory = () => computed(factoryToUse);
  const item: any = useLazy(key, refFactory);
  return item;
}

export { useSingleton, useSingletonComputed, useSingletonRef, useLazy, useLazyComputed, useLazyRef };