export const fetchInstalledApps: Middleware = (store: MiddlewareAPI<AppState>) => (next: Dispatch<AppState>) => (action: AppAction) =>
{
    const result = next(action);

    if (action.type === "REQUEST_INSTALLED_APPS")
    {
        store.dispatch(requestRegisteredApps());
        store.dispatch(requestSystemApps());
    }

    return result;
};

    async function fetchLatestVersion(store: MiddlewareAPI<AppState>, action: RequestLatestVersionAction): Promise<void>
    {
        const app = store.getState().installedApps.apps.find(_ => _.id === action.payload.appId);

        if (!app) return;

        const versionProvider = appRegistry.loadVersionProvider(app.id);
        const versionProviderAdapter = VersionProviderFactory.create(versionProvider);

        const latestVersion = await versionProviderAdapter.getVersion();        
        const isOutdated = new VersionComparer(app.installedVersion).isLesserThan(latestVersion);

        store.dispatch(receiveLatestVersion(app.id, latestVersion, isOutdated));     
    }

export const backendMiddleware: Middleware = <AppState>(store: MiddlewareAPI<AppState>) => (next: Dispatch<AppState>) => (originalAction: any) => {
    const result = next(originalAction);
    const action: AppAction = originalAction as any;

    ipcRenderer.send('action', [store.getState(), action]);

    return result
}

    function fetchLatestVersions(store: MiddlewareAPI<AppState>): void
    {
        const state = store.getState();

        state.installedApps.apps
            .filter(_ => _.latestVersion === null)
            .forEach(app => store.dispatch(requestLatestVersion(app.id)));
    }

export const joinRegisteredAppsWithSystemApps: Middleware = (store: MiddlewareAPI<AppState>) => (next: Dispatch<AppState>) => (action: AppAction) =>
{
    const result = next(action);

    if (!(action.type === "RECEIVE_REGISTERED_APPS" || action.type === "RECEIVE_SYSTEM_APPS"))
        return result;

    const state = store.getState();

    if (state.registeredApps.isFetching || state.systemApps.isFetching)
        return result;

    const installedApps = join(state.registeredApps.apps, state.systemApps.apps);

    store.dispatch(receiveInstalledApps(installedApps));

    return result;
};

 return (next: Dispatch) => (action: Action) => {
   const prevState = store.getState()
   const res = next(action)
   const newState = store.getState()
   if (prevState.currentGame !== newState.currentGame) {
     console.log('[Redux auto save middleware] Current game state changed. Triggering save game action.')
     return next(saveGameAction(newState.currentGame))
   }
   return res
 }

 <A extends Action>(action: A) => {
   console.log('will dispatch', action);
   const returnValue = next(action);
   console.log('state after dispatch', api.getState());
   return returnValue;
 };

) => (action: any) => {
  console.log("dispatching", action);
  let result = next(action);
  console.log("next state", store.getState());
  return result;
};

 ) => next => action => {
   api.dispatch({ type: 'INCREMENT' })
   api.dispatch({ type: 'DECREMENT' })
   // typings:expect-error
   api.dispatch({ type: 'UNKNOWN' })
 }

 .then(systemApps => store.dispatch(receiveSystemApps(systemApps)));