function rectsDist([ax1, ay1, ax2, ay2], [bx1, by1, bx2, by2]) {
	let left = bx2 < ax1;
	let right = ax2 < bx1;
	let bottom = by2 < ay1;
	let top = ay2 < by1;

	if (top && left) {
		return Math.hypot(ax1 - bx2, ay2 - by1);
	}
	else if (left && bottom) {
		return Math.hypot(ax1 - bx2, ay1 - by2);
	}
	else if (bottom && right) {
		return Math.hypot(ax2 - bx1, ay1 - by2);
	}
	else if (right && top) {
		return Math.hypot(ax2 - bx1, ay2 - by1);
	}
	else if (left) {
		return ax1 - bx2;
	}
	else if (right) {
		return bx1 - ax2;
	}
	else if (bottom) {
		return ay1 - by2;
	}
	else if (top) {
		return by1 - ay2;
	}

	return 0;
}

function _getClosestOffset(chars, rect) {
	let dist = Infinity;
	let idx = 0;
	for (let i = 0; i < chars.length; i++) {
		let ch = chars[i];
		let distance = rectsDist(ch.rect, rect);
		if (distance < dist) {
			dist = distance;
			idx = i;
		}
	}
	return idx;
}

let isNum = c => c >= '0' && c <= '9';

function getSurroundedNumber(chars, idx) {
	while (
		idx > 0 && isNum(chars[idx - 1].c)
		&& Math.abs(chars[idx].rect[0] - chars[idx - 1].rect[2]) < chars[idx].rect[2] - chars[idx].rect[0]
		&& Math.abs(chars[idx - 1].rect[1] - chars[idx].rect[1]) < 2
		) {
		idx--;
	}

	let str = chars[idx].c;

	while (
		idx < chars.length - 1 && isNum(chars[idx + 1].c)
		&& Math.abs(chars[idx + 1].rect[0] - chars[idx].rect[2]) < chars[idx + 1].rect[2] - chars[idx + 1].rect[0]
		&& Math.abs(chars[idx].rect[1] - chars[idx + 1].rect[1]) < 2
		) {
		idx++;
		str += chars[idx].c;
	}

	return parseInt(str);
}

function getSurroundedNumberAtPos(chars, x, y) {
	for (let i = 0; i < chars.length; i++) {
		let ch = chars[i];
		let { x: x2, y: y2 } = getRectCenter(ch.rect);
		if (isNum(ch.c) && Math.abs(x - x2) < 10 && Math.abs(y - y2) < 5) {
			return getSurroundedNumber(chars, i);
		}
	}
	return null;
}

function getRectCenter(rect) {
	return {
		x: rect[0] + (rect[2] - rect[0]) / 2,
		y: rect[1] + (rect[3] - rect[1]) / 2
	};
}

function filterNums(chars, pageHeight) {
	return chars.filter(x => x.c >= '0' && x.c <= '9' && (x.rect[3] < pageHeight * 1 / 5 || x.rect[1] > pageHeight * 3 / 5));
}

function _getPageLabelPoints(pageIndex, chars1, chars2, chars3, chars4, pageHeight) {
	let charsNum1 = filterNums(chars1, pageHeight);
	let charsNum2 = filterNums(chars2, pageHeight);
	let charsNum3 = filterNums(chars3, pageHeight);
	let charsNum4 = filterNums(chars4, pageHeight);

	// Cut off the logic if one of the pages has too many digits
	if ([charsNum1, charsNum2, charsNum3, charsNum4].find(x => x.length > 100)) {
		return null;
	}

	for (let c1 = 0; c1 < charsNum1.length; c1++) {
		let ch1 = charsNum1[c1];
		for (let c3 = 0; c3 < charsNum3.length; c3++) {
			let ch3 = charsNum3[c3];
			let { x: x1, y: y1 } = getRectCenter(ch1.rect);
			let { x: x2, y: y2 } = getRectCenter(ch3.rect);
			if (Math.abs(x1 - x2) < 10 && Math.abs(y1 - y2) < 5) {
				let num1 = getSurroundedNumber(charsNum1, c1);
				let num3 = getSurroundedNumber(charsNum3, c3);
				if (num1 && num1 + 2 === num3) {
					let pos1 = { x: x1, y: y1, num: num1, idx: pageIndex };

					let extractedNum2 = getSurroundedNumberAtPos(chars2, x1, y1);
					if (num1 + 1 === extractedNum2) {
						return [pos1];
					}

					for (let c2 = 0; c2 < charsNum2.length; c2++) {
						let ch2 = charsNum2[c2];
						for (let c4 = 0; c4 < charsNum4.length; c4++) {
							let ch4 = charsNum4[c4];
							let { x: x1, y: y1 } = getRectCenter(ch2.rect);
							let { x: x2, y: y2 } = getRectCenter(ch4.rect);
							if (Math.abs(x1 - x2) < 10 && Math.abs(y1 - y2) < 5) {
								let num2 = getSurroundedNumber(charsNum2, c2);
								let num4 = getSurroundedNumber(charsNum4, c4);
								if (num1 + 1 === num2 && num2 + 2 === num4) {
									let pos2 = { x: x1, y: y1, num: num2, idx: pageIndex + 2 };
									return [pos1, pos2];
								}
							}
						}
					}
				}
			}
		}
	}

	return null;
}

