<template>
	<LayoutCol class="document">
		<LayoutRow class="options-bar" :scrollableX="true">
			<WidgetLayout :layout="documentModeLayout" />
			<Separator :type="'Section'" />
			<WidgetLayout :layout="toolOptionsLayout" />

			<LayoutRow class="spacer"></LayoutRow>

			<WidgetLayout :layout="documentBarLayout" />
		</LayoutRow>
		<LayoutRow class="shelf-and-viewport">
			<LayoutCol class="shelf">
				<LayoutCol class="tools" :scrollableY="true">
					<WidgetLayout :layout="toolShelfLayout" />
				</LayoutCol>

				<LayoutCol class="spacer"></LayoutCol>

				<LayoutCol class="working-colors">
					<SwatchPairInput />
					<LayoutRow class="swap-and-reset">
						<!-- TODO: Remember to make these tooltip input hints customized to macOS also -->
						<IconButton :action="swapWorkingColors" :icon="'Swap'" title="Swap (Shift+X)" :size="16" />
						<IconButton :action="resetWorkingColors" :icon="'ResetColors'" title="Reset (Ctrl+Shift+X)" :size="16" />
					</LayoutRow>
				</LayoutCol>
			</LayoutCol>
			<LayoutCol class="viewport">
				<LayoutRow class="bar-area">
					<CanvasRuler :origin="rulerOrigin.x" :majorMarkSpacing="rulerSpacing" :numberInterval="rulerInterval" :direction="'Horizontal'" class="top-ruler" ref="rulerHorizontal" />
				</LayoutRow>
				<LayoutRow class="canvas-area">
					<LayoutCol class="bar-area">
						<CanvasRuler :origin="rulerOrigin.y" :majorMarkSpacing="rulerSpacing" :numberInterval="rulerInterval" :direction="'Vertical'" ref="rulerVertical" />
					</LayoutCol>
					<LayoutCol class="canvas-area">
						<div
							class="canvas"
							data-canvas
							ref="canvas"
							:style="{ cursor: canvasCursor }"
							@pointerdown="(e: PointerEvent) => canvasPointerDown(e)"
							@dragover="(e) => e.preventDefault()"
							@drop="(e) => pasteFile(e)"
						>
							<svg class="artboards" v-html="artboardSvg" :style="{ width: canvasSvgWidth, height: canvasSvgHeight }"></svg>
							<svg
								class="artwork"
								xmlns="http://www.w3.org/2000/svg"
								xmlns:xlink="http://www.w3.org/1999/xlink"
								v-html="artworkSvg"
								:style="{ width: canvasSvgWidth, height: canvasSvgHeight }"
							></svg>
							<svg class="overlays" v-html="overlaysSvg" :style="{ width: canvasSvgWidth, height: canvasSvgHeight }"></svg>
						</div>
					</LayoutCol>
					<LayoutCol class="bar-area">
						<PersistentScrollbar
							:direction="'Vertical'"
							:handlePosition="scrollbarPos.y"
							@update:handlePosition="(newValue: number) => translateCanvasY(newValue)"
							v-model:handleLength="scrollbarSize.y"
							@pressTrack="(delta: number) => pageY(delta)"
							class="right-scrollbar"
						/>
					</LayoutCol>
				</LayoutRow>
				<LayoutRow class="bar-area">
					<PersistentScrollbar
						:direction="'Horizontal'"
						:handlePosition="scrollbarPos.x"
						@update:handlePosition="(newValue: number) => translateCanvasX(newValue)"
						v-model:handleLength="scrollbarSize.x"
						@pressTrack="(delta: number) => pageX(delta)"
						class="bottom-scrollbar"
					/>
				</LayoutRow>
			</LayoutCol>
		</LayoutRow>
	</LayoutCol>
</template>

