import { useEffect, useState } from 'react';
import { useAsync, UseAsyncResult, UseDeleteResult } from './use-async';
import { useSDKModel, useSDKEventBus } from './use-models';
import {
  // Count,
  Id,
  HasId,
} from '../types';
import { EventTopic, CHANGE_EVENT_TYPE, BaseModel } from '../models';

export type UseBaseModelType<DataItem> = {
  model: BaseModel<DataItem>;
  // count: UseAsyncResult<Count>;
  // patchAll: UseAsyncResult<Count>;
  getAll: () => UseAsyncResult<DataItem[]>;
  getById: (id: Id) => UseAsyncResult<DataItem>;
  create: () => UseAsyncResult<DataItem>;
  updateById: (id: Id) => UseAsyncResult<DataItem>;
  replaceById: (id: Id) => UseAsyncResult<DataItem>;
  deleteById: (id: Id) => UseDeleteResult<DataItem>;
};

export const useBaseModel = <DataItem>(
  classProp: string,
): UseBaseModelType<DataItem> => {
  const eventBus = useSDKEventBus();
  const model = useSDKModel<DataItem>(classProp);
  return {
    model,
    getAll: useGetAll<DataItem>(model, eventBus),
    getById: useGetById<DataItem>(model, eventBus),
    create: useCreate<DataItem>(model, eventBus),
    updateById: useUpdateById<DataItem>(model, eventBus),
    replaceById: useReplaceById<DataItem>(model, eventBus),
    deleteById: useDeleteById<DataItem>(model, eventBus),
  };
};

const useGetById = <DataItem>(
  model: BaseModel<DataItem>,
  eventBus: EventTopic,
) => (id: Id): UseAsyncResult<DataItem> => {
  const [data, setData] = useState();
  const [gotten, fetch, loading, error] = useAsync(model.getById.bind(model));

  async function handleChange() {
    const d = await model.getLocalById(id);
    setData(d);
  }

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

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

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

const useGetAll = <DataItem>(
  model: BaseModel<DataItem>,
  eventBus: EventTopic,
) => (): UseAsyncResult<DataItem[]> => {
  const [data, setData] = useState();
  const [gotten, fetch, loading, error] = useAsync(model.getAll.bind(model));

  useEffect(() => {
    function handleChange() {
      if (gotten && gotten.length) {
        const ids = gotten.map((g: HasId) => g.id).filter(Boolean);
        setData(model.getLocalFilter((item: HasId) => ids.includes(item.id)));
      }
    }
    eventBus.addEventListener(CHANGE_EVENT_TYPE, handleChange);
    return () => eventBus.removeEventListener(CHANGE_EVENT_TYPE, handleChange);
  });
  useEffect(() => {
    setData(gotten);
  }, [gotten]);
  const exec = (...args: any[]) => {
    return fetch(...args);
  };
  return [data, exec, loading, error];
};

const useCreate = <DataItem>(
  model: BaseModel<DataItem>,
  eventBus: EventTopic,
) => (): UseAsyncResult<DataItem> => {
  const [data, setData] = useState();
  const [gotten, fetch, loading, error] = useAsync(model.create.bind(model));

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

  useEffect(() => {
    setData(gotten);
  }, [gotten]);

  return [data, fetch, loading, error];
};

const useUpdateById = <DataItem>(
  model: BaseModel<DataItem>,
  eventBus: EventTopic,
) => (id: Id): UseAsyncResult<DataItem> => {
  const [data, setData] = useState();
  const [gotten, fetch, loading, error] = useAsync(model.update.bind(model));
  async function handleChange() {
    const d = await model.getLocalById(id);
    setData(d);
  }

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

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

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

const useReplaceById = <DataItem>(
  model: BaseModel<DataItem>,
  eventBus: EventTopic,
) => (id: Id): UseAsyncResult<DataItem> => {
  const [data, setData] = useState();
  const [gotten, fetch, loading, error] = useAsync(model.replace.bind(model));

  async function handleChange() {
    const d = await model.getLocalById(id);
    setData(d);
  }

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

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

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

const useDeleteById = <DataItem>(
  model: BaseModel<DataItem>,
  eventBus: EventTopic,
) => (id: Id): UseDeleteResult<DataItem> => {
  const [
    // @ts-ignore
    gotten,
    fetch,
    loading,
    error,
  ] = useAsync(model.del.bind(model));

  const exec = (...args: any[]) => fetch(id, ...args);
  return [exec, loading, error];
};