/// <reference path='./ContextFormat.ts'/>

class Context {

	static raw: TContext = new TContext(); //{};

	static useDeferred = (): bool => {
		///if is_paint
		return Context.raw.renderMode != RenderMode.RenderForward && (Context.raw.viewportMode == ViewportMode.ViewLit || Context.raw.viewportMode == ViewportMode.ViewPathTrace) && Context.raw.tool != WorkspaceTool.ToolColorId;
		///end

		///if (is_sculpt || is_lab)
		return Context.raw.renderMode != RenderMode.RenderForward && (Context.raw.viewportMode == ViewportMode.ViewLit || Context.raw.viewportMode == ViewportMode.ViewPathTrace);
		///end
	}

	///if (is_paint || is_sculpt)
	static selectMaterial = (i: i32) => {
		if (Project.materials.length <= i) return;
		Context.setMaterial(Project.materials[i]);
	}

	static setMaterial = (m: SlotMaterial) => {
		if (Project.materials.indexOf(m) == -1) return;
		Context.raw.material = m;
		MakeMaterial.parsePaintMaterial();
		UIBase.hwnds[TabArea.TabSidebar1].redraws = 2;
		UIHeader.headerHandle.redraws = 2;
		UINodes.hwnd.redraws = 2;
		UINodes.groupStack = [];

		let decal = Context.raw.tool == WorkspaceTool.ToolDecal || Context.raw.tool == WorkspaceTool.ToolText;
		if (decal) {
			let _next = () => {
				UtilRender.makeDecalPreview();
			}
			Base.notifyOnNextFrame(_next);
		}
	}

	static selectBrush = (i: i32) => {
		if (Project.brushes.length <= i) return;
		Context.setBrush(Project.brushes[i]);
	}

	static setBrush = (b: SlotBrush) => {
		if (Project.brushes.indexOf(b) == -1) return;
		Context.raw.brush = b;
		MakeMaterial.parseBrush();
		UIBase.hwnds[TabArea.TabSidebar1].redraws = 2;
		UINodes.hwnd.redraws = 2;
	}

	static selectFont = (i: i32) => {
		if (Project.fonts.length <= i) return;
		Context.setFont(Project.fonts[i]);
	}

	static setFont = (f: SlotFont) => {
		if (Project.fonts.indexOf(f) == -1) return;
		Context.raw.font = f;
		UtilRender.makeTextPreview();
		UtilRender.makeDecalPreview();
		UIBase.hwnds[TabArea.TabStatus].redraws = 2;
		UIView2D.hwnd.redraws = 2;
	}

	static selectLayer = (i: i32) => {
		if (Project.layers.length <= i) return;
		Context.setLayer(Project.layers[i]);
	}

	static setLayer = (l: SlotLayer) => {
		if (l == Context.raw.layer) return;
		Context.raw.layer = l;
		UIHeader.headerHandle.redraws = 2;

		let current = Graphics2.current;
		if (current != null) current.end();

		Base.setObjectMask();
		MakeMaterial.parseMeshMaterial();
		MakeMaterial.parsePaintMaterial();

		if (current != null) current.begin(false);

		UIBase.hwnds[TabArea.TabSidebar0].redraws = 2;
		UIView2D.hwnd.redraws = 2;
	}
	///end

	static selectTool = (i: i32) => {
		Context.raw.tool = i;
		MakeMaterial.parsePaintMaterial();
		MakeMaterial.parseMeshMaterial();
		Context.raw.ddirty = 3;
		let _viewportMode = Context.raw.viewportMode;
		Context.raw.viewportMode = -1 as ViewportMode;
		Context.setViewportMode(_viewportMode);

		///if (is_paint || is_sculpt)
		Context.initTool();
		UIHeader.headerHandle.redraws = 2;
		UIToolbar.toolbarHandle.redraws = 2;
		///end
	}

