// /* eslint-disable @typescript-eslint/ban-ts-comment */

// import { BrowserWindow, app, ipcMain, screen } from 'electron';
// import settings from 'electron-settings';
// import DeskreenApp from './main.dev';
// import initGlobals from './utils/mainProcessHelpers/initGlobals';
// import signalingServer from './server';
// import MenuBuilder from './menu';
// import i18n from './configs/i18next.config';
// import getDeskreenGlobal from './utils/mainProcessHelpers/getDeskreenGlobal';
// import ConnectedDevicesService from './features/ConnectedDevicesService';
// import SharingSessionService from './features/SharingSessionService';
// import RendererWebrtcHelpersService from './features/PeerConnectionHelperRendererService';
// import installExtensions from './utils/installExtensions';

// const sourceMapSupport = require('source-map-support');
// const electronDebug = require('electron-debug');
// const electronDevToolsInstaller = require('electron-devtools-installer');

// const TEST_SIGNALING_SERVER_PORT = '4343';
// const TEST_DISPLAY_ID = 'd1';
// const TEST_DISPLAY_SIZE = { width: 600, height: 400 };
// const TEST_SCREEN_GET_ALL_DISPLAYS_RESULT = [
//   { id: 'd1', size: { width: 600, height: 400 } },
//   { id: 'd2' },
//   { id: 'd3' },
// ];
const testMapSharingSessions = new Map();
testMapSharingSessions.set('1', {
  denyConnectionForPartner: jest.fn(),
  destroy: jest.fn(),
});
testMapSharingSessions.set('2', {
  denyConnectionForPartner: jest.fn(),
  destroy: jest.fn(),
});
const TEST_SHARING_SESSIONS_SERVICE = ({
  waitingForConnectionSharingSession: '2342a',
  sharingSessions: testMapSharingSessions,
} as unknown) as SharingSessionService;
const testMapHelpers = new Map();
testMapHelpers.set('1', { close: jest.fn() });
testMapHelpers.set('2', { close: jest.fn() });
const TEST_RENDERER_WEBRTC_HELPERS_SERVICE = ({
  helpers: testMapHelpers,
} as unknown) as RendererWebrtcHelpersService;
const mockGlobal = {
  connectedDevicesService: TEST_CONNECTED_DEVICES_SERVICE,
  roomIDService: TEST_ROOM_ID_SERVICE,
  sharingSessionService: TEST_SHARING_SESSIONS_SERVICE,
  rendererWebrtcHelpersService: TEST_RENDERER_WEBRTC_HELPERS_SERVICE,
};

jest.useFakeTimers();

jest.mock('./utils/installExtensions');
jest.mock('./utils/AppUpdater');
jest.mock('./main.dev', () => {
  return {
    __esModule: true, // this property makes it work
    default: jest.requireActual('./main.dev').default,
  };
});
jest.mock('./utils/mainProcessHelpers/getDeskreenGlobal');
jest.mock('./utils/mainProcessHelpers/initGlobals');
jest.mock('electron', () => {
  return {
    app: {
      quit: jest.fn(),
      on: jest.fn(),
      getName: jest.fn(),
      getVersion: jest.fn(),
      commandLine: {
        appendSwitch: jest.fn(),
      },
      whenReady: jest
        .fn()
        .mockReturnValue(new Promise((resolve) => resolve(undefined))),
    },
    ipcMain: {
      handle: jest.fn(),
      on: jest.fn(),
    },
    screen: {
      getAllDisplays: jest
        .fn()
        .mockReturnValue(TEST_SCREEN_GET_ALL_DISPLAYS_RESULT),
    },
    BrowserWindow: jest.fn().mockReturnValue({
      loadURL: jest.fn(),
      on: jest.fn(),
      webContents: {
        on: jest.fn(),
        toggleDevTools: jest.fn(),
      },
      minimize: jest.fn(),
      show: jest.fn(),
      focus: jest.fn(),
    }),
  };
});
jest.mock('./server', () => {
  return {
    start: jest.fn(),
    port: TEST_SIGNALING_SERVER_PORT,
  };
});
jest.mock('source-map-support', () => {
  return {
    install: jest.fn(),
  };
});
jest.mock('electron-debug');
jest.mock('electron-devtools-installer', () => {
  return {
    default: jest.fn(),
    REACT_DEVELOPER_TOOLS: 'REACT_DEVELOPER_TOOLS',
    REDUX_DEVTOOLS: 'REDUX_DEVTOOLS',
  };
});
jest.mock('./configs/i18next.config', () => {
  return {
    on: jest.fn(),
    changeLanguage: jest.fn(),
    off: jest.fn(),
    language: 'sv',
  };
});
jest.mock('./menu');
jest.mock('electron-settings', () => {
  return {
    set: jest.fn(),
  };
});

