/**
 * Copyright 2017 Google Inc. All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import {BrowserLog} from '../browser-log';
import type {LogLevel} from '../log-level';
import {assert} from './assert';
import type {OnLog, Page} from './BrowserPage';
import {PageEmittedEvents} from './BrowserPage';
import type {BrowserRunner} from './BrowserRunner';
import {makeBrowserRunner} from './BrowserRunner';
import type {Connection} from './Connection';
import type {DevtoolsTargetCreatedEvent} from './devtools-types';
import {EventEmitter} from './EventEmitter';
import type {Viewport} from './PuppeteerViewport';
import type {SourceMapGetter} from './source-map-getter';
import {Target} from './Target';
import {waitWithTimeout} from './util';

interface WaitForTargetOptions {
	timeout?: number;
}

export const enum BrowserEmittedEvents {
	TargetChanged = 'targetchanged',
	TargetCreated = 'targetcreated',
	Closed = 'closed',
	ClosedSilent = 'closed-silent',
}

export class HeadlessBrowser extends EventEmitter {
	static async create({
		defaultViewport,
		timeout,
		userDataDir,
		args,
		executablePath,
		logLevel,
		indent,
	}: {
		defaultViewport: Viewport;
		timeout: number;
		userDataDir: string;
		args: string[];
		executablePath: string;
		logLevel: LogLevel;
		indent: boolean;
	}): Promise<HeadlessBrowser> {
		const runner = await makeBrowserRunner({
			executablePath,
			processArguments: args,
			userDataDir,
			indent,
			logLevel,
			timeout,
		});

		const browser = new HeadlessBrowser({
			connection: runner.connection,
			defaultViewport,
			runner,
		});
		await runner.connection.send('Target.setDiscoverTargets', {discover: true});
		return browser;
	}

	#defaultViewport: Viewport;
	connection: Connection;
	#defaultContext: BrowserContext;
	#contexts: Map<string, BrowserContext>;
	#targets: Map<string, Target>;
	id: string;

	runner: BrowserRunner;

	get _targets(): Map<string, Target> {
		return this.#targets;
	}

	constructor({
		connection,
		defaultViewport,
		runner,
	}: {
		connection: Connection;
		defaultViewport: Viewport;
		runner: BrowserRunner;
	}) {
		super();
		this.#defaultViewport = defaultViewport;
		this.connection = connection;

		this.id = Math.random().toString(36).substring(2, 15);

		this.#defaultContext = new BrowserContext(this);
		this.#contexts = new Map();

		this.#targets = new Map();
		this.connection.on('Target.targetCreated', this.#targetCreated.bind(this));
		this.connection.on(
			'Target.targetDestroyed',
			this.#targetDestroyed.bind(this),
		);
		this.connection.on(
			'Target.targetInfoChanged',
			this.#targetInfoChanged.bind(this),
		);
		this.runner = runner;
	}

	browserContexts(): BrowserContext[] {
		return [this.#defaultContext, ...Array.from(this.#contexts.values())];
	}

	async #targetCreated(event: DevtoolsTargetCreatedEvent): Promise<void> {
		const {targetInfo} = event;
		const {browserContextId} = targetInfo;
		const context =
			browserContextId && this.#contexts.has(browserContextId)
				? this.#contexts.get(browserContextId)
				: this.#defaultContext;

		if (!context) {
			throw new Error('Missing browser context');
		}

		const target = new Target(
			targetInfo,
			context,
			() => {
				return this.connection.createSession(targetInfo);
			},
			this.#defaultViewport ?? null,
		);
		assert(
			!this.#targets.has(event.targetInfo.targetId),
			'Target should not exist before targetCreated',
		);
		this.#targets.set(event.targetInfo.targetId, target);

		if (await target._initializedPromise) {
			this.emit(BrowserEmittedEvents.TargetCreated, target);
		}
	}

	#targetDestroyed(event: {targetId: string}): void {
		const target = this.#targets.get(event.targetId);
		if (!target) {
			throw new Error(
				`Missing target in _targetDestroyed (id = ${event.targetId})`,
			);
		}

		target._initializedCallback(false);
		this.#targets.delete(event.targetId);
		target._closedCallback();
	}

	#targetInfoChanged(event: DevtoolsTargetCreatedEvent): void {
		const target = this.#targets.get(event.targetInfo.targetId);
		if (!target) {
			throw new Error(
				`Missing target in targetInfoChanged (id = ${event.targetInfo.targetId})`,
			);
		}

		const previousURL = target.url();
		const wasInitialized = target._isInitialized;
		target._targetInfoChanged(event.targetInfo);
		if (wasInitialized && previousURL !== target.url()) {
			this.emit(BrowserEmittedEvents.TargetChanged, target);
		}
	}

	newPage({
		context,
		logLevel,
		indent,
		pageIndex,
		onBrowserLog,
		onLog,
	}: {
		context: SourceMapGetter;
		logLevel: LogLevel;
		indent: boolean;
		pageIndex: number;
		onBrowserLog: null | ((log: BrowserLog) => void);
		onLog: OnLog;
	}): Promise<Page> {
		return this.#defaultContext.newPage({
			context,
			logLevel,
			indent,
			pageIndex,
			onBrowserLog,
			onLog,
		});
	}

	async _createPageInContext({
		context,
		logLevel,
		indent,
		pageIndex,
		onBrowserLog,
		onLog,
	}: {
		context: SourceMapGetter;
		logLevel: LogLevel;
		indent: boolean;
		pageIndex: number;
		onBrowserLog: null | ((log: BrowserLog) => void);
		onLog: OnLog;
	}): Promise<Page> {
		const {
			value: {targetId},
		} = await this.connection.send('Target.createTarget', {
			url: 'about:blank',
			browserContextId: undefined,
		});
		const target = this.#targets.get(targetId);
		if (!target) {
			throw new Error(`Missing target for page (id = ${targetId})`);
		}

		const initialized = await target._initializedPromise;
		if (!initialized) {
			throw new Error(`Failed to create target for page (id = ${targetId})`);
		}

		const page = await target.page({
			sourceMapGetter: context,
			logLevel,
			indent,
			pageIndex,
			onBrowserLog,
			onLog,
		});
		if (!page) {
			throw new Error(`Failed to create a page for context`);
		}

		return page;
	}

	targets(): Target[] {
		return Array.from(this.#targets.values()).filter((target) => {
			return target._isInitialized;
		});
	}

	async waitForTarget(
		predicate: (x: Target) => boolean | Promise<boolean>,
		options: WaitForTargetOptions = {},
	): Promise<Target> {
		const {timeout = 30000} = options;
		let resolve: (value: Target | PromiseLike<Target>) => void;
		let isResolved = false;
		const targetPromise = new Promise<Target>((x) => {
			resolve = x;
		});
		this.on(BrowserEmittedEvents.TargetCreated, check);
		this.on(BrowserEmittedEvents.TargetChanged, check);
		try {
			if (!timeout) {
				return await targetPromise;
			}

			this.targets().forEach(check);
			return await waitWithTimeout(targetPromise, 'target', timeout, this);
		} finally {
			this.off(BrowserEmittedEvents.TargetCreated, check);
			this.off(BrowserEmittedEvents.TargetChanged, check);
		}

		async function check(target: Target): Promise<void> {
			if ((await predicate(target)) && !isResolved) {
				isResolved = true;
				resolve(target);
			}
		}
	}

	async pages(): Promise<Page[]> {
		const contextPages = await Promise.all(
			this.browserContexts().map((context) => {
				return context.pages();
			}),
		);
		// Flatten array.
		return contextPages.reduce((acc, x) => {
			return acc.concat(x);
		}, []);
	}

	async close({silent}: {silent: boolean}): Promise<void> {
		await this.runner.closeProcess();
		(await this.pages()).forEach((page) => {
			page.emit(PageEmittedEvents.Disposed);
			page.closed = true;
		});
		this.disconnect();
		this.emit(
			silent ? BrowserEmittedEvents.ClosedSilent : BrowserEmittedEvents.Closed,
		);
	}

	disconnect(): void {
		this.connection.dispose();
	}
}

export class BrowserContext extends EventEmitter {
	#browser: HeadlessBrowser;

	constructor(browser: HeadlessBrowser) {
		super();
		this.#browser = browser;
	}

	targets(): Target[] {
		return this.#browser.targets().filter((target) => {
			return target.browserContext() === this;
		});
	}

	waitForTarget(
		predicate: (x: Target) => boolean | Promise<boolean>,
		options: {timeout?: number} = {},
	): Promise<Target> {
		return this.#browser.waitForTarget((target) => {
			return target.browserContext() === this && predicate(target);
		}, options);
	}

	async pages(): Promise<Page[]> {
		const pages = await Promise.all(
			this.targets()
				.filter((target) => target.type() === 'page')
				.map((target) => target.expectPage()),
		);
		return pages.filter((page): page is Page => {
			return Boolean(page);
		});
	}

	newPage({
		context,
		logLevel,
		indent,
		pageIndex,
		onBrowserLog,
		onLog,
	}: {
		context: SourceMapGetter;
		logLevel: LogLevel;
		indent: boolean;
		pageIndex: number;
		onBrowserLog: null | ((log: BrowserLog) => void);
		onLog: OnLog;
	}): Promise<Page> {
		return this.#browser._createPageInContext({
			context,
			logLevel,
			indent,
			pageIndex,
			onBrowserLog,
			onLog,
		});
	}

	browser(): HeadlessBrowser {
		return this.#browser;
	}
}