/**
 * J3DRenderingPrefs -- A class that contains Java3D rendering preferences for this
 * application.
 *
 * Copyright (C) 2013-2023, Joseph A. Huwaldt. All rights reserved.
 *
 * This library is free software; you can redistribute it and/or modify it under the terms
 * of the GNU Lesser General Public License as published by the Free Software Foundation;
 * either version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful, but WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
 * PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place -
 * Suite 330, Boston, MA 02111-1307, USA. Or visit: http://www.gnu.org/licenses/lgpl.html
 */
package geomss.j3d;

import jahuwaldt.js.param.Parameter;
import java.awt.Color;
import java.util.ResourceBundle;
import javax.measure.quantity.Length;
import javax.measure.unit.SI;
import org.jogamp.java3d.*;
import org.jogamp.vecmath.Color3f;
import jahuwaldt.j3d.JColor4f;
import javolution.lang.Immutable;

/**
 * A class that contains a set of Java3D rendering preferences for this application.
 *
 * <p> Modified by: Joseph A. Huwaldt </p>
 *
 * @author Joseph A. Huwaldt, Date: December 21, 2013
 * @version June 4, 2023
 */
public class J3DRenderingPrefs implements Immutable {

    /**
     * The resource bundle for this class.
     */
    protected static final ResourceBundle RB = J3DGeomGroup.RB;

    //  The default color used when drawing points.
    private static final Color DEFAULT_POINT_COLOR = new Color(255, 0, 0, 255);   //  Default = Red
//  Default = Red

    //  The default color used when drawing lines.
    private static final Color DEFAULT_LINE_COLOR = new Color(0, 255, 0, 255);
    //  The color to use when drawing points.
     // Default = Green
    private JColor4f _pointColor;

    //  The color to use when drawing lines and curves.
    private JColor4f _lineColor = new JColor4f(DEFAULT_LINE_COLOR);

    //  The size that points are rendered in pixels.
    private int _pointSize = 2;

    //  The line width used when rendering lines and curves.
    private int _lineWidth = 1;

    //  The appearance used when rendering surfaces and point-arrays.
    private static final Appearance DEFAULT_APPEARANCE = new Appearance();

    static {
        Material material = new Material();
        material.setDiffuseColor(new Color3f(0.5F, 0.5F, 0.5F));
        material.setShininess(64.5F);   //      Set shininess to 50% of range rather than 49.6063%.
        material.setLightingEnable(true);
        PolygonAttributes polyAttrib = new PolygonAttributes();
        polyAttrib.setCullFace(PolygonAttributes.CULL_NONE);
        LineAttributes lineAttrib = new LineAttributes();
        lineAttrib.setLineWidth(1);
        DEFAULT_APPEARANCE.setPolygonAttributes(polyAttrib);
        DEFAULT_APPEARANCE.setLineAttributes(lineAttrib);
        DEFAULT_APPEARANCE.setMaterial(material);
    }
    private Appearance _srfAppearance = DEFAULT_APPEARANCE;

    //  The drawing tolerance used for rendering parametric objects.
    private Parameter<Length> _drawTol = Parameter.valueOf(0.005, SI.METER);

    /**
     * Construct a default set of rendering preferences.
     */
    public J3DRenderingPrefs() {this._pointColor = new JColor4f(DEFAULT_POINT_COLOR);
 }

    /**
     * @return the default Color used to render points.
     */
    public static Color getDefaultPointColor() {
        return DEFAULT_POINT_COLOR;
    }

    /**
     * @return the default Color used to render lines.
     */
    public static Color getDefaultLineColor() {
        return DEFAULT_LINE_COLOR;
    }

    /**
     * @return the Java3D Color4f used to render points.
     */
    JColor4f getPointColorJ3D() {
        return new JColor4f(_pointColor);
    }

    /**
     * @return the Color used to render points.
     */
    public Color getPointColor() {
        return _pointColor.get();
    }