function _getPageLabel(pageIndex, charsPrev, charsCur, charsNext, points) {
	let numPrev, numCur, numNext;

	// TODO: Instead of trying to extract from two positions, try to
	//  guess the right position by determining whether the page is even or odd

	// TODO: Take into account font parameters when comparing extracted numbers
	let getNum = (charsNext, points) => points.length > 0 && getSurroundedNumberAtPos(charsNext, points[0].x, points[0].y)
		|| points.length > 1 && getSurroundedNumberAtPos(charsNext, points[1].x, points[1].y);

	if (charsPrev) {
		numPrev = getNum(charsPrev, points);
	}

	numCur = getNum(charsCur, points);

	if (charsNext) {
		numNext = getNum(charsNext, points);
	}

	if (numCur && (numCur - 1 === numPrev || numCur + 1 === numNext)) {
		return numCur.toString();
	}

	if (pageIndex < points[0].idx) {
		return (points[0].num - (points[0].idx - pageIndex)).toString();
	}

	return null;
}

// The function is adapted from Xpdf https://www.xpdfreader.com/opensource.html
// Original copyright: 1996-2019 Glyph & Cog, LLC.
function computeWordSpacingThreshold(chars, vertical) {
	// Inter-character spacing that varies by less than this multiple of
	// font size is assumed to be equivalent.
	const uniformSpacing = 0.07;
	// Typical word spacing, as a fraction of font size.  This will be
	// added to the minimum inter-character spacing, to account for wide
	// character spacing.
	const wordSpacing = 0.1;
	// Compute the inter-word spacing threshold for a line of chars.
	// Spaces greater than this threshold will be considered inter-word
	// spaces.

	let char, char2;
	let avgFontSize;
	let minAdjGap, maxAdjGap, minSpGap, maxSpGap, minGap, maxGap, gap, gap2;
	let i;

	avgFontSize = 0;
	minGap = maxGap = 0;
	minAdjGap = minSpGap = 1;
	maxAdjGap = maxSpGap = 0;
	for (i = 0; i < chars.length; ++i) {
		char = chars[i];
		avgFontSize += char.fontSize;
		if (i < chars.length - 1) {
			char2 = chars[i + 1];
			gap = vertical ? (char2.rect[1] - char.rect[3]) : (char2.rect[0] - char.rect[2]);
			if (char.spaceAfter) {
				if (minSpGap > maxSpGap) {
					minSpGap = maxSpGap = gap;
				}
				else if (gap < minSpGap) {
					minSpGap = gap;
				}
				else if (gap > maxSpGap) {
					maxSpGap = gap;
				}
			}
			else if (minAdjGap > maxAdjGap) {
				minAdjGap = maxAdjGap = gap;
			}
			else if (gap < minAdjGap) {
				minAdjGap = gap;
			}
			else if (gap > maxAdjGap) {
				maxAdjGap = gap;
			}
			if (i == 0 || gap < minGap) {
				minGap = gap;
			}
			if (gap > maxGap) {
				maxGap = gap;
			}
		}
	}
	avgFontSize /= chars.length;
	if (minGap < 0) {
		minGap = 0;
	}

	// if spacing is nearly uniform (minGap is close to maxGap), use the
	// SpGap/AdjGap values if available, otherwise assume it's a single
	// word (technically it could be either "ABC" or "A B C", but it's
	// essentially impossible to tell)
	if (maxGap - minGap < uniformSpacing * avgFontSize) {
		if (minAdjGap <= maxAdjGap
			&& minSpGap <= maxSpGap
			&& minSpGap - maxAdjGap > 0.01) {
			return 0.5 * (maxAdjGap + minSpGap);
		}
		else {
			return maxGap + 1;
		}

		// if there is some variation in spacing, but it's small, assume
		// there are some inter-word spaces
	}
	else if (maxGap - minGap < wordSpacing * avgFontSize) {
		return 0.5 * (minGap + maxGap);

		// if there is a large variation in spacing, use the SpGap/AdjGap
		// values if they look reasonable, otherwise, assume a reasonable
		// threshold for inter-word spacing (we can't use something like
		// 0.5*(minGap+maxGap) here because there can be outliers at the
		// high end)
	}
	else if (minAdjGap <= maxAdjGap
		&& minSpGap <= maxSpGap
		&& minSpGap - maxAdjGap > uniformSpacing * avgFontSize) {
		gap = wordSpacing * avgFontSize;
		gap2 = 0.5 * (minSpGap - minGap);
		return minGap + (gap < gap2 ? gap : gap2);
	}
	else {
		return minGap + wordSpacing * avgFontSize;
	}
}

