/**
 * @license
 * Copyright 2018 Google Inc.
 * SPDX-License-Identifier: Apache-2.0
 */
import type {Protocol} from 'devtools-protocol';

import {CDPSessionEvent, type CDPSession} from '../api/CDPSession.js';
import type {HTTPRequest} from '../api/HTTPRequest.js';
import type {Realm} from '../api/Realm.js';
import {TargetType} from '../api/Target.js';
import {
  WebWorker,
  WebWorkerEvent,
  type WebWorkerEvents,
} from '../api/WebWorker.js';
import type {Logger} from '../common/Debug.js';
import {DEBUG_PREFIXES} from '../common/Debug.js';
import {TargetCloseError} from '../common/Errors.js';
import {EventEmitter} from '../common/EventEmitter.js';
import {NetworkManagerEvent} from '../common/NetworkManagerEvents.js';
import {TimeoutSettings} from '../common/TimeoutSettings.js';
import type {EvaluateFunc, HandleFor} from '../index-browser.js';
import {Deferred} from '../util/Deferred.js';

import {ExecutionContext} from './ExecutionContext.js';
import {IsolatedWorld} from './IsolatedWorld.js';
import {MAIN_WORLD} from './IsolatedWorlds.js';
import {releaseObject} from './JSHandle.js';
import {NetworkManager} from './NetworkManager.js';
import type {CdpTarget} from './Target.js';
import {createConsoleMessage, createRemoteException} from './utils.js';

/**
 * @internal
 */
export type ExceptionThrownCallback = (
  event: Protocol.Runtime.ExceptionThrownEvent,
) => void;

/**
 * @internal
 */
export class CdpWebWorker extends WebWorker {
  #world: IsolatedWorld;
  #client: CDPSession;
  readonly #id: string;
  readonly #targetType: TargetType;
  #logger: Logger;
  #hasOwnerExceptionListeners: () => boolean;
  readonly #emitter: EventEmitter<WebWorkerEvents>;
  #workerLoaded = new Deferred<void>();

  get internalEmitter(): EventEmitter<WebWorkerEvents> {
    return this.#emitter;
  }

  constructor(
    client: CDPSession,
    target: CdpTarget,
    exceptionThrown: ExceptionThrownCallback,
    logger: Logger,
    networkManager?: NetworkManager,
    hasOwnerExceptionListeners: () => boolean = () => {
      return false;
    },
  ) {
    super(target.url());
    this.#id = target._targetId;
    this.#client = client;
    this.#logger = logger;
    this.#hasOwnerExceptionListeners = hasOwnerExceptionListeners;
    this.#targetType = target.type();
    this.#world = new IsolatedWorld(
      this,
      new TimeoutSettings(),
      MAIN_WORLD,
      logger,
    );
    this.#emitter = new EventEmitter<WebWorkerEvents>(undefined, logger);