    /**
     * Return a set of rendering preferences that are identical to this one, but with the
     * point color changed to the specified color.
     *
     * @param color The new color to use for rendering points.
     * @return A copy of this set of rendering preferences with the point color changed.
     */
    public J3DRenderingPrefs changePointColor(Color color) {
        J3DRenderingPrefs prefs = new J3DRenderingPrefs();
        copyPrefs(prefs);

        JColor4f color4f = new JColor4f(color);

        prefs._pointColor = color4f;
        return prefs;
    }

    /**
     * @return the size in pixels used for rendering points.
     */
    public int getPointSize() {
        return _pointSize;
    }

    /**
     * Return a set of rendering preferences that are identical to this one, but with the
     * point size changed to the specified value.
     *
     * @param pixels The new size, in pixels, to use for rendering points.
     * @return A copy of this set of rendering preferences with the point size changed.
     */
    public J3DRenderingPrefs changePointSize(int pixels) {
        if (pixels < 1)
            throw new IllegalArgumentException(RB.getString("pointSizeToSmall"));
        J3DRenderingPrefs prefs = new J3DRenderingPrefs();
        copyPrefs(prefs);
        prefs._pointSize = pixels;
        return prefs;
    }

    /**
     * @return the Java3D Color4f used to render lines and curves.
     */
    JColor4f getLineColorJ3D() {
        return new JColor4f(_lineColor);
    }

    /**
     * @return the Color used to render lines and curves.
     */
    public Color getLineColor() {
        return _lineColor.get();
    }

    /**
     * Return a set of rendering preferences that are identical to this one, but with the
     * line or curve color changed to the specified color.
     *
     * @param color The color to use for rendering lines and curves.
     * @return A copy of this set of rendering preferences with the line color changed.
     */
    public J3DRenderingPrefs changeLineColor(Color color) {
        J3DRenderingPrefs prefs = new J3DRenderingPrefs();
        copyPrefs(prefs);

        JColor4f color4f = new JColor4f(color);

        prefs._lineColor = color4f;
        return prefs;
    }

    /**
     * @return the width in pixels used for rendering lines and curves.
     */
    public int getLineWidth() {
        return _lineWidth;
    }

    /**
     * Return a set of rendering preferences that are identical to this one, but with the
     * line width changed to the specified value.
     *
     * @param pixels The width, in pixels, to use when rendering lines and curves.
     * @return A copy of this set of rendering preferences with the line width changed.
     */
    public J3DRenderingPrefs changeLineWidth(int pixels) {
        if (pixels < 1)
            throw new IllegalArgumentException(RB.getString("pointSizeToSmall"));
        J3DRenderingPrefs prefs = new J3DRenderingPrefs();
        copyPrefs(prefs);
        prefs._lineWidth = pixels;
        return prefs;
    }

    /**
     * @return the tolerance used when rendering parametric objects.
     */
    public Parameter<Length> getDrawTolerance() {
        return _drawTol;
    }

    /**
     * Return a set of rendering preferences that are identical to this one, but with the
     * draw tolerance changed to the specified value. This tolerance is used when
     * determining how to subdivide parametric objects for rendering. If the input value
     * is <code>null</code> or equal to <code>0</code>, it will be silently ignored.
     *
     * @param tol The geometric tolerance to use when rendering parametric objects. May
     *            not be null.
     * @return A copy of this set of rendering preferences with the draw tolerance
     *         changed.
     */
    public J3DRenderingPrefs changeDrawTolerance(Parameter<Length> tol) {
        J3DRenderingPrefs prefs = new J3DRenderingPrefs();
        copyPrefs(prefs);
        if (tol.getValue() < 0)
            tol = tol.opposite();
        prefs._drawTol = tol;
        return prefs;
    }

    /**
     * @return the Java 3D Appearance used when rendering surfaces.
     */
    public Appearance getSurfaceAppearance() {
        return (Appearance)_srfAppearance.cloneNodeComponent(true);
    }

