import type { AsyncData } from "#app";
import type { ComputedRef, Ref } from "vue";
import { v4 as uuid4 } from "uuid";
import { useEntityManager } from "~/composables/data/useEntityManager";
import ApiResource from "~/models/ApiResource";
import type { AssociativeArray, Collection } from "~/types/data";

interface useEntityFetchReturnType {
  fetch: (
    model: typeof ApiResource,
    id: number,
  ) => AsyncData<ApiResource, ApiResource | true>;
  fetchCollection: (
    model: typeof ApiResource,
    parent?: ApiResource | null,
    query?: Ref<AssociativeArray>,
  ) => AsyncData<Collection, any>;
  // @ts-ignore
  getRef: <T extends ApiResource>(
    model: typeof T,
    id: Ref<number | null>,
  ) => ComputedRef<null | T>;
}

// TODO: améliorer le typage des fonctions sur le modèle de getRef
export const useEntityFetch = (
  lazy: boolean = false,
): useEntityFetchReturnType => {
  const { em } = useEntityManager();

  const fetch = (model: typeof ApiResource, id: number) =>
    useAsyncData(
      model.entity + "_" + id + "_" + uuid4(),
      () => em.fetch(model, id, true),
      { lazy },
    );

  const fetchCollection = (
    model: typeof ApiResource,
    parent: ApiResource | null = null,
    query: Ref<AssociativeArray | null> = ref(null),
  ) =>
    useAsyncData(
      model.entity + "_many_" + uuid4(),
      () => em.fetchCollection(model, parent, query.value ?? undefined),
      { lazy },
    );

  // @ts-ignore
  const getRef = <T extends ApiResource>(
    model: typeof T,
    id: Ref<number | null>,
  ): ComputedRef<T | null> => {
    return computed(() => (id.value ? (em.find(model, id.value) as T) : null));
  };

  // @ts-ignore
  return { fetch, fetchCollection, getRef };
};