// /* eslint-disable @typescript-eslint/ban-ts-comment */
// import { ipcRenderer } from 'electron';
// import PeerConnection from '.';
// import RoomIDService from '../../server/RoomIDService';
// import ConnectedDevicesService from '../ConnectedDevicesService';
// import SharingSessionService from '../SharingSessionService';
// import DesktopCapturerSourcesService from '../DesktopCapturerSourcesService';
// import {
//   TEST_ROOM_ID,
//   TEST_SHARING_SESSION_ID,
//   TEST_USER,
// } from './mocks/testVars';
// import setDisplaySizeFromLocalStream from './handleSetDisplaySizeFromLocalStream';
// import handleSelfDestroy from './handleSelfDestroy';
// import handleRecieveEncryptedMessage from './handleRecieveEncryptedMessage';
// import handleCreatePeer from './handleCreatePeer';
// import { prepare as prepareMessage } from '../../utils/message';
// import getAppLanguage from '../../utils/getAppLanguage';
// import getAppTheme from '../../utils/getAppTheme';

// jest.useFakeTimers();

// jest.mock('simple-peer');
// const TEST_SOURCE_DISPLAY_SIZE = {
//   width: 640,
//   height: 480,
// };
// const TEST_DATA_TO_SEND_IN_ENCRYPTED_MESSAGE = 'oji23oi12p34';
// jest.mock('electron', () => {
//   return {
//     ipcRenderer: {
//       invoke: jest.fn().mockImplementation(() => {
//         return TEST_SOURCE_DISPLAY_SIZE;
//       }),
//     },
//   };
// });
// jest.mock('./handleSetDisplaySizeFromLocalStream');
// jest.mock('./handleSelfDestroy');
// jest.mock('../../utils/message', () => {
//   return {
//     prepare: jest.fn().mockReturnValue({
//       toSend: TEST_DATA_TO_SEND_IN_ENCRYPTED_MESSAGE,
//     }),
//   };
// });
// jest.mock('./handleRecieveEncryptedMessage');
// jest.mock('./handleCreatePeer');

// const TEST_DISPLAY_ID = '21';

// describe('PeerConnection index.ts tests', () => {
//   let peerConnection: PeerConnection;
//   const mockGetSourceDisplayIDBySourceID = jest.fn().mockImplementation(() => {
//     return TEST_DISPLAY_ID;
//   });

//   beforeEach(() => {
//     peerConnection = new PeerConnection(
//       TEST_ROOM_ID,
//       TEST_SHARING_SESSION_ID,
//       TEST_USER,
//       {} as RoomIDService,
//       {} as ConnectedDevicesService,
//       {} as SharingSessionService,
//       ({} as unknown) as DesktopCapturerSourcesService
//     );
//     peerConnection.displayID = 'screen:123idid';
//   });

//   afterEach(() => {
//     jest.clearAllMocks();
//     jest.restoreAllMocks();
//   });

//   describe('when PeerConnection constructor was called', () => {
//     it('should be created with internal properties correclty', () => {
//       expect(peerConnection.roomIDService).toBeDefined();
//       expect(peerConnection.connectedDevicesService).toBeDefined();
//       expect(peerConnection.sharingSessionService).toBeDefined();
//     });

//     describe('when notifyClientWithNewLanguage was called', () => {
//       it('should call sendEncryptedMessage with proper payload', () => {
//         peerConnection.sendEncryptedMessage = jest.fn();

//         peerConnection.notifyClientWithNewLanguage();

//         expect(peerConnection.sendEncryptedMessage).toBeCalledWith({
//           type: 'APP_LANGUAGE',
//           payload: { value: getAppLanguage() },
//         });
//       });
//     });

//     describe('when notifyClientWithNewColorTheme was called', () => {
//       it('should call sendEncryptedMessage with proper payload', () => {
//         peerConnection.sendEncryptedMessage = jest.fn();

//         peerConnection.notifyClientWithNewColorTheme();

//         expect(peerConnection.sendEncryptedMessage).toBeCalledWith({
//           type: 'APP_THEME',
//           payload: { value: getAppTheme() },
//         });
//       });
//     });

