/**
 * GameLib.D3.Material.Phong
 * @param graphics
 * @param apiMaterialPhong
 * @constructor
 */
GameLib.D3.Material.Phong = function(
    graphics,
    apiMaterialPhong
) {
    this.graphics = graphics;
    this.graphics.isNotThreeThrow();

    if (GameLib.Utils.UndefinedOrNull(apiMaterialPhong)) {
        apiMaterialPhong = {
            materialType : GameLib.D3.API.Material.MATERIAL_TYPE_PHONG
        };
    }

    GameLib.D3.API.Material.Phong.call(
        this,
		apiMaterialPhong,
		apiMaterialPhong.alphaMap,
		apiMaterialPhong.aoMap,
		apiMaterialPhong.aoMapIntensity,
		apiMaterialPhong.bumpMap,
		apiMaterialPhong.bumpScale,
		apiMaterialPhong.color,
		apiMaterialPhong.combine,
		apiMaterialPhong.displacementMap,
		apiMaterialPhong.displacementScale,
		apiMaterialPhong.displacementBias,
		apiMaterialPhong.emissive,
		apiMaterialPhong.emissiveMap,
		apiMaterialPhong.emissiveIntensity,
		apiMaterialPhong.envMap,
		apiMaterialPhong.lightMap,
		apiMaterialPhong.lightMapIntensity,
		apiMaterialPhong.diffuseMap,
		apiMaterialPhong.morphNormals,
		apiMaterialPhong.morphTargets,
		apiMaterialPhong.normalMap,
		apiMaterialPhong.normalScale,
		apiMaterialPhong.reflectivity,
		apiMaterialPhong.refractionRatio,
		apiMaterialPhong.shininess,
		apiMaterialPhong.skinning,
		apiMaterialPhong.specular,
		apiMaterialPhong.specularMap,
		apiMaterialPhong.wireframe,
		apiMaterialPhong.wireframeLinecap,
		apiMaterialPhong.wireframeLinejoin,
        apiMaterialPhong.wireframeLinewidth
    );

    if (this.alphaMap instanceof GameLib.D3.API.Texture) {
        this.alphaMap = GameLib.Component.ConstructFromObject(this.alphaMap);
    }

    if (this.aoMap instanceof GameLib.D3.API.Texture) {
        this.aoMap = GameLib.Component.ConstructFromObject(this.aoMap);
    }

    if (this.bumpMap instanceof GameLib.D3.API.Texture) {
        this.bumpMap = GameLib.Component.ConstructFromObject(this.bumpMap);
    }

    this.color = new GameLib.Color(
        this.graphics,
        this.color,
        this
    );

    if (this.displacementMap instanceof GameLib.D3.API.Texture) {
        this.displacementMap = GameLib.Component.ConstructFromObject(this.displacementMap);
    }

    this.emissive = new GameLib.Color(
        this.graphics,
        this.emissive,
        this
    );

    if (this.emissiveMap instanceof GameLib.D3.API.Texture) {
        this.emissiveMap = GameLib.Component.ConstructFromObject(this.emissiveMap);
    }

    if (this.envMap instanceof GameLib.D3.API.Texture) {
        this.envMap = GameLib.Component.ConstructFromObject(this.envMap);
    }

    if (this.lightMap instanceof GameLib.D3.API.Texture) {
        this.lightMap = GameLib.Component.ConstructFromObject(this.lightMap);
    }

    if (this.diffuseMap instanceof GameLib.D3.API.Texture) {
        this.diffuseMap = GameLib.Component.ConstructFromObject(this.diffuseMap);
    }

    if (this.normalMap instanceof GameLib.D3.API.Texture) {
        this.normalMap = GameLib.Component.ConstructFromObject(this.normalMap);
    }

    this.specular = new GameLib.Color(
        this.graphics,
        this.specular,
        this
    );

    if (this.specularMap instanceof GameLib.D3.API.Texture) {
        this.specularMap = GameLib.Component.ConstructFromObject(this.specularMap);
    }
        
    GameLib.D3.Material.call(
        this,
        this.graphics,
        this
    );

};

GameLib.D3.Material.Phong.prototype = Object.create(GameLib.D3.Material.prototype);
GameLib.D3.Material.Phong.prototype.constructor = GameLib.D3.Material.Phong;

/**
 * Creates an instance of our texture object
 * @returns {*}
 */
GameLib.D3.Material.Phong.prototype.createInstance = function() {

    this.instance = new THREE.MeshPhongMaterial(
        {
			alphaMap				: this.alphaMap ? this.alphaMap.instance : null,
			aoMap				    : this.aoMap ? this.aoMap.instance : null,
			aoMapIntensity			: this.aoMapIntensity,
			bumpMap				    : this.bumpMap ? this.bumpMap.instance : null,
			bumpScale				: this.bumpScale,
			color				    : this.color.instance,
            combine                 : this.combine,
			displacementMap			: this.displacementMap ? this.displacementMap.instance : null,
			displacementScale		: this.displacementScale,
			displacementBias		: this.displacementBias,
			emissive				: this.emissive.instance,
			emissiveMap				: this.emissiveMap ? this.emissiveMap.instance : null,
			emissiveIntensity		: this.emissiveIntensity,
			envMap				    : this.envMap ? this.envMap.instance : null,
			lightMap				: this.lightMap ? this.lightMap.instance : null,
			lightMapIntensity		: this.lightMapIntensity,
			map				        : this.diffuseMap ? this.diffuseMap.instance : null,
			morphNormals			: this.morphNormals,
			morphTargets			: this.morphTargets,
			normalMap				: this.normalMap ? this.normalMap.instance : null,
            normalScale				: this.normalScale,
            reflectivity            : this.reflectivity,
			refractionRatio			: this.refractionRatio,
            shininess               : this.shininess,
			skinning				: this.skinning,
			specular				: this.specular.instance,
			specularMap			    : this.specularMap ? this.specularMap.instance : null,
			wireframe				: this.wireframe,
			wireframeLinecap		: this.wireframeLinecap,
			wireframeLinejoin		: this.wireframeLinejoin,
            wireframeLinewidth      : this.wireframeLinewidth
        }
    );
   
    GameLib.D3.Material.prototype.createInstance.call(this);
};

