import {
	Data3DTexture,
	FloatType,
	HalfFloatType,
	LinearFilter,
	NearestFilter,
	sRGBEncoding,
	Uniform,
	Vector3
} from "three";

import { BlendFunction } from "../enums/index.js";
import { LookupTexture } from "../textures/index.js";
import { encodingToColorSpace } from "../utils/index.js";
import { Effect } from "./Effect.js";

import fragmentShader from "./glsl/lut-3d.frag";

/**
 * A LUT effect.
 *
 * The tetrahedral interpolation algorithm was inspired by an implementation from OpenColorIO which is licensed under
 * the BSD 3-Clause License.
 *
 * The manual trilinear interpolation algorithm is based on an implementation by Garret Johnson which is licensed under
 * the MIT License.
 *
 * References:
 * https://developer.nvidia.com/gpugems/gpugems2/part-iii-high-quality-rendering/chapter-24-using-lookup-tables-accelerate-color
 * https://www.nvidia.com/content/GTC/posters/2010/V01-Real-Time-Color-Space-Conversion-for-High-Resolution-Video.pdf
 * https://github.com/AcademySoftwareFoundation/OpenColorIO/blob/master/src/OpenColorIO/ops/lut3d/
 * https://github.com/gkjohnson/threejs-sandbox/tree/master/3d-lut
 */

export class LUT3DEffect extends Effect {

	/**
	 * Constructs a new color grading effect.
	 *
	 * @param {Texture} lut - The lookup texture.
	 * @param {Object} [options] - The options.
	 * @param {BlendFunction} [options.blendFunction=BlendFunction.SRC] - The blend function of this effect.
	 * @param {Boolean} [options.tetrahedralInterpolation=false] - Enables or disables tetrahedral interpolation.
	 * @param {TextureEncoding} [options.inputEncoding=sRGBEncoding] - Deprecated.
	 * @param {ColorSpace} [options.inputColorSpace=SRGBColorSpace] - The input color space.
	 */

	constructor(lut, {
		blendFunction = BlendFunction.SRC,
		tetrahedralInterpolation = false,
		inputEncoding = sRGBEncoding,
		inputColorSpace
	} = {}) {

		super("LUT3DEffect", fragmentShader, {
			blendFunction,
			uniforms: new Map([
				["lut", new Uniform(null)],
				["scale", new Uniform(new Vector3())],
				["offset", new Uniform(new Vector3())],
				["domainMin", new Uniform(null)],
				["domainMax", new Uniform(null)]
			])
		});

		this.tetrahedralInterpolation = tetrahedralInterpolation;
		this.inputColorSpace = inputColorSpace || encodingToColorSpace.get(inputEncoding);
		this.lut = lut;

	}

	/**
	 * The input encoding. Default is `sRGBEncoding`.
	 *
	 * Set this to `LinearEncoding` if your LUT expects linear color input.
	 *
	 * @deprecated Use inputColorSpace instead.
	 * @type {TextureEncoding}
	 */

	get inputEncoding() {

		return this.inputColorSpace;

	}

	set inputEncoding(value) {

		this.inputColorSpace = value;

	}

	/**
	 * Returns the input encoding.
	 *
	 * @deprecated Use inputColorSpace instead.
	 * @return {TextureEncoding} The encoding.
	 */

	getInputEncoding() {

		return this.inputColorSpace;

	}

	/**
	 * Sets the input encoding.
	 *
	 * @deprecated Use inputColorSpace instead.
	 * @param {TextureEncoding} value - The encoding.
	 */

	setInputEncoding(value) {

		this.inputColorSpace = value;

	}

	/**
	 * Returns the output encoding.
	 *
	 * @deprecated Use outputColorSpace instead.
	 * @return {TextureEncoding} The encoding.
	 */

	getOutputEncoding() {

		return this.outputColorSpace;

	}

	/**
	 * The LUT.
	 *
	 * @type {Texture}
	 */

	get lut() {

		return this.uniforms.get("lut").value;

	}

