/**

 * Copyright (c) Meta Platforms, Inc. and affiliates.

 *

 * This source code is licensed under the MIT license found in the

 * LICENSE file in the root directory of this source tree.

 *

 * @flow

 */

import {CustomConsole} from '@jest/console';

import type {

  BackendBridge,

  FrontendBridge,

} from 'react-devtools-shared/src/bridge';

// Argument is serialized when passed from jest-cli script through to setupTests.

const compactConsole = process.env.compactConsole === 'true';

if (compactConsole) {

  const formatter = (type, message) => {

    switch (type) {

      case 'error':

        return '\x1b[31m' + message + '\x1b[0m';

      case 'warn':

        return '\x1b[33m' + message + '\x1b[0m';

      case 'log':

      default:

        return message;

    }

  };

  global.console = new CustomConsole(process.stdout, process.stderr, formatter);

}

beforeEach(() => {

  global.mockClipboardCopy = jest.fn();

  // Test environment doesn't support document methods like execCommand()

  // Also once the backend components below have been required,

  // it's too late for a test to mock the clipboard-js modules.

  jest.mock('clipboard-js', () => ({copy: global.mockClipboardCopy}));

  // These files should be required (and re-required) before each test,

  // rather than imported at the head of the module.

  // That's because we reset modules between tests,

  // which disconnects the DevTool's cache from the current dispatcher ref.

  const Agent = require('react-devtools-shared/src/backend/agent').default;

  const {initBackend} = require('react-devtools-shared/src/backend');

  const Bridge = require('react-devtools-shared/src/bridge').default;

  const Store = require('react-devtools-shared/src/devtools/store').default;

  const {installHook} = require('react-devtools-shared/src/hook');

  const {

    getDefaultComponentFilters,

    setSavedComponentFilters,

  } = require('react-devtools-shared/src/utils');

  // Fake timers let us flush Bridge operations between setup and assertions.

  jest.useFakeTimers();

  // Use utils.js#withErrorsOrWarningsIgnored instead of directly mutating this array.

  global._ignoredErrorOrWarningMessages = [];

  function shouldIgnoreConsoleErrorOrWarn(args) {

    let firstArg = args[0];

    if (

      firstArg !== null &&

      typeof firstArg === 'object' &&

      String(firstArg).indexOf('Error: Uncaught [') === 0

    ) {

      firstArg = String(firstArg);

    } else if (typeof firstArg !== 'string') {

      return false;

    }

    const shouldFilter = global._ignoredErrorOrWarningMessages.some(

      errorOrWarningMessage => {

        return firstArg.indexOf(errorOrWarningMessage) !== -1;

      },

    );

    return shouldFilter;

  }

  const originalConsoleError = console.error;

  console.error = (...args) => {

    const firstArg = args[0];

    if (

      firstArg === 'Warning: React instrumentation encountered an error: %s'

    ) {

      // Rethrow errors from React.

      throw args[1];

    } else if (

      typeof firstArg === 'string' &&

      (firstArg.startsWith(

        "Warning: It looks like you're using the wrong act()",

      ) ||

        firstArg.startsWith(

          'Warning: The current testing environment is not configured to support act',

        ) ||

        firstArg.startsWith(

          'Warning: You seem to have overlapping act() calls',

        ))

    ) {

      // DevTools intentionally wraps updates with acts from both DOM and test-renderer,

      // since test updates are expected to impact both renderers.

      return;

    } else if (shouldIgnoreConsoleErrorOrWarn(args)) {

      // Allows testing how DevTools behaves when it encounters console.error without cluttering the test output.

      // Errors can be ignored by running in a special context provided by utils.js#withErrorsOrWarningsIgnored

      return;

    }

    originalConsoleError.apply(console, args);

  };

  const originalConsoleWarn = console.warn;

  console.warn = (...args) => {

    if (shouldIgnoreConsoleErrorOrWarn(args)) {

      // Allows testing how DevTools behaves when it encounters console.warn without cluttering the test output.

      // Warnings can be ignored by running in a special context provided by utils.js#withErrorsOrWarningsIgnored

      return;

    }

    originalConsoleWarn.apply(console, args);

  };

  // Initialize filters to a known good state.

  setSavedComponentFilters(getDefaultComponentFilters());

  global.__REACT_DEVTOOLS_COMPONENT_FILTERS__ = getDefaultComponentFilters();

  // Also initialize inline warnings so that we can test them.

  global.__REACT_DEVTOOLS_SHOW_INLINE_WARNINGS_AND_ERRORS__ = true;

  installHook(global);

  const bridgeListeners = [];

  const bridge = new Bridge({

    listen(callback) {

      bridgeListeners.push(callback);

      return () => {

        const index = bridgeListeners.indexOf(callback);

        if (index >= 0) {

          bridgeListeners.splice(index, 1);

        }

      };

    },

    send(event: string, payload: any, transferable?: Array<any>) {

      bridgeListeners.forEach(callback => callback({event, payload}));

    },

  });

  const agent = new Agent(((bridge: any): BackendBridge));

  const hook = global.__REACT_DEVTOOLS_GLOBAL_HOOK__;

  initBackend(hook, agent, global);

  const store = new Store(((bridge: any): FrontendBridge));

  global.agent = agent;

  global.bridge = bridge;

  global.store = store;

  const readFileSync = require('fs').readFileSync;

  async function mockFetch(url) {

    return {

      ok: true,

      status: 200,

      text: async () => readFileSync(__dirname + url, 'utf-8'),

    };

  }

  global.fetch = mockFetch;

});

afterEach(() => {

  delete global.__REACT_DEVTOOLS_GLOBAL_HOOK__;

  // It's important to reset modules between test runs;

  // Without this, ReactDOM won't re-inject itself into the new hook.

  // It's also important to reset after tests, rather than before,

  // so that we don't disconnect the ReactCurrentDispatcher ref.

  jest.resetModules();

});