	///if (is_paint || is_sculpt)
	static initTool = () => {
		let decal = Context.raw.tool == WorkspaceTool.ToolDecal || Context.raw.tool == WorkspaceTool.ToolText;
		if (decal) {
			if (Context.raw.tool == WorkspaceTool.ToolText) {
				UtilRender.makeTextPreview();
			}
			UtilRender.makeDecalPreview();
		}

		else if (Context.raw.tool == WorkspaceTool.ToolParticle) {
			UtilParticle.initParticle();
			MakeMaterial.parseParticleMaterial();
		}

		else if (Context.raw.tool == WorkspaceTool.ToolBake) {
			///if (krom_direct3d12 || krom_vulkan || krom_metal)
			// Bake in lit mode for now
			if (Context.raw.viewportMode == ViewportMode.ViewPathTrace) {
				Context.raw.viewportMode = ViewportMode.ViewLit;
			}
			///end
		}

		else if (Context.raw.tool == WorkspaceTool.ToolMaterial) {
			Base.updateFillLayers();
			Context.mainObject().skip_context = null;
		}

		///if krom_ios
		// No hover on iPad, decals are painted by pen release
		Config.raw.brush_live = decal;
		///end
	}
	///end

	static selectPaintObject = (o: MeshObject) => {
		///if (is_paint || is_sculpt)
		UIHeader.headerHandle.redraws = 2;
		for (let p of Project.paintObjects) p.skip_context = "paint";
		Context.raw.paintObject = o;

		let mask = Context.raw.layer.getObjectMask();
		if (Context.layerFilterUsed()) mask = Context.raw.layerFilter;

		if (Context.raw.mergedObject == null || mask > 0) {
			Context.raw.paintObject.skip_context = "";
		}
		UtilUV.uvmapCached = false;
		UtilUV.trianglemapCached = false;
		UtilUV.dilatemapCached = false;
		///end

		///if is_lab
		Context.raw.paintObject = o;
		///end
	}

	static mainObject = (): MeshObject => {
		///if (is_paint || is_sculpt)
		for (let po of Project.paintObjects) if (po.children.length > 0) return po;
		return Project.paintObjects[0];
		///end

		///if is_lab
		return Project.paintObjects[0];
		///end
	}

	static layerFilterUsed = (): bool => {
		///if (is_paint || is_sculpt)
		return Context.raw.layerFilter > 0 && Context.raw.layerFilter <= Project.paintObjects.length;
		///end

		///if is_lab
		return true;
		///end
	}

	static objectMaskUsed = (): bool => {
		return Context.raw.layer.getObjectMask() > 0 && Context.raw.layer.getObjectMask() <= Project.paintObjects.length;
	}

	static inViewport = (): bool => {
		return Context.raw.paintVec.x < 1 && Context.raw.paintVec.x > 0 &&
			   Context.raw.paintVec.y < 1 && Context.raw.paintVec.y > 0;
	}

	static inPaintArea = (): bool => {
		///if (is_paint || is_sculpt)
		let mouse = Input.getMouse();
		let right = App.w();
		if (UIView2D.show) right += UIView2D.ww;
		return mouse.viewX > 0 && mouse.viewX < right &&
			   mouse.viewY > 0 && mouse.viewY < App.h();
		///end

		///if is_lab
		return Context.inViewport();
		///end
	}

	static inLayers = (): bool => {
		return UIBase.ui.getHoveredTabName() == tr("Layers");
	}

	static inMaterials = (): bool => {
		return UIBase.ui.getHoveredTabName() == tr("Materials");
	}

	///if (is_paint || is_sculpt)
	static in2dView = (type = View2DType.View2DLayer): bool => {
		let mouse = Input.getMouse();
		return UIView2D.show && UIView2D.type == type &&
			   mouse.x > UIView2D.wx && mouse.x < UIView2D.wx + UIView2D.ww &&
			   mouse.y > UIView2D.wy && mouse.y < UIView2D.wy + UIView2D.wh;
	}
	///end