    /**
     * Get the color (of the specified type) used to render surfaces and point-arrays.
     *
     * @param colorType The aspect or type of the surface color that is being set. If
     *                  AMBIENT_AND_DIFFUSE is passed in, then only the ambient color is
     *                  returned!
     * @return The color used for the specified type of surface color. Alpha is ignored.
     * @see #getSurfaceAlpha
     */
    public Color getSurfaceColor(SurfaceColorType colorType) {

        //      Retrieve the appearance and material.
        Appearance appearance = _srfAppearance;
        Material material = appearance.getMaterial();

        //      Get the specified color.
        Color3f color3f = new Color3f();
        switch (colorType) {
            case AMBIENT:
            case AMBIENT_AND_DIFFUSE:
                material.getAmbientColor(color3f);
                break;
            case DIFFUSE:
                material.getDiffuseColor(color3f);
                break;
            case EMISSIVE:
                material.getEmissiveColor(color3f);
                break;
            case SPECULAR:
                material.getSpecularColor(color3f);
                break;
        }

        //      Return as an AWT color object.
        return new Color(color3f.getX(), color3f.getY(), color3f.getZ(), 1F);
    }

    /**
     * Return a set of rendering preferences that are identical to this one, but with the
     * specified type of color used to render surfaces and point-arrays changed.
     *
     * @param colorType The aspect or type of the surface color that is being set.
     * @param color     The color to use for the specified type of surface color. The
     *                  alpha, if present, is ignored.
     * @return A copy of this set of rendering preferences with the surface color changed.
     * @see #changeSurfaceAlpha
     */
    public J3DRenderingPrefs changeSurfaceColor(SurfaceColorType colorType, Color color) {
        J3DRenderingPrefs prefs = new J3DRenderingPrefs();
        copyPrefs(prefs);

        //  Copy the surface appearance data.
        prefs._srfAppearance = (Appearance)prefs._srfAppearance.cloneNodeComponent(true);

        float red = color.getRed() / 255F;
        float green = color.getGreen() / 255F;
        float blue = color.getBlue() / 255F;

        //      Retrieve the appearance and material.
        Appearance appearance = prefs._srfAppearance;
        Material material = appearance.getMaterial();

        //      Set the material color.
        switch (colorType) {
            case AMBIENT:
                material.setAmbientColor(red, green, blue);
                break;
            case DIFFUSE:
                material.setDiffuseColor(red, green, blue);
                break;
            case AMBIENT_AND_DIFFUSE:
                material.setAmbientColor(red, green, blue);
                material.setDiffuseColor(red, green, blue);
                break;
            case EMISSIVE:
                material.setEmissiveColor(red, green, blue);
                break;
            case SPECULAR:
                material.setSpecularColor(red, green, blue);
                break;
        }

        return prefs;
    }

    /**
     * Get the alpha or transparency used when rendering surfaces or point-arrays.
     *
     * @return The alpha value used (0.0=completely transparent, 1.0=completely opaque).
     */
    public float getSurfaceAlpha() {

        //      Get the transparency attributes (if there are any).
        TransparencyAttributes transp = _srfAppearance.getTransparencyAttributes();
        float alpha = 1;
        if (transp != null)
            alpha -= transp.getTransparency();

        return alpha;
    }

    /**
     * Return a set of rendering preferences that are identical to this one, but with the
     * alpha or transparency used to render surfaces and point-arrays changed.
     *
     * @param alpha The alpha value to use (0.0=completely transparent, 1.0=completely
     *              opaque).
     * @return A copy of this set of rendering preferences with the surface alpha changed.
     */
    public J3DRenderingPrefs changeSurfaceAlpha(float alpha) {
        J3DRenderingPrefs prefs = new J3DRenderingPrefs();
        copyPrefs(prefs);

        //  Copy the surface appearance data.
        prefs._srfAppearance = (Appearance)prefs._srfAppearance.cloneNodeComponent(true);

        //      Retrieve the appearance.
        Appearance appearance = prefs._srfAppearance;

        //      Get the transparency attributes (if there are any).
        TransparencyAttributes transp = appearance.getTransparencyAttributes();
        if (transp != null)
            transp.setTransparency(1F - alpha);
        else {
            transp = new TransparencyAttributes(TransparencyAttributes.NICEST, 1F - alpha);
            appearance.setTransparencyAttributes(transp);
        }
        if (alpha == 1)
            transp.setTransparencyMode(TransparencyAttributes.NONE);
        else
            transp.setTransparencyMode(TransparencyAttributes.NICEST);

        return prefs;
    }

