import { Utils, Object3D } from '@uino/thing';

	/**
	 * 分层体积网格，用于创建具有多层结构的体积效果。
	 * @class VolumeLayeredMesh
	 * @public
	 * @memberof THING
	 * @example
	 * let volumeLayeredMesh = new THING.VolumeLayeredMesh({
	 *   width: 2,
	 *   height: 2,
	 *   depth: 2,
	 *   diskSize: [0.01, 0.01],
	 *   diskSpacing: [0.003, 0.003],
	 *   valueRange: [0, 1],
	 *   platteTexture: new THING.ImageTexture({ url: 'http://xxx.png' })
	 * });
	 */
class VolumeLayeredMesh extends Object3D {

/**
   * @constructor
   * @summary 构造函数
	 * @param {object} param - 配置参数
	 * @param {number} param.width - 体积宽度（默认值1）
	 * @param {number} param.height - 体积高度（默认值1）
	 * @param {number} param.depth - 体积深度（默认值1）
	 * @param {number} param.layerCount - 分层数量（默认值10）
	 * @param {number} param.opacityFactor - 透明度因子（默认值0.5）
	 * @param {Array} param.diskSize - 圆片大小 [x, y]（默认值[0.008, 0.008]）
	 * @param {Array} param.diskSpacing - 圆片间距 [x, y]（默认值[0.002, 0.002]）
	 * @param {Array} param.valueRange - 值范围 [min, max]（默认值[0, 1]）
	 * @param {THING.ImageTexture} param.platteTexture - 调色板纹理
	 * @param {THING.ImageTexture} param.densityTexture - 密度纹理
 */
	constructor(param) {
		super(param);

		this.scale = [param.width || 1, 1, param.depth || 1];
	}

	/**
	 *
	 * @param options
	 * @param resolve
	 * @param reject
	 *	@public
	 */
	onLoadResource(options, resolve, reject) {
		let dynamic = Utils.parseValue(options['dynamic'], false);
		if (!dynamic) {
			Utils.setTimeout(() => {
				if (this.destroyed) {
					reject(`The object had been destroyed, skip to load resources`);
				}
				else {
					let node = this.onCreateBodyNode(options);

					this.body.setNode(node);

					resolve();
				}
			});
		}
	}

	/**
	 * 创建体积分层网格的节点
	 * @param {object} params - 节点参数
	 * @param {number} params.width - 体积宽度（默认值1）
	 * @param {number} params.height - 体积高度（默认值1）
	 * @param {number} params.depth - 体积深度（默认值1）
	 * @param {Array} params.diskSize - 圆片大小 [x, y]（默认值[0.008, 0.008]）
	 * @param {Array} params.diskSpacing - 圆片间距 [x, y]（默认值[0.002, 0.002]）
	 * @param {Array} params.valueRange - 值范围 [min, max]（默认值[0, 1]）
	 * @param {THING.ImageTexture} params.platteTexture - 调色板纹理
	 * @returns {object} 创建的节点对象
	 * @private
	 */
	onCreateBodyNode(params) {
		const node = Utils.createObject('VolumeLayeredNode', {
			external: {
				node: this.node,
				width: Utils.parseValue(params.width, 1),
				height: Utils.parseValue(params.height, 1),
				depth: Utils.parseValue(params.depth, 1),
				layerCount: Utils.parseValue(params.layerCount, 10),
				layerRandom: Utils.parseValue(params.layerRandom, 0.01),
				diskSize: Utils.parseValue(params.diskSize, [0.008, 0.008]),
				diskSpacing: Utils.parseValue(params.diskSpacing, [0.002, 0.002]),
				valueRange: Utils.parseValue(params.valueRange, [0, 1]),
				colorRampTexture: params?.platteTexture?.getTextureResource(),
				densityTexture: params?.densityTexture?.getTextureResource(),
			}
		});
		return node;
	}