function overlaps(char1, char2) {
	if ([0, 180].includes(char1.rotation)) {
		return (char1.rect[1] <= char2.rect[1] && char2.rect[1] <= char1.rect[3]
			|| char2.rect[1] <= char1.rect[1] && char1.rect[1] <= char2.rect[3]);
	}
	return (
		char1.rect[0] <= char2.rect[0] && char2.rect[0] <= char1.rect[2]
		|| char2.rect[0] <= char1.rect[0] && char1.rect[0] <= char2.rect[2]
	);
}

function charHeight(char) {
	return (!char.rotation && char.rect[3] - char.rect[1]
		|| char.rotation === 90 && char.rect[2] - char.rect[0]
		|| char.rotation === 180 && char.rect[1] - char.rect[3]
		|| char.rotation === 270 && char.rect[0] - char.rect[2]);
}

function getLines(chars) {
	let lines = [];
	let line = {
		offset: 0,
		chars: [chars[0]],
		vertical: [90, 270].includes(chars[0].rotation)
	};
	for (let i = 1; i < chars.length; i++) {
		let char = chars[i];
		let prevChar = line.chars[line.chars.length - 1];
		if (
			// Caret jumps to the next line start
			!char.rotation && prevChar.rect[0] > char.rect[0]
			|| char.rotation === 90 && prevChar.rect[1] > char.rect[1]
			|| char.rotation === 180 && prevChar.rect[0] < char.rect[0]
			|| char.rotation === 270 && prevChar.rect[1] < char.rect[1]
			// Rotation changes
			|| prevChar.rotation !== char.rotation
			// Chars aren't in the same line
			|| !overlaps(prevChar, char)
			// Line's first char is more than 2x larger than the following char
			|| line.chars.length === 1 && charHeight(prevChar) > charHeight(char) * 2
		) {
			lines.push(line);
			line = { offset: i, chars: [char], vertical: [90, 270].includes(char.rotation) };
		}
		else {
			line.chars.push(char);
		}
	}
	// Push last line
	if (line.chars.length) {
		lines.push(line);
	}
	// Calculate line bounding rect
	for (let line of lines) {
		line.rect = line.chars[0].rect.slice();
		for (let char of line.chars) {
			line.rect[0] = Math.min(line.rect[0], char.rect[0]);
			line.rect[1] = Math.min(line.rect[1], char.rect[1]);
			line.rect[2] = Math.max(line.rect[2], char.rect[2]);
			line.rect[3] = Math.max(line.rect[3], char.rect[3]);
		}
	}
	for (let line of lines) {
		line.words = [];
		let wordSp = computeWordSpacingThreshold(line.chars, line.vertical);
		let i = 0;
		while (i < line.chars.length) {
			let sp = wordSp - 1;
			let spaceAfter = false;
			let j;
			for (j = i + 1; j < line.chars.length; ++j) {
				let char = line.chars[j - 1];
				let char2 = line.chars[j];
				sp = line.vertical ? (char2.rect[1] - char.rect[3]) : (char2.rect[0] - char.rect[2]);
				if (sp > wordSp) {
					spaceAfter = true;
					break;
				}
			}
			line.words.push({ offset: line.offset + i, chars: line.chars.slice(i, j), spaceAfter });
			i = j;
		}
	}

	return lines;
}

