GCTC-NTGC / TalentCloud

  Reducer,

  useCallback,

  useEffect,

  useMemo,

  useReducer,

  useRef,

} from "react";

import {

  deleteRequest,

  FetchError,

  getRequest,

  postRequest,

  processJsonResponse,

  putRequest,

} from "../../helpers/httpRequests";

import { identity } from "../../helpers/queries";

import indexCrudReducer, {

  initializeState,

  ResourceState,

  ActionTypes,

  AsyncAction,

} from "./indexCrudReducer";

import { Json, ResourceStatus } from "./types";

type IndexedObject<T> = {

  [id: number]: T;

};

function valuesSelector<T extends { id: number }>(

  state: ResourceState<T>,

): IndexedObject<T> {

  return Object.values(state.values).reduce(

    (collection: IndexedObject<T>, item) => {

      collection[item.value.id] = item.value;

      return collection;

    },

    {},

  );

}

function statusSelector<T extends { id: number }>(

  state: ResourceState<T>,

): IndexedObject<ResourceStatus> {

  // If the entire index is being refreshed, then each individual item should be considered "pending".

  const forcePending = state.indexMeta.status === "pending";

  return Object.values(state.values).reduce(

    (collection: IndexedObject<ResourceStatus>, item) => {

      collection[item.value.id] = forcePending ? "pending" : item.status;

      return collection;

    },

    {},

  );

}

function defaultCreateEndpoint(baseEndpoint: string): string {

  return baseEndpoint;

}

function doNothing(): void {

  /* do nothing */

}

export function useResourceIndex<T extends { id: number }>(

  endpoint: string,

  overrides?: {

    initialValue?: T[]; // Defaults to an empty list.

    forceInitialRefresh: boolean; // If you set an initialValue but also want to refresh immediately, set this to true.

    parseIndexResponse?: (response: Json) => T[];

    parseEntityResponse?: (response: Json) => T;

    resolveEntityEndpoint?: (baseEndpoint: string, id: number) => string;

    resolveCreateEndpoint?: (baseEndpoint: string, newEntity: T) => string;

    handleError?: (error: Error | FetchError) => void;

  },

): {

  values: IndexedObject<T>;

  indexStatus: ResourceStatus;

  entityStatus: IndexedObject<ResourceStatus>;

  create: (newValue: T) => Promise<T>;

  refresh: () => Promise<T[]>; // Reloads the entire index.

  update: (newValue: T) => Promise<T>;

  deleteResource: (id: number) => Promise<void>;

} {

  const initialValue = overrides?.initialValue ?? [];

  const doInitialRefresh =

    overrides?.initialValue === undefined ||

    overrides?.forceInitialRefresh === true;

  const parseIndexResponse = overrides?.parseIndexResponse ?? identity;

  const parseEntityResponse = overrides?.parseEntityResponse ?? identity;

  const resolveEntityEndpoint =

    overrides?.resolveEntityEndpoint ?? defaultEntityEndpoint;

  const resolveCreateEndpoint =

    overrides?.resolveCreateEndpoint ?? defaultCreateEndpoint;

  const handleError = overrides?.handleError ?? doNothing;

  const isSubscribed = useRef(true);

  const [state, dispatch] = useReducer<

    Reducer<ResourceState<T>, AsyncAction<T>>,

    T[] // This represent type of initialValue, passed to initializeState to create initial state.

  >(indexCrudReducer, initialValue, initializeState);

  const values = useMemo(() => valuesSelector(state), [state]);

  const indexStatus = state.indexMeta.status;

  const entityStatus = useMemo(() => statusSelector(state), [state]);

  const create = useCallback(

    async (newValue: T): Promise<T> => {

      dispatch({

        type: ActionTypes.createStart,

        meta: { item: newValue },

      });

      let json: Json;

      try {

        json = await postRequest(

          resolveCreateEndpoint(endpoint, newValue),

          newValue,

        ).then(processJsonResponse);

      } catch (error) {

        if (isSubscribed.current) {

          dispatch({

            type: ActionTypes.createReject,

            payload: error,

            meta: { item: newValue },

          });

        }

        handleError(error);

        throw error;

      }

      const entity = parseEntityResponse(json) as T;

      if (isSubscribed.current) {

        dispatch({

          type: ActionTypes.createFulfill,

          payload: entity,

          meta: { item: newValue },

        });

      }

      return entity;

    },

    [endpoint, resolveCreateEndpoint, parseEntityResponse, handleError],

  );

  const refresh = useCallback(async (): Promise<T[]> => {

    dispatch({

      type: ActionTypes.indexStart,

    });

    let json: Json;

    try {

      json = await getRequest(endpoint).then(processJsonResponse);

    } catch (error) {

      if (isSubscribed.current) {

        dispatch({

          type: ActionTypes.indexReject,

          payload: error,

        });

      }

      handleError(error);

      throw error;

    }

    const index = parseIndexResponse(json) as T[];

    if (isSubscribed.current) {

      dispatch({

        type: ActionTypes.indexFulfill,

        payload: index,

      });

    }

    return index;

  }, [endpoint, parseIndexResponse, handleError]);

  const update = useCallback(

    async (newValue: T): Promise<T> => {

      const meta = { id: newValue.id, item: newValue };

      dispatch({

        type: ActionTypes.updateStart,

        meta,

      });

      let json: Json;

      try {

        json = await putRequest(

          resolveEntityEndpoint(endpoint, newValue.id),

          newValue,

        ).then(processJsonResponse);

      } catch (error) {

        if (isSubscribed.current) {

          dispatch({

            type: ActionTypes.updateReject,

            payload: error,

            meta,

          });

        }

        handleError(error);

        throw error;

      }

      const value = parseEntityResponse(json) as T;

      if (isSubscribed.current) {

        dispatch({

          type: ActionTypes.updateFulfill,

          payload: value,

          meta,

        });

      }

      return value;

    },

    [endpoint, resolveEntityEndpoint, parseEntityResponse, handleError],

  );

  const deleteResource = useCallback(

    async (id: number): Promise<void> => {

      dispatch({

        type: ActionTypes.deleteStart,

        meta: { id },

      });

      try {

        const response = await deleteRequest(

          resolveEntityEndpoint(endpoint, id),

        );

        if (!response.ok) {

          throw new FetchError(response);

        }

      } catch (error) {

        if (isSubscribed.current) {

          dispatch({

            type: ActionTypes.deleteReject,

            payload: error,

            meta: { id },

          });

        }

        handleError(error);

        throw error;

      }

      if (isSubscribed.current) {

        dispatch({

          type: ActionTypes.deleteFulfill,

          meta: { id },

        });

      }

    },

    [endpoint, resolveEntityEndpoint, handleError],

  );

  // Despite the usual guidlines, this should only be reconsidered if endpoint changes.

  // Changing doInitialRefresh after the first run (or refresh) should not cause this to rerun.

  useEffect(() => {

    if (doInitialRefresh) {

      refresh();

    }

    // eslint-disable-next-line react-hooks/exhaustive-deps

  }, [endpoint]);

  // Unsubscribe from promises when this hook is unmounted.

  useEffect(() => {

    return (): void => {

      isSubscribed.current = false;

    };

  }, []);

  return {

    values,

    indexStatus,

    entityStatus,

    create,

    refresh,

    update,

    deleteResource,

  };

}

export default useResourceIndex;