import { Id } from '../types';
import { useAsync, UseAsyncResult, UseDeleteResult } from './use-async';
import { useBaseModelRelation, useSDKEventBus } from './use-models';
import { HasMany } from '../models/has-many';
import { EventTopic, BaseModel, CHANGE_EVENT_TYPE } from '../models';
import { useEffect, useState } from 'react';

export type UseHasMany<DataItem> = {
  model: any;
  getAllByParentId: (parentId: Id) => UseAsyncResult<DataItem[]>;
  createByParentId: (parentId: Id) => UseAsyncResult<DataItem>;
  updateAllByParentId: (parentId: Id) => UseAsyncResult<DataItem[]>;
  delAllByParentId: (parentId: Id) => UseDeleteResult<DataItem>;
};

export const useHasMany = <DataItem>(
  model: BaseModel<any>,
  classProp: string,
) => {
  const relation = useBaseModelRelation(model, classProp);
  const eventBus = useSDKEventBus();
  return {
    model: relation,
    getAllByParentId: useGetAllByParentId<DataItem>(relation, eventBus),
    createByParentId: useCreateByParentId<DataItem>(relation, eventBus),
    updateAllByParentId: useUpdateAllByParentId<DataItem>(relation, eventBus),
    delAllByParentId: useDelAllByParentId<void>(relation, eventBus),
  };
};

const useGetAllByParentId = <DataItem>(
  relation: HasMany<DataItem>,
  eventBus: EventTopic,
) => (parentId: Id): UseAsyncResult<DataItem[]> => {
  const [data, setData] = useState();
  const [gotten, fetch, loading, error] = useAsync<DataItem[]>(
    relation.getAll.bind(relation),
  );

  async function handleChange() {
    const d = await relation.getLocalAll(parentId);
    setData(d);
  }

  useEffect(() => {
    handleChange();
  }, []);

  useEffect(() => {
    eventBus.addEventListener(CHANGE_EVENT_TYPE, handleChange);
    return () => eventBus.removeEventListener(CHANGE_EVENT_TYPE, handleChange);
  });

  useEffect(() => {
    if (gotten) {
      setData(gotten);
    }
  }, [gotten]);
  const exec = (...args: any[]) => fetch(parentId, ...args);
  return [data, exec, loading, error];
};

const useCreateByParentId = <DataItem>(
  relation: HasMany<DataItem>,
  eventBus: EventTopic,
) => (parentId: Id): UseAsyncResult<DataItem> => {
  const [data, setData] = useState();
  const [gotten, fetch, loading, error] = useAsync(
    relation.create.bind(relation),
  );

  async function handleChange() {
    if (gotten && gotten.id) {
      setData(await relation.getLocalById(gotten.id));
    }
  }
  useEffect(() => {
    eventBus.addEventListener(CHANGE_EVENT_TYPE, handleChange);
    return () => eventBus.removeEventListener(CHANGE_EVENT_TYPE, handleChange);
  }, [gotten]);

  useEffect(() => {
    setData(gotten);
  }, [gotten]);
  const exec = (...args: any[]) => fetch(parentId, ...args);
  return [data, exec, loading, error];
};

const useUpdateAllByParentId = <DataItem>(
  relation: HasMany<DataItem>,
  eventBus: EventTopic,
) => (parentId: Id): UseAsyncResult<DataItem[]> => {
  const [data, setData] = useState<DataItem[]>();
  const [gotten, fetch, loading, error] = useAsync<DataItem[]>(
    relation.updateAll.bind(relation),
  );

  async function handleChange() {
    setData(await relation.getLocalAll(parentId));
  }

  useEffect(() => {
    eventBus.addEventListener(CHANGE_EVENT_TYPE, handleChange);
    return () => eventBus.removeEventListener(CHANGE_EVENT_TYPE, handleChange);
  });
  useEffect(() => {
    if (gotten) {
      setData(gotten);
    }
  }, [gotten]);
  const exec = (...args: any[]) => fetch(parentId, ...args);
  return [data, exec, loading, error];
};

const useDelAllByParentId = <DataItem>(
  relation: HasMany<DataItem>,
  eventBus: EventTopic,
) => (parentId: Id): UseDeleteResult<DataItem> => {
  const [
    // @ts-ignore
    gotten,
    fetch,
    loading,
    error,
  ] = useAsync<DataItem>(relation.delAll.bind(relation));
  const exec = (...args: any[]) => fetch(parentId, ...args);
  return [exec, loading, error];
};