	static inNodes = (): bool => {
		let mouse = Input.getMouse();
		return UINodes.show &&
			   mouse.x > UINodes.wx && mouse.x < UINodes.wx + UINodes.ww &&
			   mouse.y > UINodes.wy && mouse.y < UINodes.wy + UINodes.wh;
	}

	static inSwatches = (): bool => {
		return UIBase.ui.getHoveredTabName() == tr("Swatches");
	}

	static inBrowser = (): bool => {
		return UIBase.ui.getHoveredTabName() == tr("Browser");
	}

	static getAreaType = (): AreaType => {
		if (Context.inViewport()) return AreaType.AreaViewport;
		if (Context.inNodes()) return AreaType.AreaNodes;
		if (Context.inBrowser()) return AreaType.AreaBrowser;
		///if (is_paint || is_sculpt)
		if (Context.in2dView()) return AreaType.Area2DView;
		if (Context.inLayers()) return AreaType.AreaLayers;
		if (Context.inMaterials()) return AreaType.AreaMaterials;
		///end
		return -1 as AreaType;
	}

	static setViewportMode = (mode: ViewportMode) => {
		if (mode == Context.raw.viewportMode) return;

		Context.raw.viewportMode = mode;
		if (Context.useDeferred()) {
			RenderPath.active.commands = RenderPathDeferred.commands;
		}
		else {
			if (RenderPathForward.path == null) {
				RenderPathForward.init(RenderPath.active);
			}
			RenderPath.active.commands = RenderPathForward.commands;
		}
		let _workspace = UIHeader.worktab.position;
		UIHeader.worktab.position = 0;
		MakeMaterial.parseMeshMaterial();
		UIHeader.worktab.position = _workspace;
	}

	static loadEnvmap = () => {
		if (!Context.raw.envmapLoaded) {
			// TODO: Unable to share texture for both radiance and envmap - reload image
			Context.raw.envmapLoaded = true;
			Data.cachedImages.delete("World_radiance.k");
		}
		Scene.active.world.loadEnvmap((_) => {});
		if (Context.raw.savedEnvmap == null) Context.raw.savedEnvmap = Scene.active.world.envmap;
	}

	static updateEnvmap = () => {
		if (Context.raw.showEnvmap) {
			Scene.active.world.envmap = Context.raw.showEnvmapBlur ? Scene.active.world.probe.radianceMipmaps[0] : Context.raw.savedEnvmap;
		}
		else {
			Scene.active.world.envmap = Context.raw.emptyEnvmap;
		}
	}

	// @:keep
	static setViewportShader = (viewportShader: (ns: NodeShader)=>string) => {
		Context.raw.viewportShader = viewportShader;
		Context.setRenderPath();
	}

	static setRenderPath = () => {
		if (Context.raw.renderMode == RenderMode.RenderForward || Context.raw.viewportShader != null) {
			if (RenderPathForward.path == null) {
				RenderPathForward.init(RenderPath.active);
			}
			RenderPath.active.commands = RenderPathForward.commands;
		}
		else {
			RenderPath.active.commands = RenderPathDeferred.commands;
		}
		App.notifyOnInit(() => {
			MakeMaterial.parseMeshMaterial();
		});
	}

	static enableImportPlugin = (file: string): bool => {
		// Return plugin name suitable for importing the specified file
		if (BoxPreferences.filesPlugin == null) {
			BoxPreferences.fetchPlugins();
		}
		let ext = file.substr(file.lastIndexOf(".") + 1);
		for (let f of BoxPreferences.filesPlugin) {
			if (f.startsWith("import_") && f.indexOf(ext) >= 0) {
				Config.enablePlugin(f);
				Console.info(f + " " + tr("plugin enabled"));
				return true;
			}
		}
		return false;
	}

	static setSwatch = (s: TSwatchColor) => {
		Context.raw.swatch = s;
	}