    /**
     * Get the shininess used when rendering surfaces and point-arrays.
     *
     * @return The shininess to use in the range [0.0, 1.0] where 0.0 is not shiny and 1.0
     *         is very shiny.
     */
    public float getSurfaceShininess() {

        //      Retrieve the appearance and material.
        Material material = _srfAppearance.getMaterial();

        //      Get the shininess value.
        float shininess = material.getShininess();

        //      Convert the shininess from Java3D to GeomSS.
        shininess = (shininess - 1F) / 127F;
        return shininess;
    }

    /**
     * Return a set of rendering preferences that are identical to this one, but with the
     * shininess used when rendering surfaces and point-arrays changed.
     *
     * @param shininess The shininess to use in the range [0.0, 1.0] where 0.0 is not
     *                  shiny and 1.0 is very shiny. Values outside this range are
     *                  clamped.
     * @return A copy of this set of rendering preferences with the surface shininess
     *         changed.
     */
    public J3DRenderingPrefs changeSurfaceShininess(float shininess) {
        J3DRenderingPrefs prefs = new J3DRenderingPrefs();
        copyPrefs(prefs);

        //  Copy the surface appearance data.
        prefs._srfAppearance = (Appearance)prefs._srfAppearance.cloneNodeComponent(true);

        //      Convert shininess value from GeomSS to Java3D values.
        shininess = 127F * shininess + 1F;

        //      Retrieve a copy of the appearance and material.
        Material material = prefs._srfAppearance.getMaterial();

        //      Set the shininess.
        material.setShininess(shininess);

        return prefs;
    }

    /**
     * Copies over the existing set of J3D rendering preferences from this object to the
     * target one.
     */
    private void copyPrefs(J3DRenderingPrefs target) {
        target._pointColor = _pointColor;
        target._pointSize = _pointSize;
        target._lineColor = _lineColor;
        target._lineWidth = _lineWidth;
        target._srfAppearance = _srfAppearance;
        target._drawTol = _drawTol;
    }

    /**
     * Compares this J3DRenderingPrefs against the specified object for strict equality.
     *
     * @param obj the object to compare with.
     * @return <code>true</code> if this set of preferences is identical to that one;
     *         <code>false</code> otherwise.
     */
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if ((obj == null) || (obj.getClass() != this.getClass()))
            return false;

        J3DRenderingPrefs that = (J3DRenderingPrefs)obj;
        if (!this._pointColor.equals(that._pointColor))
            return false;
        if (this._pointSize != that._pointSize)
            return false;
        if (!this._lineColor.equals(that._lineColor))
            return false;
        if (this._lineWidth != that._lineWidth)
            return false;
        if (!this._drawTol.equals(that._drawTol))
            return false;
        if (this.getSurfaceAlpha() != that.getSurfaceAlpha())
            return false;
        if (this.getSurfaceShininess() != that.getSurfaceShininess())
            return false;
        if (!this.getSurfaceColor(SurfaceColorType.AMBIENT).equals(that.getSurfaceColor(SurfaceColorType.AMBIENT)))
            return false;
        if (!this.getSurfaceColor(SurfaceColorType.DIFFUSE).equals(that.getSurfaceColor(SurfaceColorType.DIFFUSE)))
            return false;
        if (!this.getSurfaceColor(SurfaceColorType.EMISSIVE).equals(that.getSurfaceColor(SurfaceColorType.EMISSIVE)))
            return false;

        return this.getSurfaceColor(SurfaceColorType.SPECULAR).equals(that.getSurfaceColor(SurfaceColorType.SPECULAR));
    }

    /**
     * Returns the hash code for this set of preferences.
     *
     * @return the hash code value.
     */
    @Override
    public int hashCode() {
        int hash = 7;

        hash = hash * 31 + _pointColor.hashCode();
        hash = hash * 31 + _pointSize;
        hash = hash * 31 + _lineColor.hashCode();
        hash = hash * 31 + _lineWidth;
        hash = hash * 31 + _srfAppearance.hashCode();
        hash = hash * 31 + _drawTol.hashCode();

        return hash;
    }

}