//     describe('when setDesktopCapturerSourceID was called', () => {
//       it('should set .desktopCapturerSourceID and call other callbacks', () => {
//         const testSourceID = 'screen:asdfsffs1234';
//         process.env.RUN_MODE = 'dev';
//         peerConnection.setDisplayIDByDesktopCapturerSourceID = jest.fn();
//         peerConnection.handleCreatePeerAfterDesktopCapturerSourceIDWasSet = jest.fn();

//         peerConnection.setDesktopCapturerSourceID(testSourceID);

//         process.env.RUN_MODE = 'test';
//         expect(peerConnection.desktopCapturerSourceID).toBe(testSourceID);
//         expect(
//           peerConnection.setDisplayIDByDesktopCapturerSourceID
//         ).toBeCalled();
//         expect(
//           peerConnection.handleCreatePeerAfterDesktopCapturerSourceIDWasSet
//         ).toBeCalled();
//       });
//     });

//     describe('when setDisplayIDByDesktopCapturerSourceID was called', () => {
//       describe('when desktopCapture source id is screen', () => {
//         it('should set .desktopCapturerSourceID and call other callbacks', () => {
//           peerConnection.desktopCapturerSourceID = 'screen:asdfa2';
//           peerConnection.setDisplaySizeRetreivedFromMainProcess = jest.fn();
//           peerConnection.desktopCapturerSourcesService = ({
//             getSourceDisplayIDBySourceID: mockGetSourceDisplayIDBySourceID,
//           } as unknown) as DesktopCapturerSourcesService;

//           peerConnection.setDisplayIDByDesktopCapturerSourceID();

//           expect(
//             peerConnection.setDisplaySizeRetreivedFromMainProcess
//           ).toBeCalled();
//           expect(mockGetSourceDisplayIDBySourceID).toBeCalled();
//           expect(peerConnection.displayID).toBe(TEST_DISPLAY_ID);
//         });
//       });

//       describe('when desktopCapture source id is window', () => {
//         it('should not set anything', () => {
//           peerConnection.desktopCapturerSourceID = 'window:asdfa2';
//           peerConnection.setDisplaySizeRetreivedFromMainProcess = jest.fn();
//           peerConnection.desktopCapturerSourcesService = ({
//             getSourceDisplayIDBySourceID: mockGetSourceDisplayIDBySourceID,
//           } as unknown) as DesktopCapturerSourcesService;

//           peerConnection.setDisplayIDByDesktopCapturerSourceID();

//           expect(
//             peerConnection.setDisplaySizeRetreivedFromMainProcess
//           ).not.toBeCalled();
//           expect(mockGetSourceDisplayIDBySourceID).not.toBeCalled();
//           expect(peerConnection.displayID).not.toBe(TEST_DISPLAY_ID);
//         });
//       });
//     });

//     describe('when setDisplaySizeRetreivedFromMainProcess was called', () => {
//       it('should call .invoke on ipcRenderer with proper parameters', async () => {
//         await peerConnection.setDisplaySizeRetreivedFromMainProcess();

//         expect(ipcRenderer.invoke).toBeCalledWith(
//           'get-display-size-by-display-id',
//           peerConnection.displayID
//         );
//         expect(peerConnection.sourceDisplaySize).toBe(TEST_SOURCE_DISPLAY_SIZE);
//       });

//       describe('when .invoke returned "undefined"', () => {
//         it('should not set sourceDisplaySize', async () => {
//           // @ts-ignore
//           ipcRenderer.invoke.mockImplementation(() => {
//             return 'undefined';
//           });

//           await peerConnection.setDisplaySizeRetreivedFromMainProcess();

//           expect(ipcRenderer.invoke).toBeCalledWith(
//             'get-display-size-by-display-id',
//             peerConnection.displayID
//           );
//           expect(peerConnection.sourceDisplaySize).not.toBe(
//             TEST_SOURCE_DISPLAY_SIZE
//           );
//         });
//       });
//     });

//     describe('when handleCreatePeerAfterDesktopCapturerSourceIDWasSet was called', () => {
//       describe('when .sourceDisplaySize is defined', () => {
//         it('should call setDisplaySizeFromLocalStream', async () => {
//           peerConnection.createPeer = jest.fn();
//           peerConnection.sourceDisplaySize = TEST_SOURCE_DISPLAY_SIZE;

//           await peerConnection.handleCreatePeerAfterDesktopCapturerSourceIDWasSet();