<style lang="scss">
.document {
	height: 100%;

	.options-bar {
		height: 32px;
		flex: 0 0 auto;
		margin: 0 4px;

		.spacer {
			min-width: 40px;
		}
	}

	.shelf-and-viewport {
		.shelf {
			flex: 0 0 auto;

			.tools {
				flex: 0 1 auto;

				.icon-button[title^="Coming Soon"] {
					opacity: 0.25;
					transition: opacity 0.25s;

					&:hover {
						opacity: 1;
					}
				}

				.color-solid {
					fill: var(--color-f-white);
				}

				.color-general {
					fill: var(--color-data-general);
				}

				.color-vector {
					fill: var(--color-data-vector);
				}

				.color-raster {
					fill: var(--color-data-raster);
				}
			}

			.spacer {
				flex: 1 0 auto;
				min-height: 8px;
			}

			.working-colors {
				flex: 0 0 auto;

				.swap-and-reset {
					flex: 0 0 auto;
				}
			}
		}

		.viewport {
			flex: 1 1 100%;

			.canvas-area {
				flex: 1 1 100%;
			}

			.bar-area {
				flex: 0 0 auto;
			}

			.top-ruler {
				padding-left: 16px;
				margin-right: 16px;
			}

			.right-scrollbar {
				margin-top: -16px;
			}

			.bottom-scrollbar {
				margin-right: 16px;
			}

			.canvas {
				background: var(--color-2-mildblack);
				width: 100%;
				height: 100%;
				// Allows the SVG to be placed at explicit integer values of width and height to prevent non-pixel-perfect SVG scaling
				position: relative;
				overflow: hidden;

				svg {
					position: absolute;
					// Fallback values if JS hasn't set these to integers yet
					width: 100%;
					height: 100%;
					// Allows dev tools to select the artwork without being blocked by the SVG containers
					pointer-events: none;

					// Prevent inheritance from reaching the child elements
					> * {
						pointer-events: auto;
					}
				}
				foreignObject {
					width: 10000px;
					height: 10000px;
					overflow: visible;

					div {
						background: none;
						cursor: text;
						border: none;
						margin: 0;
						padding: 0;
						overflow: visible;
						white-space: pre-wrap;
						display: inline-block;
						// Workaround to force Chrome to display the flashing text entry cursor when text is empty
						padding-left: 1px;
						margin-left: -1px;
					}

					div:focus {
						border: none;
						outline: none;
						margin: -1px;
					}
				}
			}
		}
	}
}
</style>

<script lang="ts">
import { defineComponent, nextTick } from "vue";

import {
	UpdateDocumentArtwork,
	UpdateDocumentOverlays,
	UpdateDocumentScrollbars,
	UpdateDocumentRulers,
	UpdateDocumentArtboards,
	UpdateMouseCursor,
	UpdateDocumentModeLayout,
	UpdateToolOptionsLayout,
	UpdateToolShelfLayout,
	defaultWidgetLayout,
	UpdateDocumentBarLayout,
	UpdateImageData,
	TriggerTextCommit,
	TriggerTextCopy,
	TriggerViewportResize,
	DisplayRemoveEditableTextbox,
	DisplayEditableTextbox,
	TriggerFontLoad,
	TriggerFontLoadDefault,
	TriggerVisitLink,
} from "@/dispatcher/js-messages";

import { textInputCleanup } from "@/lifetime/input";

import { loadDefaultFont, setLoadDefaultFontCallback } from "@/utilities/fonts";

import LayoutCol from "@/components/layout/LayoutCol.vue";
import LayoutRow from "@/components/layout/LayoutRow.vue";
import IconButton from "@/components/widgets/buttons/IconButton.vue";
import SwatchPairInput from "@/components/widgets/inputs/SwatchPairInput.vue";
import CanvasRuler from "@/components/widgets/rulers/CanvasRuler.vue";
import PersistentScrollbar from "@/components/widgets/scrollbars/PersistentScrollbar.vue";
import Separator from "@/components/widgets/separators/Separator.vue";
import WidgetLayout from "@/components/widgets/WidgetLayout.vue";