	set lut(value) {

		const defines = this.defines;
		const uniforms = this.uniforms;

		if(this.lut !== value) {

			uniforms.get("lut").value = value;

			if(value !== null) {

				const image = value.image;

				// Remember settings that are backed by defines.
				const tetrahedralInterpolation = this.tetrahedralInterpolation;

				defines.clear();
				defines.set("LUT_SIZE", Math.min(image.width, image.height).toFixed(16));
				defines.set("LUT_TEXEL_WIDTH", (1.0 / image.width).toFixed(16));
				defines.set("LUT_TEXEL_HEIGHT", (1.0 / image.height).toFixed(16));

				uniforms.get("domainMin").value = null;
				uniforms.get("domainMax").value = null;

				if(value.type === FloatType || value.type === HalfFloatType) {

					defines.set("LUT_PRECISION_HIGH", "1");

				}

				if(image.width > image.height) {

					defines.set("LUT_STRIP_HORIZONTAL", "1");

				} else if(value instanceof Data3DTexture) {

					defines.set("LUT_3D", "1");

				}

				if(value instanceof LookupTexture) {

					const min = value.domainMin;
					const max = value.domainMax;

					if(min.x !== 0 || min.y !== 0 || min.z !== 0 || max.x !== 1 || max.y !== 1 || max.z !== 1) {

						defines.set("CUSTOM_INPUT_DOMAIN", "1");
						uniforms.get("domainMin").value = min.clone();
						uniforms.get("domainMax").value = max.clone();

					}

				}

				// Refresh settings that affect the LUT.
				this.tetrahedralInterpolation = tetrahedralInterpolation;

			}

		}

	}

	/**
	 * Returns the current LUT.
	 *
	 * @deprecated Use lut instead.
	 * @return {Texture} The LUT.
	 */

	getLUT() {

		return this.lut;

	}

	/**
	 * Sets the LUT.
	 *
	 * @deprecated Use lut instead.
	 * @param {Texture} value - The LUT.
	 */

	setLUT(value) {

		this.lut = value;

	}

	/**
	 * Updates the scale and offset for the LUT sampling coordinates.
	 *
	 * @private
	 */

	updateScaleOffset() {

		const lut = this.lut;

		if(lut !== null) {

			const size = Math.min(lut.image.width, lut.image.height);
			const scale = this.uniforms.get("scale").value;
			const offset = this.uniforms.get("offset").value;

			if(this.tetrahedralInterpolation && lut instanceof Data3DTexture) {

				if(this.defines.has("CUSTOM_INPUT_DOMAIN")) {

					const domainScale = lut.domainMax.clone().sub(lut.domainMin);
					scale.setScalar(size - 1).divide(domainScale);
					offset.copy(lut.domainMin).negate().multiply(scale);

				} else {

					scale.setScalar(size - 1);
					offset.setScalar(0);

				}

			} else {

				if(this.defines.has("CUSTOM_INPUT_DOMAIN")) {

					const domainScale = lut.domainMax.clone().sub(lut.domainMin).multiplyScalar(size);
					scale.setScalar(size - 1).divide(domainScale);
					offset.copy(lut.domainMin).negate().multiply(scale).addScalar(1.0 / (2.0 * size));

				} else {

					scale.setScalar((size - 1) / size);
					offset.setScalar(1.0 / (2.0 * size));

				}

			}

		}

	}

	/**
	 * Configures parameters for tetrahedral interpolation.
	 *
	 * @private
	 */

	configureTetrahedralInterpolation() {

		const lut = this.lut;

		if(lut !== null) {

			lut.minFilter = LinearFilter;
			lut.magFilter = LinearFilter;

			if(this.tetrahedralInterpolation) {

				if(lut instanceof Data3DTexture) {

					// Interpolate samples manually.
					lut.minFilter = NearestFilter;
					lut.magFilter = NearestFilter;

				} else {

					console.warn("Tetrahedral interpolation requires a 3D texture");

				}

			}

			// TODO Added for compatibility with r138. Remove later.
			if(lut.source === undefined) {

				lut.needsUpdate = true;

			}

		}

	}

	/**
	 * Indicates whether tetrahedral interpolation is enabled. Requires a 3D LUT, disabled by default.
	 *
	 * Tetrahedral interpolation produces highly accurate results but is slower than hardware interpolation.
	 *
	 * @type {Boolean}
	 */

	get tetrahedralInterpolation() {

		return this.defines.has("TETRAHEDRAL_INTERPOLATION");

	}

	set tetrahedralInterpolation(value) {

		if(value) {

			this.defines.set("TETRAHEDRAL_INTERPOLATION", "1");

		} else {

			this.defines.delete("TETRAHEDRAL_INTERPOLATION");

		}

		this.configureTetrahedralInterpolation();
		this.updateScaleOffset();
		this.setChanged();

	}

	/**
	 * Enables or disables tetrahedral interpolation.
	 *
	 * @deprecated Use tetrahedralInterpolation instead.
	 * @param {Boolean} value - Whether tetrahedral interpolation should be enabled.
	 */

	setTetrahedralInterpolationEnabled(value) {

		this.tetrahedralInterpolation = value;

	}

}