describe('app main.dev tests', () => {
  let testApp: DeskreenApp;

  beforeEach(() => {
    jest.clearAllMocks();
    jest.restoreAllMocks();
    // @ts-ignore
    MenuBuilder.mockClear();
    // @ts-ignore
    installExtensions.mockClear();

    testApp = new DeskreenApp();
  });

  describe('when DeskreenApp created properly', () => {
    describe('when .start() was called', () => {
      it('should call initGlobals', () => {
        testApp.start();

        expect(initGlobals).toBeCalled();
      });

      it('should call signalingServer.start()', () => {
        testApp.start();

        expect(signalingServer.start).toBeCalled();
      });

      it('should call .initElectronAppObject()', () => {
        testApp.initElectronAppObject = jest.fn();

        testApp.start();

        expect(testApp.initElectronAppObject).toBeCalled();
      });

      it('should call .initIpcMain()', () => {
        testApp.initIpcMain = jest.fn();

        testApp.start();

        expect(testApp.initIpcMain).toBeCalled();
      });

      describe('when initElectronAppObject was called', () => {
        it('should set app.on("window-all-closed" listener', () => {
          testApp.initElectronAppObject();

          expect(app.on).toHaveBeenCalledWith(
            'window-all-closed',
            expect.anything()
          );
        });

        it('should call app.commandLine.appendSwitch with "webrtc-max-cpu-consumption-percentage","100"', () => {
          testApp.initElectronAppObject();

          expect(app.commandLine.appendSwitch).toHaveBeenCalledWith(
            'webrtc-max-cpu-consumption-percentage',
            '100'
          );
        });

        describe('when process.env.E2E_BUILD !== "true"', () => {
          it('should set app.on("ready" listener', () => {
            const processEnvBackup = process.env.E2E_BUILD;
            process.env.E2E_BUILD = 'false';

            testApp.initElectronAppObject();

            expect(app.on).toHaveBeenCalledWith('ready', expect.anything());

            process.env.E2E_BUILD = processEnvBackup;
          });
        });

        describe('when process.env.E2E_BUILD === "true"', () => {
          it('should set app.on("ready" listener', () => {
            const processEnvBackup = process.env.E2E_BUILD;
            process.env.E2E_BUILD = 'true';

            testApp.initElectronAppObject();

            expect(app.whenReady).toHaveBeenCalled();

            process.env.E2E_BUILD = processEnvBackup;
          });
        });

        describe('when app.on("window-all-closed" event occured', () => {
          describe('when running on NOT darwin platform', () => {
            it('should call app.quit()', () => {
              const processBackup = process;
              // @ts-ignore
              // eslint-disable-next-line no-global-assign
              process = {
                ...processBackup,
                platform: 'linux',
              };

//               testApp.initElectronAppObject();

//               // @ts-ignore
//               const callback = app.on.mock.calls[0][1];
//               callback();

//               expect(app.quit).toBeCalled();

//               // @ts-ignore
//               // eslint-disable-next-line no-global-assign
//               process = processBackup;
//             });
//           });

//           describe('when running on darwin platform', () => {
//             it('should NOT call app.quit()', () => {
//               const processBackup = process;
//               // @ts-ignore
//               // eslint-disable-next-line no-global-assign
//               process = {
//                 ...processBackup,
//                 platform: 'darwin',
//               };

//               testApp.initElectronAppObject();

//               // @ts-ignore
//               const callback = app.on.mock.calls[0][1];
//               callback();

//               expect(app.quit).not.toBeCalled();

//               // @ts-ignore
//               // eslint-disable-next-line no-global-assign
//               process = processBackup;
//             });
//           });
//         });

//         describe('when app.on("activate" event occured', () => {
//           it('should call .createWindow if mainWindow is null', () => {
//             testApp.mainWindow = null;
//             testApp.createWindow = jest.fn();

//             testApp.initElectronAppObject();

//             // @ts-ignore
//             const callback = app.on.mock.calls[2][1];
//             callback({ preventDefault: () => {} });

//             expect(testApp.createWindow).toBeCalled();
//           });

//           it('should NOT call .createWindow if mainWindow is not null', () => {
//             testApp.mainWindow = ({
//               asdf: 'agasg',
//             } as unknown) as BrowserWindow;
//             testApp.createWindow = jest.fn();

//             testApp.initElectronAppObject();

//             // @ts-ignore
//             const callback = app.on.mock.calls[2][1];
//             callback({ preventDefault: () => {} });

//             expect(testApp.createWindow).not.toBeCalled();
//           });
//         });
//       });

//       describe('when initIpcMain was called', () => {
//         it('should set ipcMain.on("client-changed-language" listener', () => {
//           testApp.initIpcMain();

//           expect(ipcMain.on).toHaveBeenCalledWith(
//             'client-changed-language',
//             expect.anything()
//           );
//         });

//         it('should set ipcMain.handle("get-signaling-server-port" listener', () => {
//           testApp.initIpcMain();

//           expect(ipcMain.handle).toHaveBeenCalledWith(
//             'get-signaling-server-port',
//             expect.anything()
//           );
//         });

//         it('should set ipcMain.handle("get-all-displays" listener', () => {
//           testApp.initIpcMain();

//           expect(ipcMain.handle).toHaveBeenCalledWith(
//             'get-all-displays',
//             expect.anything()
//           );
//         });

//         it('should set ipcMain.handle("get-display-size-by-display-id" listener', () => {
//           testApp.initIpcMain();

//           expect(ipcMain.handle).toHaveBeenCalledWith(
//             'get-display-size-by-display-id',
//             expect.anything()
//           );
//         });

//         it('should set ipcMain.handle("main-window-onbeforeunload" listener', () => {
//           testApp.initIpcMain();

//           expect(ipcMain.handle).toHaveBeenCalledWith(
//             'main-window-onbeforeunload',
//             expect.anything()
//           );
//         });

//         describe('when ipcMain.on("client-changed-language" callback was called', () => {
//           it('should call i18n.changeLanguage and settings.set("appLanguage", newLangCode)', async () => {
//             const testNewLang = 'bz';

//             testApp.initIpcMain();

//             // @ts-ignore
//             const callback = ipcMain.on.mock.calls[0][1];
//             await callback(undefined, testNewLang);

//             expect(i18n.changeLanguage).toHaveBeenCalledWith(testNewLang);
//             expect(settings.set).toHaveBeenCalledWith(
//               'appLanguage',
//               testNewLang
//             );
//           });
//         });

//         describe('when ipcMain.on("get-signaling-server-port" callback was called', () => {
//           describe('when main window is defined', () => {
//             it('should send a signaling server port to main window', () => {
//               testApp.mainWindow = ({
//                 webContents: { send: jest.fn() },
//               } as unknown) as BrowserWindow;

//               testApp.initIpcMain();

//               // @ts-ignore
//               const callback = ipcMain.handle.mock.calls[0][1];
//               callback();

//               expect(testApp.mainWindow.webContents.send).toHaveBeenCalledWith(
//                 'sending-port-from-main',
//                 TEST_SIGNALING_SERVER_PORT
//               );
//             });
//           });
//         });

//         describe('when ipcMain.on("get-all-displays" callback was called', () => {
//           it('should return screen.getAllDisplays() result', () => {
//             testApp.initIpcMain();

//             // @ts-ignore
//             const callback = ipcMain.handle.mock.calls[1][1];
//             const res = callback();

//             expect(res).toBe(TEST_SCREEN_GET_ALL_DISPLAYS_RESULT);
//             expect(screen.getAllDisplays).toBeCalled();
//           });
//         });

//         describe('when ipcMain.on("get-display-size-by-display-id" callback was called', () => {
//           describe('when displayID exists in screen.getAllDisplays() result', () => {
//             it('should return display size as expected', () => {
//               testApp.initIpcMain();

//               // @ts-ignore
//               const callback = ipcMain.handle.mock.calls[2][1];
//               const res = callback(undefined, TEST_DISPLAY_ID);

//               expect(res).toEqual(TEST_DISPLAY_SIZE);
//             });
//           });

//           describe('when displayID NOT exist in screen.getAllDisplays() result', () => {
//             it('should return undefined expected', () => {
//               testApp.initIpcMain();

//               // @ts-ignore
//               const callback = ipcMain.handle.mock.calls[2][1];
//               const res = callback(undefined, 'dagaw22ds');

//               expect(res).toBe(undefined);
//             });
//           });
//         });

//         describe('when ipcMain.on("main-window-onbeforeunload" callback was called', () => {
//           it('should reset globals', () => {
//             // @ts-ignore
//             getDeskreenGlobal.mockReturnValue(mockGlobal);

//             testApp.initIpcMain();

//             // @ts-ignore
//             const callback = ipcMain.handle.mock.calls[3][1];
//             callback();

//             const deskreenGlobal = getDeskreenGlobal();

//             expect(deskreenGlobal.connectedDevicesService).not.toBe(
//               TEST_CONNECTED_DEVICES_SERVICE
//             );
//             expect(deskreenGlobal.roomIDService).not.toBe(TEST_ROOM_ID_SERVICE);
//             testMapSharingSessions.forEach((s) => {
//               expect(s.denyConnectionForPartner).toBeCalled();
//               expect(s.destroy).toBeCalled();
//             });
//             testMapHelpers.forEach((s) => {
//               expect(s.close).toBeCalled();
//             });

//             expect(
//               deskreenGlobal.sharingSessionService
//                 .waitingForConnectionSharingSession
//             ).toBe(null);
//             expect(testMapHelpers.size).toBe(0);
//             expect(testMapSharingSessions.size).toBe(0);
//           });
//         });

//         describe('when createWindow is called', () => {
//           describe('when in dev environment', () => {
//             it('should call installExtensions', async () => {
//               // @ts-ignore
//               // installExtensions = jest.fn();
//               const processEnvNodeEnvBackup = process.env.NODE_ENV;
//               process.env.NODE_ENV = 'development';

//               await testApp.createWindow();

//               expect(installExtensions).toBeCalledTimes(1);

//               process.env.NODE_ENV = processEnvNodeEnvBackup;

//               const processDebugProdBackup = process.env.DEBUG_PROD;
//               process.env.DEBUG_PROD = 'true';

//               await testApp.createWindow();

//               expect(installExtensions).toBeCalledTimes(2);

//               process.env.DEBUG_PROD = processDebugProdBackup;
//             });
//           });

//           describe('when mainWindow is created', () => {
//             it('should call .mainWindow.loadURL with proper parameter', () => {
//               testApp.createWindow();

//               expect(testApp.mainWindow?.loadURL).toHaveBeenCalledWith(
//                 `file://${__dirname}/app.html`
//               );
//             });

//             it('should set .mainWindow.webContents.on("did-finish-load"', () => {
//               testApp.createWindow();

//               expect(testApp.mainWindow?.webContents.on).toHaveBeenCalledWith(
//                 'did-finish-load',
//                 expect.anything()
//               );
//             });

//             describe('when process.env.NODE_ENV === "dev"', () => {
//               it('should call this.mainWindow.webContents.toggleDevTools', () => {
//                 const backProcEnvNodeEnv = process.env.NODE_ENV;
//                 process.env.NODE_ENV = 'dev';

//                 testApp.createWindow();

//                 expect(
//                   testApp.mainWindow?.webContents.toggleDevTools
//                 ).toBeCalled();

//                 process.env.NODE_ENV = backProcEnvNodeEnv;
//               });
//             });

//             describe('when .mainWindow?.webContents.on("did-finish-load" callback called', () => {
//               describe('when mainWindow is not defined', () => {
//                 it('should throw an error', () => {
//                   testApp.createWindow();

//                   const callback =
//                     // @ts-ignore
//                     testApp.mainWindow.webContents.on.mock.calls[0][1];

//                   testApp.mainWindow = null;

//                   try {
//                     callback();
//                     // eslint-disable-next-line jest/no-jasmine-globals
//                     fail();
//                   } catch (e) {
//                     // eslint-disable-next-line jest/no-try-expect
//                     expect(e).toEqual(new Error('"mainWindow" is not defined'));
//                   }
//                 });
//               });

//               describe('when process.env.START_MINIMIZED is defined', () => {
//                 it('should call mainWindow.minimize', () => {
//                   testApp.createWindow();
//                   const backProcessEnvStartMinimized =
//                     process.env.START_MINIMIZED;
//                   process.env.START_MINIMIZED = 'true';

//                   const callback =
//                     // @ts-ignore
//                     testApp.mainWindow.webContents.on.mock.calls[0][1];

//                   callback();

//                   expect(testApp.mainWindow?.minimize).toBeCalled();

//                   process.env.START_MINIMIZED = backProcessEnvStartMinimized;
//                 });
//               });

//               describe('when process.env.START_MINIMIZED is NOT defined', () => {
//                 it('should call mainWindow.show and mainWindow.focus', () => {
//                   testApp.createWindow();
//                   const backProcessEnvStartMinimized =
//                     process.env.START_MINIMIZED;
//                   process.env.START_MINIMIZED = 'false';

//                   const callback =
//                     // @ts-ignore
//                     testApp.mainWindow.webContents.on.mock.calls[0][1];

//                   callback();

//                   expect(testApp.mainWindow?.show).toBeCalled();
//                   expect(testApp.mainWindow?.focus).toBeCalled();

//                   process.env.START_MINIMIZED = backProcessEnvStartMinimized;
//                 });
//               });
//             });

//             describe('when .mainWindow?.on("closed" callback called', () => {
//               it('should set main window to null', () => {
//                 testApp.createWindow();
//                 const callback =
//                   // @ts-ignore
//                   testApp.mainWindow.on.mock.calls[0][1];

//                 callback();

//                 expect(testApp.mainWindow).toBeNull();
//               });
//               describe('when process.platform !== "darwin"', () => {
//                 it('should call app.quit()', () => {
//                   const processBackup = process;
//                   // @ts-ignore
//                   // eslint-disable-next-line no-global-assign
//                   process = {
//                     ...processBackup,
//                     platform: 'linux',
//                   };
//                   testApp.createWindow();

//                   const callback =
//                     // @ts-ignore
//                     testApp.mainWindow.on.mock.calls[0][1];

//                   callback();

//                   expect(app.quit).toBeCalled();

//                   // @ts-ignore
//                   // eslint-disable-next-line no-global-assign
//                   process = processBackup;
//                 });
//               });

//               describe('when process.platform === "darwin"', () => {
//                 it('should call app.quit()', () => {
//                   const processBackup = process;
//                   // @ts-ignore
//                   // eslint-disable-next-line no-global-assign
//                   process = {
//                     ...processBackup,
//                     platform: 'darwin',
//                   };
//                   testApp.createWindow();

//                   const callback =
//                     // @ts-ignore
//                     testApp.mainWindow.on.mock.calls[0][1];

//                   callback();

//                   expect(app.quit).not.toBeCalled();

//                   // @ts-ignore
//                   // eslint-disable-next-line no-global-assign
//                   process = processBackup;
//                 });
//               });
//             });
//           });
//         });
//       });

//       describe('when process.env.NODE_ENV === "production"', () => {
//         it('should call sourceMapSupport to be called when ', () => {
//           const envNodeEnvBackup = process.env.NODE_ENV;
//           process.env.NODE_ENV = 'production';

//           testApp.start();

//           expect(sourceMapSupport.install).toBeCalled();

//           process.env.NODE_ENV = envNodeEnvBackup;
//         });
//       });

//       describe('when process.env.NODE_ENV === "development"', () => {
//         it('should call electron-debug ', () => {
//           const envNodeEnvBackup = process.env.NODE_ENV;
//           process.env.NODE_ENV = 'development';

//           testApp.start();

//           expect(electronDebug).toBeCalled();

//           process.env.NODE_ENV = envNodeEnvBackup;
//         });
//       });

//       describe('when process.env.DEBUG_PROD === "true"', () => {
//         it('should call electron-debug ', () => {
//           const envDebugProdBackup = process.env.DEBUG_PROD;
//           process.env.DEBUG_PROD = 'true';

//           testApp.start();

//           expect(electronDebug).toBeCalled();

//           process.env.DEBUG_PROD = envDebugProdBackup;
//         });
//       });
//     });

//     describe('when .initI18n() was called', () => {
//       it('should init i18n object with .on("loaded" event', () => {
//         testApp.initI18n();

//         expect(i18n.on).toBeCalledWith('loaded', expect.anything());
//       });

//       it('should init i18n object with .on("languageChanged" event', () => {
//         testApp.initI18n();

//         expect(i18n.on).toBeCalledWith('languageChanged', expect.anything());
//       });

//       describe('when "loaded" event occured', () => {
//         it('should call changleLanguage("en") and i18n.off("loaded"', () => {
//           testApp.initI18n();
//           // @ts-ignore
//           const callback = i18n.on.mock.calls[0][1];

//           callback();

//           expect(i18n.changeLanguage).toBeCalledWith('en');
//           expect(i18n.off).toBeCalledWith('loaded');
//         });
//       });

//       describe('when "languageChanged" event occured', () => {
//         describe('when mainWindow is defined', () => {
//           it('should create new MenuBuilder', () => {
//             testApp.mainWindow = ({} as unknown) as BrowserWindow;
//             testApp.initI18n();
//             // @ts-ignore
//             const callback = i18n.on.mock.calls[1][1];

//             callback();

//             expect(MenuBuilder).toHaveBeenCalledTimes(1);
//             expect(MenuBuilder).toHaveBeenCalledWith(testApp.mainWindow, i18n);
//           });

//           it('should call .buildMenu() of menuBuilder', () => {
//             testApp.mainWindow = ({} as unknown) as BrowserWindow;
//             testApp.initI18n();
//             // @ts-ignore
//             const callback = i18n.on.mock.calls[1][1];

//             callback();

//             // @ts-ignore
//             const mockMenuBuilderInstance = MenuBuilder.mock.instances[0];

//             expect(mockMenuBuilderInstance.buildMenu).toBeCalled();
//           });

//           it('should call setTimeout with callback and delay', () => {
//             testApp.mainWindow = ({} as unknown) as BrowserWindow;
//             testApp.initI18n();
//             // @ts-ignore
//             const callback = i18n.on.mock.calls[1][1];

//             callback();

//             expect(setTimeout).toHaveBeenCalledWith(expect.anything(), 400);
//           });

//           describe('when setTimeout callback triggered after delay', () => {
//             describe('when should really change app lang', () => {
//               it('should call i18n.changeLanguage with passed language', () => {
//                 const testLng = 'bg';
//                 testApp.mainWindow = ({} as unknown) as BrowserWindow;
//                 testApp.initI18n();
//                 // @ts-ignore
//                 const callback = i18n.on.mock.calls[1][1];
//                 callback(testLng);
//                 // @ts-ignore
//                 const timeoutCallback = setTimeout.mock.calls[0][0];

//                 timeoutCallback();

//                 expect(i18n.changeLanguage).toHaveBeenCalledWith(testLng);
//               });

//               it('should set "appLanguage" in electron-settings', async () => {
//                 const testLng = 'bg';
//                 testApp.mainWindow = ({} as unknown) as BrowserWindow;
//                 testApp.initI18n();
//                 // @ts-ignore
//                 const callback = i18n.on.mock.calls[1][1];
//                 callback(testLng);
//                 // @ts-ignore
//                 const timeoutCallback = setTimeout.mock.calls[0][0];

//                 await timeoutCallback();

//                 expect(settings.set).toHaveBeenCalledWith(
//                   'appLanguage',
//                   testLng
//                 );
//               });
//             });
//           });
//         });
//       });
//     });
//   });

//   describe('when installExtensions was called', () => {
//     it('should call electron-devtools-installer with "REACT_DEVELOPER_TOOLS" and "REDUX_DEVTOOLS"', async () => {
//       // @ts-ignore
//       installExtensions.mockImplementation(
//         jest.requireActual('./utils/installExtensions').default
//       );

//       await installExtensions();

//       expect(electronDevToolsInstaller.default).toBeCalledWith(
//         'REDUX_DEVTOOLS',
//         !!process.env.UPGRADE_EXTENSIONS
//       );
//       expect(electronDevToolsInstaller.default).toBeCalledWith(
//         'REACT_DEVELOPER_TOOLS',
//         !!process.env.UPGRADE_EXTENSIONS
//       );
//     });
//   });
// });