export default defineComponent({
	inject: ["editor", "dialog"],
	methods: {
		viewportResize() {
			// Resize the canvas

			const canvas = this.$refs.canvas as HTMLElement;

			// Get the width and height rounded up to the nearest even number because resizing is centered and dividing an odd number by 2 for centering causes antialiasing
			let width = Math.ceil(parseFloat(getComputedStyle(canvas).width));
			if (width % 2 === 1) width += 1;
			let height = Math.ceil(parseFloat(getComputedStyle(canvas).height));
			if (height % 2 === 1) height += 1;

			this.canvasSvgWidth = `${width}px`;
			this.canvasSvgHeight = `${height}px`;

			// Resize the rulers

			const rulerHorizontal = this.$refs.rulerHorizontal as typeof CanvasRuler;
			const rulerVertical = this.$refs.rulerVertical as typeof CanvasRuler;
			rulerHorizontal?.handleResize();
			rulerVertical?.handleResize();
		},
		pasteFile(e: DragEvent) {
			const { dataTransfer } = e;
			if (!dataTransfer) return;
			e.preventDefault();

			Array.from(dataTransfer.items).forEach(async (item) => {
				const file = item.getAsFile();
				if (file?.type.startsWith("image")) {
					const buffer = await file.arrayBuffer();
					const u8Array = new Uint8Array(buffer);

					this.editor.instance.paste_image(file.type, u8Array, e.clientX, e.clientY);
				}
			});
		},
		translateCanvasX(newValue: number) {
			const delta = newValue - this.scrollbarPos.x;
			this.scrollbarPos.x = newValue;
			this.editor.instance.translate_canvas(-delta * this.scrollbarMultiplier.x, 0);
		},
		translateCanvasY(newValue: number) {
			const delta = newValue - this.scrollbarPos.y;
			this.scrollbarPos.y = newValue;
			this.editor.instance.translate_canvas(0, -delta * this.scrollbarMultiplier.y);
		},
		pageX(delta: number) {
			const move = delta < 0 ? 1 : -1;
			this.editor.instance.translate_canvas_by_fraction(move, 0);
		},
		pageY(delta: number) {
			const move = delta < 0 ? 1 : -1;
			this.editor.instance.translate_canvas_by_fraction(0, move);
		},
		swapWorkingColors() {
			this.editor.instance.swap_colors();
		},
		resetWorkingColors() {
			this.editor.instance.reset_colors();
		},
		canvasPointerDown(e: PointerEvent) {
			const onEditbox = e.target instanceof HTMLDivElement && e.target.contentEditable;
			if (!onEditbox) {
				const canvas = this.$refs.canvas as HTMLElement;
				canvas.setPointerCapture(e.pointerId);
			}
		},
	},
	mounted() {
		this.editor.dispatcher.subscribeJsMessage(UpdateDocumentArtwork, (UpdateDocumentArtwork) => {
			this.artworkSvg = UpdateDocumentArtwork.svg;

			nextTick((): void => {
				if (this.textInput) {
					const canvas = this.$refs.canvas as HTMLElement;
					const foreignObject = canvas.getElementsByTagName("foreignObject")[0] as SVGForeignObjectElement;
					if (foreignObject.children.length > 0) return;

					const addedInput = foreignObject.appendChild(this.textInput);

					nextTick((): void => {
						// Necessary to select contenteditable: https://stackoverflow.com/questions/6139107/programmatically-select-text-in-a-contenteditable-html-element/6150060#6150060

						const range = document.createRange();
						range.selectNodeContents(addedInput);

						const selection = window.getSelection();
						if (selection) {
							selection.removeAllRanges();
							selection.addRange(range);
						}

						addedInput.focus();
						addedInput.click();
					});

					window.dispatchEvent(
						new CustomEvent("modifyinputfield", {
							detail: addedInput,
						})
					);
				}
			});
		});

		this.editor.dispatcher.subscribeJsMessage(UpdateDocumentOverlays, (updateDocumentOverlays) => {
			this.overlaysSvg = updateDocumentOverlays.svg;
		});

		this.editor.dispatcher.subscribeJsMessage(UpdateDocumentArtboards, (updateDocumentArtboards) => {
			this.artboardSvg = updateDocumentArtboards.svg;
		});

		this.editor.dispatcher.subscribeJsMessage(UpdateDocumentScrollbars, (updateDocumentScrollbars) => {
			this.scrollbarPos = updateDocumentScrollbars.position;
			this.scrollbarSize = updateDocumentScrollbars.size;
			this.scrollbarMultiplier = updateDocumentScrollbars.multiplier;
		});

		this.editor.dispatcher.subscribeJsMessage(UpdateDocumentRulers, (updateDocumentRulers) => {
			this.rulerOrigin = updateDocumentRulers.origin;
			this.rulerSpacing = updateDocumentRulers.spacing;
			this.rulerInterval = updateDocumentRulers.interval;
		});

		this.editor.dispatcher.subscribeJsMessage(UpdateMouseCursor, (updateMouseCursor) => {
			this.canvasCursor = updateMouseCursor.cursor;
		});
		this.editor.dispatcher.subscribeJsMessage(TriggerTextCommit, () => {
			if (this.textInput) {
				const textCleaned = textInputCleanup(this.textInput.innerText);
				this.editor.instance.on_change_text(textCleaned);
			}
		});
		this.editor.dispatcher.subscribeJsMessage(TriggerFontLoad, async (triggerFontLoad) => {
			const response = await fetch(triggerFontLoad.font);
			const responseBuffer = await response.arrayBuffer();
			this.editor.instance.on_font_load(triggerFontLoad.font, new Uint8Array(responseBuffer), false);
		});
		this.editor.dispatcher.subscribeJsMessage(TriggerFontLoadDefault, loadDefaultFont);
		this.editor.dispatcher.subscribeJsMessage(TriggerVisitLink, async (triggerOpenLink) => {
			window.open(triggerOpenLink.url, "_blank");
		});
		this.editor.dispatcher.subscribeJsMessage(TriggerTextCopy, (triggerTextCopy) => {
			// If the Clipboard API is supported in the browser, copy text to the clipboard
			navigator.clipboard?.writeText?.(triggerTextCopy.copy_text);
		});

		this.editor.dispatcher.subscribeJsMessage(DisplayEditableTextbox, (displayEditableTextbox) => {
			this.textInput = document.createElement("DIV") as HTMLDivElement;

			if (displayEditableTextbox.text === "") this.textInput.textContent = "";
			else this.textInput.textContent = `${displayEditableTextbox.text}\n`;

			this.textInput.contentEditable = "true";
			this.textInput.style.width = displayEditableTextbox.line_width ? `${displayEditableTextbox.line_width}px` : "max-content";
			this.textInput.style.height = "auto";
			this.textInput.style.fontSize = `${displayEditableTextbox.font_size}px`;
			this.textInput.style.color = displayEditableTextbox.color.toRgbaCSS();

			this.textInput.oninput = (): void => {
				if (this.textInput) this.editor.instance.update_bounds(textInputCleanup(this.textInput.innerText));
			};
		});

		this.editor.dispatcher.subscribeJsMessage(DisplayRemoveEditableTextbox, () => {
			this.textInput = undefined;
			window.dispatchEvent(
				new CustomEvent("modifyinputfield", {
					detail: undefined,
				})
			);
		});

		this.editor.dispatcher.subscribeJsMessage(UpdateDocumentModeLayout, (updateDocumentModeLayout) => {
			this.documentModeLayout = updateDocumentModeLayout;
		});

		this.editor.dispatcher.subscribeJsMessage(UpdateToolOptionsLayout, (updateToolOptionsLayout) => {
			this.toolOptionsLayout = updateToolOptionsLayout;
		});

		this.editor.dispatcher.subscribeJsMessage(UpdateDocumentBarLayout, (updateDocumentBarLayout) => {
			this.documentBarLayout = updateDocumentBarLayout;
		});

		this.editor.dispatcher.subscribeJsMessage(UpdateToolShelfLayout, (updateToolShelfLayout) => {
			this.toolShelfLayout = updateToolShelfLayout;
		});

		this.editor.dispatcher.subscribeJsMessage(TriggerViewportResize, this.viewportResize);

		this.editor.dispatcher.subscribeJsMessage(UpdateImageData, (updateImageData) => {
			updateImageData.image_data.forEach(async (element) => {
				// Using updateImageData.image_data.buffer returns undefined for some reason?
				const blob = new Blob([new Uint8Array(element.image_data.values()).buffer], { type: element.mime });

				const url = URL.createObjectURL(blob);

				const image = await createImageBitmap(blob);

				this.editor.instance.set_image_blob_url(element.path, url, image.width, image.height);
			});
		});

		// Gets metadata populated in `frontend/vue.config.js`. We could potentially move this functionality in a build.rs file.
		const loadBuildMetadata = (): void => {
			const release = process.env.VUE_APP_RELEASE_SERIES;
			let timestamp = "";
			const hash = (process.env.VUE_APP_COMMIT_HASH || "").substring(0, 8);
			const branch = process.env.VUE_APP_COMMIT_BRANCH;
			{
				const date = new Date(process.env.VUE_APP_COMMIT_DATE || "");
				const dateString = `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")}`;
				const timeString = `${String(date.getHours()).padStart(2, "0")}:${String(date.getMinutes()).padStart(2, "0")}`;
				const timezoneName = Intl.DateTimeFormat(undefined, { timeZoneName: "long" })
					.formatToParts(new Date())
					.find((part) => part.type === "timeZoneName");
				const timezoneNameString = timezoneName?.value;
				timestamp = `${dateString} ${timeString} ${timezoneNameString}`;
			}

			this.editor.instance.populate_build_metadata(release || "", timestamp, hash, branch || "");
		};

		setLoadDefaultFontCallback((font: string, data: Uint8Array) => this.editor.instance.on_font_load(font, data, true));

		loadBuildMetadata();
	},
	data() {
		return {
			// Interactive text editing
			textInput: undefined as undefined | HTMLDivElement,

			// CSS properties
			canvasSvgWidth: "100%",
			canvasSvgHeight: "100%",
			canvasCursor: "default",

			// Scrollbars
			scrollbarPos: { x: 0.5, y: 0.5 },
			scrollbarSize: { x: 0.5, y: 0.5 },
			scrollbarMultiplier: { x: 0, y: 0 },

			// Rulers
			rulerOrigin: { x: 0, y: 0 },
			rulerSpacing: 100,
			rulerInterval: 100,

			// Rendered SVG viewport data
			artworkSvg: "",
			artboardSvg: "",
			overlaysSvg: "",

			// Layouts
			documentModeLayout: defaultWidgetLayout(),
			toolOptionsLayout: defaultWidgetLayout(),
			documentBarLayout: defaultWidgetLayout(),
			toolShelfLayout: defaultWidgetLayout(),
		};
	},
	components: {
		LayoutRow,
		LayoutCol,
		SwatchPairInput,
		Separator,
		PersistentScrollbar,
		CanvasRuler,
		IconButton,
		WidgetLayout,
	},
});
</script>
