import { Utils } from '../common/Utils';
import { Object3D } from './Object3D';
import { EventType } from '../const';
import { MathUtils } from '../math/MathUtils';

/**
 * @class BaseModelObject3D
 * The base model object 3D. 3d模型对象的基类
 * @memberof THING
 * @extends THING.Object3D
 * @public
 */
class BaseModelObject3D extends Object3D {

	/**
	 * 3D模型对象基类，负责3D模型对象的基础功能实现
	 * @param {object} param 初始化参数
	 */
	constructor(param) {
		super(param);
	}

	hasResource() {
		return true;
	}

	onSetupResource(param) {
		this.onSetupURL(param);

		// Setup components
		const components = param['components'];
		const toolkit = param['toolkit'];
		if (components && toolkit) {
			this.onImportComponents(components, toolkit, param);
		}

		if (!this.isDynamicLoad) {
			let node = this.app.resourceManager.parseModel(this.type, param);
			this.body.setNode(node);

			this.onLoadComplete();
		}
	}

	onLoadRenderableResource(options, resolve, reject) {
		if (this.hasResource()) {
			let node = this.app.resourceManager.parseModel(this.type, this.options);
			this.body.setNode(node);
		}
		resolve();
	}

	onCreateBodyNode(type) {
		return Utils.createObject('Node', { app: this.app });
	}

	onCollectMesh() {
		// All base model object 3D resource creation is dynamic, so skip to collect mesh when export
		return false;
	}

	_processBodyWithoutPivot(callback) {
		let pivot = this.pivot;
		let isEqualPivot = MathUtils.equalsVector3(pivot, [0.5, 0.5, 0.5]);
		if (!isEqualPivot) {
			this.pivot = null;
		}

		callback(this.body);

		if (!isEqualPivot) {
			this.pivot = pivot;
		}
	}

	/**
	 * Check whether it's BaseModelObject3D type or inherit from it.
	 * @type {boolean}
	 * @example
	 * let obj = new THING.BaseModelObject3D();
	 * let ret = obj.isBaseModelObject3D;
	 * // @expect(ret == true)
	 */
	get isBaseModelObject3D() {
		return true;
	}

}

export { BaseModelObject3D }