AppContext.tsx

import {
  createContext,
  Dispatch,
  ReactNode,
  useContext,
  useEffect,
  useReducer,
} from 'react';
import { SESSION_KEY } from './const/session';
import { getStorage } from './store/storage';
import { getInternalEventBus } from './helpers/internalEventBus';
import { InternalEvents } from './const/internalEvents';
import { EventBus } from './helpers/createComponent/EventBus';
import { UITagsEnum, ProviderFactory } from './lib/sdkDapp';

const AsyncStorage = getStorage();

export type AppStateType = {
  isInitialized: boolean;
  address?: string;
  encrypted?: string | object;
  registeredDAppComponents: Record<UITagsEnum, object>;
};

const initialState: AppStateType = {
  isInitialized: false,
  address: '',
  encrypted: '',
  registeredDAppComponents: {} as Record<UITagsEnum, object>,
};

type ActionMap<M extends { [index: string]: any }> = {
  [Key in keyof M]: M[Key] extends undefined
    ? {
        type: Key;
      }
    : {
        type: Key;
      } & M[Key]; // Explicitly constrain Key to string and intersect with M[Key]
};

enum ActionType {
  INITIALIZED = 'INITIALIZED',
  REGISTER_DAPP_COMPONENT = 'REGISTER_DAPP_COMPONENT',
  UNREGISTER_DAPP_COMPONENT = 'UNREGISTER_DAPP_COMPONENT',
  UPDATE_SESSION = 'UPDATE_SESSION',
  GENERATE = 'GENERATE',
  CLEAR = 'CLEAR',
}

type ActionPayloadType = {
  [ActionType.INITIALIZED]: never;
  [ActionType.REGISTER_DAPP_COMPONENT]: {
    componentType: UITagsEnum;
    componentProps: object;
  };
  [ActionType.UNREGISTER_DAPP_COMPONENT]: {
    componentType: UITagsEnum;
  };
  [ActionType.UPDATE_SESSION]: AppStateType;
  [ActionType.GENERATE]: {
    address: string;
    encrypted: string | object;
    accessToken: string;
  };
  [ActionType.CLEAR]: never;
};

export type Actions =
  ActionMap<ActionPayloadType>[keyof ActionMap<ActionPayloadType>];

type ContextType = {
  state: AppStateType;
  dispatch: Dispatch<Actions>;
};

const AppContext = createContext<ContextType>({
  state: initialState,
  dispatch: () => null,
});

export const reducer = (
  state: AppStateType,
  action: Actions,
): typeof initialState => {
  switch (action.type) {
    case ActionType.INITIALIZED: {
      return {
        ...state,
        isInitialized: true,
      };
    }

    case ActionType.REGISTER_DAPP_COMPONENT: {
      const { componentType, componentProps } = action;

      state.registeredDAppComponents[componentType] = componentProps;

      return {
        ...state,
      };
    }

    case ActionType.UNREGISTER_DAPP_COMPONENT: {
      const { componentType } = action;

      delete state.registeredDAppComponents[componentType];

      return {
        ...state,
      };
    }

    case ActionType.UPDATE_SESSION: {
      const { ...session } = action;

      return {
        ...state,
        ...session,
      };
    }

    case ActionType.GENERATE: {
      const { address, encrypted } = action;

      return {
        ...state,
        address,
        encrypted,
      };
    }

    case ActionType.CLEAR: {
      AsyncStorage.clear();
      return initialState;
    }

    default: {
      throw new Error(`unhandled type ${(action as { type: string }).type}`);
    }
  }
};

let isAppInitialized = false;

export const Provider = ({ children }: React.PropsWithChildren) => {
  const [state, dispatch] = useReducer(reducer, {
    ...initialState,
  });

  const getCurrentSession = async () => {
    const sessionData = await AsyncStorage.getItem(SESSION_KEY);
    const session = sessionData ? JSON.parse(sessionData) : initialState;

    dispatch({
      type: ActionType.UPDATE_SESSION,
      ...session,
    });
  };

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

  useEffect(() => {
    AsyncStorage.setItem(SESSION_KEY, JSON.stringify(state));
  }, [state]);

  const onLogin = async () => {
    try {
      const provider = await ProviderFactory.create({
        type: 'RN_DAppProvider',
      });

      provider.login();
    } catch (err) {
      console.error('Provider logged in error:', err);
    }
  };

  useEffect(() => {
    if (!isAppInitialized) {
      return;
    }

    if (state.address && state.encrypted) {
      onLogin();
    }
  }, [state.address, state.encrypted, state.isInitialized]);

  useEffect(() => {
    const unsubscribeDappInit = getInternalEventBus().subscribe(
      InternalEvents.DAPP_INITIALIZED,
      () => {
        isAppInitialized = true;
      },
    );

    const unsubscribeRegister = getInternalEventBus().subscribe(
      InternalEvents.COMPONENT_REGISTERED,
      (msg: { type: UITagsEnum; component: ReactNode; eventBus: EventBus }) => {
        const { type, component, eventBus } = msg;

        dispatch({
          type: ActionType.REGISTER_DAPP_COMPONENT,
          componentType: type,
          componentProps: {
            component,
            eventBus,
          },
        });
      },
    );

    const unsubscribeUnregister = getInternalEventBus().subscribe(
      InternalEvents.UNREGISTER_DAPP_COMPONENT,
      (msg: { type: UITagsEnum }) => {
        const { type } = msg;

        dispatch({
          type: ActionType.UNREGISTER_DAPP_COMPONENT,
          componentType: type,
        });
      },
    );

    return () => {
      unsubscribeDappInit();
      unsubscribeRegister();
      unsubscribeUnregister();
    };
  }, []);

  return (
    <AppContext.Provider value={{ state, dispatch }}>
      {children}
    </AppContext.Provider>
  );
};

export const useAppProvider = () => {
  const context = useContext(AppContext);

  if (context == null) {
    throw new Error('useProvider must be used within a Provider');
  }

  const { state, dispatch } = context;

  return { ...state, dispatch, actions: ActionType };
};