	/**
	 *
	 * @param data
	 *	@public
	 */
	setData(data) {
		this.node.setData(data);
	}

	/**
	 * 设置颜色渐变纹理
	 * @param {THING.ImageTexture} texture - 颜色渐变纹理
	 *	@public
	 */
	set colorRampTexture(texture) {
		this.node.setColorRampTexture(texture.getTextureResource());
	}

	/**
	 * 获取当前颜色渐变纹理
	 * @returns {THING.ImageTexture} 当前颜色渐变纹理
	 *	@public
	 */
	get colorRampTexture() {
		return this.node.getColorRampTexture();
	}

	/**
	 * 设置密度纹理
	 * @param {THING.ImageTexture} texture - 密度纹理
	 *	@public
	 */
	set densityTexture(texture) {
		this.node.setDensityTexture(texture.getTextureResource());
	}

	/**
	 * 获取当前密度纹理
	 * @returns {THING.ImageTexture} 当前密度纹理
	 *	@public
	 */
	get densityTexture() {
		return this.node.getDensityTexture();
	}

	/**
	 * 设置分层数量
	 * @param {number} count - 分层数量
	 *	@public
	 */
	set layerCount(count) {
		this.node.setLayerCount(count);
	}

	/**
	 * 获取当前分层数量
	 * @returns {number} 当前分层数量
	 *	@public
	 */
	get layerCount() {
		return this.node.getLayerCount();
	}

	/**
	 * 设置分层随机值
	 * @param {number} value - 随机值（范围0-1）
	 *	@public
	 */
	set layerRandom(value) {
		this.node.setLayerRandom(value);
	}

	/**
	 * 获取是否使用纯颜色
	 * @returns {boolean} 是否使用纯颜色
	 *	@public
	 */
	get usePureColor() {
		return this.node.getUsePureColor();
	}

	/**
	 * 设置是否使用纯颜色
	 * @type {boolean} value - 是否使用纯颜色
	 * @public
	 */
	set usePureColor(value) {
		this.node.setUsePureColor(value);
	}

	/**
	 * 获取当前分层随机值
	 * @returns {number} 当前分层随机值
	 *	@public
	 */
	get layerRandom() {
		return this.node.getLayerRandom();
	}

	/**
	 * 设置圆片大小
	 * @param {Array} value - 圆片大小 [x, y]
	 *	@public
	 */
	set diskSize(value) {
		this.node.setDiskSize(value);
	}

	/**
	 * 获取当前圆片大小
	 * @returns {Array} 当前圆片大小 [x, y]
	 *	@public
	 */
	get diskSize() {
		return this.node.getDiskSize();
	}

	/**
	 * 设置圆片间距
	 * @param {Array} value - 圆片间距 [x, y]
	 *	@public
	 */
	set diskSpacing(value) {
		this.node.setDiskSpacing(value);
	}

	/**
	 * 获取当前圆片间距
	 * @returns {Array} 当前圆片间距 [x, y]
	 *	@public
	 */
	get diskSpacing() {
		return this.node.getDiskSpacing();
	}

	/**
	 * 设置值范围
	 * @param {Array} value - 值范围 [min, max]
	 *	@public
	 */
	set valueRange(value) {
		this.node.setValueRange(value);
	}

	/**
	 * 获取当前值范围
	 * @returns {Array} 当前值范围 [min, max]
	 *	@public
	 */
	get valueRange() {
		return this.node.getValueRange();
	}

	/**
	 * 设置透明度因子
	 * @param {number} value - 透明度因子（默认值 0.5）
	 *	@public
	 */
	set opacityFactor(value) {
		this.node.setOpacityFactor(value);
	}

	/**
	 * 获取当前透明度因子
	 * @returns {number} 当前透明度因子
	 *	@public
	 */
	get opacityFactor() {
		return this.node.getOpacityFactor();
	}

}

export { VolumeLayeredMesh };