    this.#client.once('Runtime.executionContextCreated', async event => {
      this.#world.setContext(
        new ExecutionContext(client, event.context, this.#world, logger),
      );
    });
    this.#client.once('Inspector.workerScriptLoaded', () => {
      this.#workerLoaded.resolve();
    });

    this.#world.emitter.on('consoleapicalled', async event => {
      try {
        const values = event.args.map(arg => {
          return this.#world.createCdpHandle(arg);
        });

        const noInternalListeners =
          this.#emitter.listenerCount(WebWorkerEvent.Console) === 0;
        const noWorkerListeners =
          this.listenerCount(WebWorkerEvent.Console) === 0;

        if (noInternalListeners && noWorkerListeners) {
          // eslint-disable-next-line max-len -- The comment is long.
          // eslint-disable-next-line @puppeteer/use-using -- These are not owned by this function.
          for (const value of values) {
            void value.dispose().catch((err: Error) => {
              return this.#logger?.(DEBUG_PREFIXES.error)?.(err);
            });
          }
          return;
        }

        const consoleMessages = createConsoleMessage(
          event,
          values,
          this.#id,
          undefined,
          this,
        );
        this.#emitter.emit(WebWorkerEvent.Console, consoleMessages);
        if (!noWorkerListeners) {
          this.emit(WebWorkerEvent.Console, consoleMessages);
        }
      } catch (err) {
        this.#logger?.(DEBUG_PREFIXES.error)?.(err);
      }
    });
    this.#client.on('Runtime.exceptionThrown', event => {
      exceptionThrown(event);
      this.#onException(event);
    });
    this.#client.once(CDPSessionEvent.Disconnected, () => {
      // The worker might be destroyed before its script loads (e.g. a 404
      // script), in which case `Inspector.workerScriptLoaded` never fires.
      this.#workerLoaded.reject(
        new TargetCloseError(
          'Worker was closed before its script finished loading',
        ),
      );
      this.#world.dispose();
    });

    const netManager =
      networkManager ?? this.#createOwnNetworkManager(target, logger);
    // This might fail if the target is closed before we receive all execution contexts.
    netManager.addClient(this.#client).catch((err: Error) => {
      return this.#logger?.(DEBUG_PREFIXES.error)?.(err);
    });
    // Must run after addClient(): addClient() synchronously registers the
    // manager's Disconnected listener, which emits RequestFailed for pending
    // requests (NetworkManager#removeClient). #forwardNetworkEvents()
    // registers a later Disconnected listener that stops forwarding, so the
    // opposite order would drop those RequestFailed events.
    this.#forwardNetworkEvents(netManager);
    this.#client.send('Runtime.enable').catch((err: Error) => {
      return this.#logger?.(DEBUG_PREFIXES.error)?.(err);
    });
  }

  /**
   * Network manager for workers that are not owned by a page (service and
   * shared workers). It only tracks this worker's session.
   */
  #createOwnNetworkManager(target: CdpTarget, logger: Logger): NetworkManager {
    return new NetworkManager(
      {
        frame: () => {
          return null;
        },
        worker: client => {
          return client === this.#client ? this : null;
        },
        browser: () => {
          return target.browser();
        },
      },
      target.browser().isNetworkEnabled(),
      logger,
    );
  }

  /**
   * Utility method to check if the request is owned by the current WebWorker
   */
  #isOwn(request: HTTPRequest): boolean {
    return request.worker() === this;
  }

  /**
   * Re-emits network events that belong to this worker. The network manager
   * may be shared with a page (dedicated workers), so events are filtered by
   * `request.worker()`.
   */
  #forwardNetworkEvents(networkManager: NetworkManager): void {
    const emitter = new EventEmitter(networkManager);
    emitter.on(NetworkManagerEvent.Request, request => {
      if (this.#isOwn(request)) {
        this.emit(WebWorkerEvent.Request, request);
      }
    });
    emitter.on(NetworkManagerEvent.RequestServedFromCache, request => {
      if (this.#isOwn(request)) {
        this.emit(WebWorkerEvent.RequestServedFromCache, request);
      }
    });
    emitter.on(NetworkManagerEvent.Response, response => {
      if (this.#isOwn(response.request())) {
        this.emit(WebWorkerEvent.Response, response);
      }
    });
    emitter.on(NetworkManagerEvent.RequestFailed, request => {
      if (this.#isOwn(request)) {
        this.emit(WebWorkerEvent.RequestFailed, request);
      }
    });
    emitter.on(NetworkManagerEvent.RequestFinished, request => {
      if (this.#isOwn(request)) {
        this.emit(WebWorkerEvent.RequestFinished, request);
      }
    });
    this.#client.once(CDPSessionEvent.Disconnected, () => {
      emitter.removeAllListeners();
    });
  }

  #onException(event: Protocol.Runtime.ExceptionThrownEvent): void {
    const details = event.exceptionDetails;
    if (
      this.listenerCount(WebWorkerEvent.Exception) === 0 &&
      !this.#hasOwnerExceptionListeners()
    ) {
      // Nobody can use a handle, but the browser keeps the exception alive
      // until it is released.
      if (details.exception) {
        void releaseObject(this.#client, details.exception, this.#logger);
      }
      return;
    }
    // Disposed when this scope ends, i.e. right after dispatch. This is a no-op
    // if a listener called `move()` on the handle.
    using handle = details.exception?.objectId
      ? this.#world.createCdpHandle(details.exception)
      : undefined;
    const exception = createRemoteException(details, handle);
    // Emitted internally first so that the page can forward it before the
    // handle is disposed.
    this.#emitter.emit(WebWorkerEvent.Exception, exception);
    this.emit(WebWorkerEvent.Exception, exception);
  }

  mainRealm(): Realm {
    return this.#world;
  }

  get client(): CDPSession {
    return this.#client;
  }

  override async close(): Promise<void> {
    switch (this.#targetType) {
      case TargetType.SERVICE_WORKER: {
        // For service workers we need to close the target and detach to allow
        // the worker to stop.
        await this.client.connection()?.send('Target.closeTarget', {
          targetId: this.#id,
        });
        await this.client.connection()?.send('Target.detachFromTarget', {
          sessionId: this.client.id(),
        });
        break;
      }
      case TargetType.SHARED_WORKER: {
        await this.client.connection()?.send('Target.closeTarget', {
          targetId: this.#id,
        });
        break;
      }
      default:
        // Dedicated workers do not support `Target.closeTarget`. Evaluate on
        // the realm directly so that closing does not wait for the worker
        // script to load.
        await this.#world.evaluate(() => {
          self.close();
        });
    }
  }

  override async evaluate<
    Params extends unknown[],
    Func extends EvaluateFunc<Params> = EvaluateFunc<Params>,
  >(func: Func | string, ...args: Params): Promise<Awaited<ReturnType<Func>>> {
    await this.#workerLoaded.valueOrThrow();
    return await super.evaluate(func, ...args);
  }

  override async evaluateHandle<
    Params extends unknown[],
    Func extends EvaluateFunc<Params> = EvaluateFunc<Params>,
  >(
    func: Func | string,
    ...args: Params
  ): Promise<HandleFor<Awaited<ReturnType<Func>>>> {
    await this.#workerLoaded.valueOrThrow();
    return await super.evaluateHandle(func, ...args);
  }
}