function isDash(c) {
	let re = /[\x2D\u058A\u05BE\u1400\u1806\u2010-\u2015\u2E17\u2E1A\u2E3A\u2E3B\u301C\u3030\u30A0\uFE31\uFE32\uFE58\uFE63\uFF0D]/;
	return re.test(c);
}

function quickIntersectRect(r1, r2) {
	return !(r2[0] > r1[2]
		|| r2[2] < r1[0]
		|| r2[1] > r1[3]
		|| r2[3] < r1[1]);
}

function getCenterRect(r) {
	return [
		r[0] + (r[2] - r[0]) / 2,
		r[1] + (r[3] - r[1]) / 2,
		r[0] + (r[2] - r[0]) / 2,
		r[1] + (r[3] - r[1]) / 2
	];
}

function getRangeBySelection({ chars, anchor, head, reverse }) {
	// Note: Offsets can be between 0 and chars.length (the cursor can after the last char)
	if (!chars.length) {
		return null;
	}
	let anchorOffset = reverse ? chars.length - 1 : 0;
	let headOffset = reverse ? 0 : chars.length - 1;
	let x1, y1, x2, y2;
	if (Number.isInteger(anchor)) {
		anchorOffset = anchor;
		anchorOffset = anchorOffset < 0 ? 0 : anchorOffset;
		anchorOffset = anchorOffset > chars.length ? chars.length : anchorOffset;
	}
	else if (Array.isArray(anchor)) {
		[x1, y1] = anchor;
		anchorOffset = _getClosestOffset(chars, [x1, y1, x1, y1]);
	}
	if (Number.isInteger(head)) {
		headOffset = head;
		headOffset = headOffset < 0 ? 0 : headOffset;
		headOffset = headOffset > chars.length ? chars.length : headOffset;
	}
	else if (Array.isArray(head)) {
		[x2, y2] = head;
		headOffset = _getClosestOffset(chars, [x2, y2, x2, y2]);
	}
	if (Array.isArray(anchor)) {
		let { rotation, rect } = chars[anchorOffset];
		if (!rotation && x1 > rect[0] + (rect[2] - rect[0]) / 2
			|| rotation === 90 && y1 > rect[1] + (rect[3] - rect[1]) / 2
			|| rotation === 180 && x1 < rect[0] + (rect[2] - rect[0]) / 2
			|| rotation === 270 && y1 < rect[1] + (rect[3] - rect[1]) / 2) {
			anchorOffset++;
		}
	}
	if (Array.isArray(head)) {
		let { rotation, rect } = chars[headOffset];
		if (!rotation && x2 > rect[0] + (rect[2] - rect[0]) / 2
			|| rotation === 90 && y2 > rect[1] + (rect[3] - rect[1]) / 2
			|| rotation === 180 && x2 < rect[0] + (rect[2] - rect[0]) / 2
			|| rotation === 270 && y2 < rect[1] + (rect[3] - rect[1]) / 2) {
			headOffset++;
		}
	}

	return getRange(chars, anchorOffset, headOffset);
}

function _getRangeByHighlight(chars, rects) {
	if (!chars.length) {
		return null;
	}
	let anchorOffset = Infinity;
	for (let i = 0; i < chars.length; i++) {
		let char = chars[i];
		if (quickIntersectRect(getCenterRect(char.rect), rects[0])) {
			anchorOffset = i;
			break;
		}
	}
	let headOffset = 0;
	for (let i = chars.length - 1; i >= 0; i--) {
		let char = chars[i];
		if (quickIntersectRect(getCenterRect(char.rect), rects[rects.length - 1])) {
			headOffset = i;
			break;
		}
	}

	headOffset++;

	if (anchorOffset > headOffset) {
		return null;
	}

	let range = getRange(chars, anchorOffset, headOffset);
	range.offset = range.anchorOffset;
	delete range.anchorOffset;
	delete range.headOffset;
	return range;
}