//           expect(peerConnection.createPeer).toBeCalled();
//           expect(setDisplaySizeFromLocalStream).not.toBeCalled();
//         });
//       });

//       describe('when .sourceDisplaySize is NOT defined', () => {
//         it('should call setDisplaySizeFromLocalStream', async () => {
//           peerConnection.createPeer = jest.fn();

//           await peerConnection.handleCreatePeerAfterDesktopCapturerSourceIDWasSet();

//           expect(peerConnection.createPeer).toBeCalled();
//           expect(setDisplaySizeFromLocalStream).toBeCalled();
//         });
//       });
//     });

//     describe('when setOnDeviceConnectedCallback was called properly', () => {
//       it('should set onDeviceConnectedCallback', () => {
//         // eslint-disable-next-line @typescript-eslint/no-unused-vars
//         const testCallback = (_: Device) => {};
//         peerConnection.setOnDeviceConnectedCallback(testCallback);

//         expect(peerConnection.onDeviceConnectedCallback).toBe(testCallback);
//       });
//     });

//     describe('when denyConnectionForPartner was called properly', () => {
//       it('should call sendEncryptedMessage with proper payload and call .disconnectPartner', async () => {
//         const testPayload = {
//           type: 'DENY_TO_CONNECT',
//           payload: {},
//         };
//         peerConnection.sendEncryptedMessage = jest.fn();
//         peerConnection.disconnectPartner = jest.fn();

//         await peerConnection.denyConnectionForPartner();

//         expect(peerConnection.sendEncryptedMessage).toBeCalledWith(testPayload);
//         expect(peerConnection.disconnectPartner).toBeCalled();
//       });
//     });

//     describe('when sendUserAllowedToConnect was called properly', () => {
//       it('should call sendEncryptedMessage with proper payload', () => {
//         const testPayload = {
//           type: 'ALLOWED_TO_CONNECT',
//           payload: {},
//         };
//         peerConnection.sendEncryptedMessage = jest.fn();

//         peerConnection.sendUserAllowedToConnect();

//         expect(peerConnection.sendEncryptedMessage).toBeCalledWith(testPayload);
//       });
//     });

//     describe('when disconnectByHostMachineUser was called properly', () => {
//       it('should call sendEncryptedMessage with proper payload and call .disconnectPartner and .selfDestroy', async () => {
//         const testPayload = {
//           type: 'DISCONNECT_BY_HOST_MACHINE_USER',
//           payload: {},
//         };
//         peerConnection.sendEncryptedMessage = jest.fn();
//         peerConnection.disconnectPartner = jest.fn();
//         peerConnection.selfDestroy = jest.fn();

//         await peerConnection.disconnectByHostMachineUser();

//         expect(peerConnection.sendEncryptedMessage).toBeCalledWith(testPayload);
//         expect(peerConnection.disconnectPartner).toBeCalled();
//         expect(peerConnection.selfDestroy).toBeCalled();
//       });
//     });

//     describe('when disconnectPartner was called properly', () => {
//       it('should call sendEncryptedMessage with proper payload', () => {
//         const testEmitData = {
//           ip: peerConnection.partnerDeviceDetails.deviceIP,
//         };
//         peerConnection.socket = ({
//           emit: jest.fn(),
//         } as unknown) as SocketIOClient.Socket;

//         peerConnection.disconnectPartner();

//         expect(peerConnection.socket.emit).toBeCalledWith(
//           'DISCONNECT_SOCKET_BY_DEVICE_IP',
//           testEmitData
//         );
//         expect(peerConnection.partnerDeviceDetails).toEqual({});
//       });
//     });

//     describe('when selfDestroy was called', () => {
//       it('should call handleSelfDestroy', () => {
//         peerConnection.selfDestroy();

//         expect(handleSelfDestroy).toBeCalled();
//       });
//     });

//     describe('when emitUserEnter was called', () => {
//       describe('when .socket is defined', () => {
//         it('should call socket emit with proper parameters', () => {
//           const testEmitData = {
//             username: peerConnection.user.username,
//             publicKey: peerConnection.user.publicKey,
//           };
//           peerConnection.socket = ({
//             emit: jest.fn(),
//           } as unknown) as SocketIOClient.Socket;

//           peerConnection.emitUserEnter();