/**
 * Updates the instance with the current state
 */
GameLib.D3.Material.Phong.prototype.updateInstance = function(property) {

    if (property === 'alphaMap') {
        this.assignTexture('alphaMap', property);
        return;
    }

    if (property === 'aoMap') {
        this.assignTexture('aoMap', property);
        return;
    }

    if (property === 'aoMapIntensity') {
        this.instance.aoMapIntensity = this.aoMapIntensity;
        return;
    }

    if (property === 'bumpMap') {
        this.assignTexture('bumpMap', property);
        return;
    }

    if (property === 'bumpScale') {
        this.instance.bumpScale = this.bumpScale;
        return;
    }

    if (property === 'color') {
        this.instance.color = this.color.instance;
        return;
    }

    if (property === 'combine') {
        this.instance.combine = this.combine;
        this.instance.needsUpdate = true;
        return;
    }

    if (property === 'displacementMap') {
        this.assignTexture('displacementMap', property);
        return;
    }

    if (property === 'displacementScale') {
        this.instance.displacementScale = this.displacementScale;
        return;
    }

    if (property === 'displacementBias') {
        this.instance.displacementBias = this.displacementBias;
        return;
    }

    if (property === 'emissive') {
        this.instance.emissive = this.emissive.instance;
        return;
    }

    if (property === 'emissiveMap') {
        this.assignTexture('emissiveMap', property);
        return;
    }

    if (property === 'emissiveIntensity') {
        this.instance.emissiveIntensity = this.emissiveIntensity;
        return;
    }

    if (property === 'envMap') {
        this.assignTexture('envMap', property);
        return;
    }

    if (property === 'lightMap') {
        this.assignTexture('lightMap', property);
        return;
    }

    if (property === 'lightMapIntensity') {
        this.instance.lightMapIntensity = this.lightMapIntensity;
        return;
    }

    if (property === 'diffuseMap') {
        this.assignTexture('map', property);
        return;
    }

    if (property === 'morphNormals') {
        this.instance.morphNormals = this.morphNormals;
        return;
    }

    if (property === 'morphTargets') {
        this.instance.morphTargets = this.morphTargets;
        return;
    }

    if (property === 'normalMap') {
        this.assignTexture('normalMap', property);
        return;
    }

    if (property === 'normalScale') {
        this.instance.normalScale = this.normalScale;
        return;
    }

    if (property === 'reflectivity') {
        this.instance.reflectivity = this.reflectivity;
        return;
    }

    if (property === 'refractionRatio') {
        this.instance.refractionRatio = this.refractionRatio;
        return;
    }

    if (property === 'shininess') {
        this.instance.shininess = this.shininess;
        return;
    }

    if (property === 'skinning') {
        this.instance.skinning = this.skinning;
        return;
    }

    if (property === 'specular') {
        this.instance.specular = this.specular.instance;
        return;
    }

    if (property === 'specularMap') {
        this.assignTexture('specularMap', property);
        return;
    }

    if (property === 'wireframe') {
        this.instance.wireframe = this.wireframe;
        return;
    }

    if (property === 'wireframeLinecap') {
        this.instance.wireframeLinecap = this.wireframeLinecap;
        return;
    }

    if (property === 'wireframeLinejoin') {
        this.instance.wireframeLinejoin = this.wireframeLinejoin;
        return;
    }

    if (property === 'wireframeLinewidth') {
        this.instance.wireframeLinewidth = this.wireframeLinewidth;
        return;
    }

    GameLib.D3.Material.prototype.updateInstance.call(this, property);
};

/**
 * Converts a GameLib.D3.Material.Phong to a GameLib.D3.API.Material.Phong
 * @returns {GameLib.D3.API.Material.Phong}
 */
GameLib.D3.Material.Phong.prototype.toApiObject = function() {

    var apiMaterial = GameLib.D3.Material.prototype.toApiObject.call(this);

    var apiMaterialPhong = new GameLib.D3.API.Material.Phong(
        apiMaterial,
		GameLib.Utils.IdOrNull(this.alphaMap),
        GameLib.Utils.IdOrNull(this.aoMap),
		this.aoMapIntensity,
        GameLib.Utils.IdOrNull(this.bumpMap),
		this.bumpScale,
		this.color.toApiObject(),
        this.combine,
        GameLib.Utils.IdOrNull(this.displacementMap),
		this.displacementScale,
		this.displacementBias,
		this.emissive.toApiObject(),
        GameLib.Utils.IdOrNull(this.emissiveMap),
		this.emissiveIntensity,
        GameLib.Utils.IdOrNull(this.envMap),
        GameLib.Utils.IdOrNull(this.lightMap),
		this.lightMapIntensity,
        GameLib.Utils.IdOrNull(this.diffuseMap),
		this.morphNormals,
		this.morphTargets,
        GameLib.Utils.IdOrNull(this.normalMap),
		this.normalScale,
		this.reflectivity,
		this.refractionRatio,
		this.shininess,
        this.skinning,
        this.specular.toApiObject(),
        GameLib.Utils.IdOrNull(this.specularMap),
		this.wireframe,
		this.wireframeLinecap,
		this.wireframeLinejoin,
        this.wireframeLinewidth
    );

    return apiMaterialPhong;
};