function getLineSelectionRect(line, charFrom, charTo) {
	if (line.vertical) {
		return [
			line.rect[0],
			Math.min(charFrom.rect[1], charTo.rect[1]),
			line.rect[2],
			Math.max(charFrom.rect[3], charTo.rect[3])
		];
	}
	else {
		return [
			Math.min(charFrom.rect[0], charTo.rect[0]),
			line.rect[1],
			Math.max(charFrom.rect[2], charTo.rect[2]),
			line.rect[3]
		];
	}
}

function getRange(chars, anchorOffset, headOffset) {
	let lines = getLines(chars);
	let charStart;
	let charEnd;
	if (anchorOffset < headOffset) {
		charStart = chars[anchorOffset];
		charEnd = chars[headOffset - 1];
	}
	else if (anchorOffset > headOffset) {
		charStart = chars[headOffset];
		charEnd = chars[anchorOffset - 1];
	}
	else {
		return { collapsed: true, anchorOffset, headOffset, rects: [], text: '' };
	}

	// Get text
	let text = '';
	let extracting = false;

	loop1: for (let line of lines) {
		for (let word of line.words) {
			let isLastWord = word === line.words[line.words.length - 1];
			for (let char of word.chars) {
				let isLastChar = char === word.chars[word.chars.length - 1];
				if (char === charStart) {
					extracting = true;
				}
				if (!extracting || isLastWord && isLastChar && isDash(char.c) && char !== charEnd) {
					continue;
				}
				text += char.c;
				if (isLastChar
					&& (word.spaceAfter || isLastWord)
					&& text[text.length - 1] !== ' ') {
					text += ' ';
				}
				if (char === charEnd) {
					break loop1;
				}
			}
		}
	}
	text = text.trim();
	// Get rects
	extracting = false;
	let rects = [];
	loop2: for (let line of lines) {
		let charFrom = null;
		let charTo = null;
		for (let word of line.words) {
			for (let char of word.chars) {
				if (char === charStart || extracting && !charFrom) {
					extracting = true;
					charFrom = char;
				}
				if (extracting) {
					charTo = char;
					if (char === charEnd) {
						rects.push(getLineSelectionRect(line, charFrom, charTo));
						break loop2;
					}
				}
			}
		}
		if (extracting) {
			rects.push(getLineSelectionRect(line, charFrom, charTo));
			charFrom = null;
		}
	}
	rects = rects.map(rect => rect.map(value => parseFloat(value.toFixed(3))));

	return { anchorOffset, headOffset, rects, text };
}

function _getNextLineClosestOffset(chars, offset) {
	if (!chars.length) {
		return null;
	}
	if (offset < 0) {
		offset = 0;
	}
	else if (offset >= chars.length) {
		offset = chars.length - 1;
	}
	let lines = getLines(chars);
	let char = chars[offset];
	let idx = lines.findIndex(line => line.chars.includes(char));
	if (idx < lines.length - 1) {
		let line = lines[idx + 1];
		return line.offset + getClosestOffset(line.chars, char.rect);
	}
	return chars.length;
}

function _getPrevLineClosestOffset(chars, offset) {
	if (!chars.length) {
		return null;
	}
	if (offset < 0) {
		offset = 0;
	}
	else if (offset >= chars.length) {
		offset = chars.length - 1;
	}
	let lines = getLines(chars);
	let char = chars[offset];
	let idx = lines.findIndex(line => line.chars.includes(char));
	if (idx > 0) {
		let line = lines[idx - 1];
		return line.offset + _getClosestOffset(line.chars, char.rect);
	}
	return 0;
}

function _getClosestWord(chars, rect) {
	if (!chars.length) {
		return null;
	}
	let lines = getLines(chars);
	let offset = _getClosestOffset(chars, rect);
	let char = chars[offset];
	let line = lines.find(line => line.chars.includes(char));
	let word = line.words.find(word => word.chars.includes(char));
	return { anchorOffset: word.offset, headOffset: word.offset + word.chars.length };
}

function _getClosestLine(chars, rect) {
	if (!chars.length) {
		return null;
	}
	let lines = getLines(chars);
	let offset = _getClosestOffset(chars, rect);
	let char = chars[offset];
	let line = lines.find(line => line.chars.includes(char));
	return { anchorOffset: line.offset, headOffset: line.offset + line.chars.length };
}


window.getClosestOffset = _getClosestOffset