import Row from './row.ts';
import { FileType } from './filetype/mod.ts';
import { arrayInsert } from './fns.ts';
import Option, { None, Some } from './option.ts';
import { getRuntime, logWarning } from './runtime/mod.ts';
import { Position, SearchDirection } from './types.ts';

export class Document {
	/**
	 * Each line of the current document
	 */
	#rows: Row[] = [];

	/**
	 * @param dirty - Has the document been modified?
	 * @param type - The meta-data for the file type of the current document
	 */
	private constructor(
		public dirty: boolean = false,
		public type: FileType = FileType.default(),
	) {
	}

	public get fileType(): string {
		return this.type.name;
	}

	public get numRows(): number {
		return this.#rows.length;
	}

	public static default(): Document {
		return new Document();
	}

	public isEmpty(): boolean {
		return this.#rows.length === 0;
	}

	/**
	 * Open a file for editing
	 */
	public async open(filename: string): Promise<Document> {
		const { file } = await getRuntime();

		// Clear any existing rows
		if (!this.isEmpty()) {
			this.#rows = [];
		}

		this.type = FileType.from(filename);

		const rawFile = await file.openFile(filename);
		rawFile.split(/\r?\n/)
			.forEach((row) => {
				this.#rows.push(Row.from(row));
			});

		this.dirty = false;

		return this;
	}

	/**
	 * Save the current document
	 */
	public async save(filename: string): Promise<void> {
		const { file } = await getRuntime();

		await file.saveFile(filename, this.rowsToString());
		this.type = FileType.from(filename);

		this.dirty = false;
	}

	/**
	 * Find the cursor position of the query, if it exists
	 *
	 * @param q - the search query
	 * @param at - the point from which to start the search
	 * @param direction - which direction to search, backward or forward
	 */
	public find(
		q: string,
		at: Position,
		direction: SearchDirection,
	): Option<Position> {
		if (at.y >= this.numRows) {
			logWarning('Trying to search beyond the end of the current file', {
				at,
				document: this,
			});
			return None;
		}

		const position = Position.from(at);

		for (let y = at.y; y >= 0 && y < this.numRows; y += direction) {
			const maybeMatch = this.#rows[y].find(q, position.x, direction);
			if (maybeMatch.isSome()) {
				position.x = maybeMatch.unwrap();
				return Some(position);
			}

			if (direction === SearchDirection.Forward) {
				position.y += 1;
				position.x = 0;
			} else if (direction === SearchDirection.Backward) {
				position.y -= 1;
				position.x = this.#rows[position.y].size;

				console.assert(position.y < this.numRows);
			}
		}

		return None;
	}

	/**
	 * Insert a new line, splitting and/or creating a new row as needed
	 */
	public insertNewline(at: Position): void {
		if (at.y > this.numRows) {
			return;
		}

		this.dirty = true;

		// Just add a simple blank line
		if (at.y === this.numRows) {
			this.#rows.push(Row.default());

			return;
		}

		// Split the current row, and insert a new
		// row with the leftovers
		const currentRow = this.#rows[at.y];
		const newRow = currentRow.split(at.x, this.type);
		this.#rows = arrayInsert(this.#rows, at.y + 1, newRow);
	}

	public insert(at: Position, c: string): void {
		if (at.y > this.numRows) {
			return;
		}

		this.dirty = true;

		if (at.y === this.numRows) {
			this.#rows.push(Row.from(c));
		} else {
			this.#rows[at.y].insertChar(at.x, c);
		}

		this.unHighlightRows(at.y);
	}

	protected unHighlightRows(start: number): void {
		if (this.numRows < start && start >= 1) {
			for (let i = start - 1; i < this.numRows; i++) {
				this.#rows[i].isHighlighted = false;
			}
		}
	}

	/**
	 * Remove a character from the document, merging
	 * adjacent lines if necessary
	 */
	public delete(at: Position): void {
		const len = this.numRows;
		if (at.y >= len) {
			return;
		}

		this.dirty = true;

		const maybeRow = this.row(at.y);
		if (maybeRow.isNone()) {
			return;
		}

		const row = maybeRow.unwrap();

		const mergeNextRow = at.x === row.size && this.row(at.y + 1).isSome();

		// If we are at the end of a line, and press delete,
		// add the contents of the next row, and delete
		// the merged row object (This also works for pressing
		// backspace at the beginning of a line: the cursor is
		// moved to the end of the previous line)
		if (mergeNextRow) {
			// At the end of a line, pressing delete will merge
			// the next line into the current one
			const rowToAppend = this.#rows[at.y + 1].toString();
			row.append(rowToAppend, this.type);
			this.deleteRow(at.y + 1);
		} else {
			row.delete(at.x);
		}

		this.unHighlightRows(at.y);
	}

	public row(i: number): Option<Row> {
		if (i >= this.numRows || i < 0) {
			return None;
		}

		return Option.from(this.#rows.at(i));
	}

	public highlight(searchMatch: Option<string>, limit: Option<number>): void {
		let startWithComment = false;
		let until = this.numRows;
		if (limit.isSome() && (limit.unwrap() + 1 < this.numRows)) {
			until = limit.unwrap() + 1;
		}

		for (let i = 0; i < until; i++) {
			startWithComment = this.#rows[i].update(
				searchMatch,
				this.type,
				startWithComment,
			);
		}
	}

	/**
	 * Delete the specified row
	 * @param at - the index of the row to delete
	 */
	protected deleteRow(at: number): void {
		this.#rows.splice(at, 1);
	}

	/**
	 * Convert the array of row objects into one string
	 */
	protected rowsToString(): string {
		return this.#rows.map((r) => r.toString()).join('\n');
	}
}

export default Document;