	///if is_lab
	static runBrush = (from: i32) => {
		let left = 0.0;
		let right = 1.0;

		// First time init
		if (Context.raw.lastPaintX < 0 || Context.raw.lastPaintY < 0) {
			Context.raw.lastPaintVecX = Context.raw.paintVec.x;
			Context.raw.lastPaintVecY = Context.raw.paintVec.y;
		}

		let nodes = UINodes.getNodes();
		let canvas = UINodes.getCanvas(true);
		let inpaint = nodes.nodesSelectedId.length > 0 && nodes.getNode(canvas.nodes, nodes.nodesSelectedId[0]).type == "InpaintNode";

		// Paint bounds
		if (inpaint &&
			Context.raw.paintVec.x > left &&
			Context.raw.paintVec.x < right &&
			Context.raw.paintVec.y > 0 &&
			Context.raw.paintVec.y < 1 &&
			!Base.isDragging &&
			!Base.isResizing &&
			!Base.isScrolling() &&
			!Base.isComboSelected()) {

			let down = Input.getMouse().down() || Input.getPen().down();

			// Prevent painting the same spot
			let sameSpot = Context.raw.paintVec.x == Context.raw.lastPaintX && Context.raw.paintVec.y == Context.raw.lastPaintY;
			if (down && sameSpot) {
				Context.raw.painted++;
			}
			else {
				Context.raw.painted = 0;
			}
			Context.raw.lastPaintX = Context.raw.paintVec.x;
			Context.raw.lastPaintY = Context.raw.paintVec.y;

			if (Context.raw.painted == 0) {
				Context.parseBrushInputs();
			}

			if (Context.raw.painted <= 1) {
				Context.raw.pdirty = 1;
				Context.raw.rdirty = 2;
			}
		}
	}

	static parseBrushInputs = () => {
		if (!Context.raw.registered) {
			Context.raw.registered = true;
			App.notifyOnUpdate(Context.update);
		}

		Context.raw.paintVec = Context.raw.coords;
	}

	static update = () => {
		let mouse = Input.getMouse();
		let paintX = mouse.viewX / App.w();
		let paintY = mouse.viewY / App.h();
		if (mouse.started()) {
			Context.raw.startX = mouse.viewX / App.w();
			Context.raw.startY = mouse.viewY / App.h();
		}

		let pen = Input.getPen();
		if (pen.down()) {
			paintX = pen.viewX / App.w();
			paintY = pen.viewY / App.h();
		}
		if (pen.started()) {
			Context.raw.startX = pen.viewX / App.w();
			Context.raw.startY = pen.viewY / App.h();
		}

		if (Operator.shortcut(Config.keymap.brush_ruler + "+" + Config.keymap.action_paint, ShortcutType.ShortcutDown)) {
			if (Context.raw.lockX) paintX = Context.raw.startX;
			if (Context.raw.lockY) paintY = Context.raw.startY;
		}

		Context.raw.coords.x = paintX;
		Context.raw.coords.y = paintY;

		if (Context.raw.lockBegin) {
			let dx = Math.abs(Context.raw.lockStartX - mouse.viewX);
			let dy = Math.abs(Context.raw.lockStartY - mouse.viewY);
			if (dx > 1 || dy > 1) {
				Context.raw.lockBegin = false;
				dx > dy ? Context.raw.lockY = true : Context.raw.lockX = true;
			}
		}

		let kb = Input.getKeyboard();
		if (kb.started(Config.keymap.brush_ruler)) {
			Context.raw.lockStartX = mouse.viewX;
			Context.raw.lockStartY = mouse.viewY;
			Context.raw.lockBegin = true;
		}
		else if (kb.released(Config.keymap.brush_ruler)) {
			Context.raw.lockX = Context.raw.lockY = Context.raw.lockBegin = false;
		}

		Context.parseBrushInputs();
	}
	///end
}