//           expect(peerConnection.socket.emit).toBeCalledWith(
//             'USER_ENTER',
//             testEmitData
//           );
//         });
//       });
//     });

//     describe('when sendEncryptedMessage was called', () => {
//       describe('when it was NOT called properly', () => {
//         it('should not call "prepare" from message.ts if socket is not defined', () => {
//           peerConnection.socket = (undefined as unknown) as SocketIOClient.Socket;

//           peerConnection.sendEncryptedMessage(
//             ({} as unknown) as SendEncryptedMessagePayload
//           );

//           expect(prepareMessage).not.toBeCalled();
//         });

//         it('should not call "prepare" from message.ts if user is not defined', () => {
//           peerConnection.user = (undefined as unknown) as LocalPeerUser;

//           peerConnection.sendEncryptedMessage(
//             ({} as unknown) as SendEncryptedMessagePayload
//           );

//           expect(prepareMessage).not.toBeCalled();
//         });

//         it('should not call "prepare" from message.ts if partner is not defined', () => {
//           peerConnection.partner = (undefined as unknown) as LocalPeerUser;

//           peerConnection.sendEncryptedMessage(
//             ({} as unknown) as SendEncryptedMessagePayload
//           );

//           expect(prepareMessage).not.toBeCalled();
//         });
//       });

//       describe('when it was called properly', () => {
//         it('should call "prepare" from message.ts and .socket.emit(ENCRYPTED_MESSAGE', async () => {
//           const testPayload = ({} as unknown) as SendEncryptedMessagePayload;
//           peerConnection.socket = ({
//             emit: jest.fn(),
//           } as unknown) as SocketIOClient.Socket;
//           peerConnection.partner = TEST_USER;

//           await peerConnection.sendEncryptedMessage(testPayload);

//           expect(prepareMessage).toBeCalledWith(
//             testPayload,
//             TEST_USER,
//             TEST_USER
//           );
//           expect(peerConnection.socket.emit).toBeCalledWith(
//             'ENCRYPTED_MESSAGE',
//             TEST_DATA_TO_SEND_IN_ENCRYPTED_MESSAGE
//           );
//         });
//       });
//     });

//     describe('when receiveEncryptedMessage was called', () => {
//       describe('when peerConnection user is NOT defined', () => {
//         it('should NOT call handleRecieveEncryptedMessage', () => {
//           const testPayload = {} as ReceiveEncryptedMessagePayload;
//           peerConnection.user = (undefined as unknown) as LocalPeerUser;

//           peerConnection.receiveEncryptedMessage(testPayload);

//           expect(handleRecieveEncryptedMessage).not.toBeCalled();
//         });
//       });

//       describe('when peerConnection user is defined', () => {
//         it('should call handleRecieveEncryptedMessage', () => {
//           const testPayload = {} as ReceiveEncryptedMessagePayload;

//           peerConnection.receiveEncryptedMessage(testPayload);

//           expect(handleRecieveEncryptedMessage).toBeCalled();
//         });
//       });
//     });

//     describe('when callPeer was called', () => {
//       describe('when it was called when call already started', () => {
//         it('should NOT call .sendEncryptedMessage', () => {
//           process.env.RUN_MODE = 'dev';
//           peerConnection.isCallStarted = true;
//           peerConnection.sendEncryptedMessage = jest.fn();
//           peerConnection.signalsDataToCallUser = ['asdfasdf'];

//           peerConnection.callPeer();

//           process.env.RUN_MODE = 'test';
//           expect(peerConnection.sendEncryptedMessage).not.toBeCalled();
//         });
//       });

//       describe('when it was called when call NOT started', () => {
//         it('should call .sendEncryptedMessage', () => {
//           process.env.RUN_MODE = 'dev';
//           peerConnection.sendEncryptedMessage = jest.fn();
//           peerConnection.signalsDataToCallUser = ['asdfasdf'];

//           peerConnection.callPeer();

//           process.env.RUN_MODE = 'test';
//           expect(peerConnection.sendEncryptedMessage).toBeCalled();
//         });
//       });
//     });

//     describe('when createPeer was called', () => {
//       it('should call handleCreatePeer callback', () => {
//         peerConnection.createPeer();

//         expect(handleCreatePeer).toBeCalled();
//       });
//     });
//   });
// });