/**
 * J3DGeomGroup -- A Java3D node that represents a GeomElement in a J3D scene graph.
 *
 * Copyright (C) 2009-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 geomss.app.GeomSSCanvas3D;
import geomss.geom.GeomElement;
import jahuwaldt.js.param.Parameter;
import java.awt.Color;
import static java.util.Objects.requireNonNull;
import java.util.ResourceBundle;
import javax.measure.quantity.Length;
import org.jogamp.java3d.BranchGroup;
import org.jogamp.java3d.Group;
import org.jogamp.java3d.Switch;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import javolution.lang.Immutable;

/**
 * A Java 3D node that represents a GeomElement in a Java 3D scene graph.
 *
 * <p> Modified by: Joseph A. Huwaldt </p>
 *
 * @author Joseph A. Huwaldt, Date: April 13, 2009
 * @version June 4, 2023
 *
 * @param <T> The type of GeomElement represented by this object.
 */
public abstract class J3DGeomGroup<T extends GeomElement> extends BranchGroup {

    /**
     * The resource bundle for this class and it's descendants.
     */
    static final ResourceBundle RB
            = ResourceBundle.getBundle("geomss.j3d.J3DResources", java.util.Locale.getDefault());

    /**
     * The key used to store this instance in the user data of the supplied GeomElement
     * object.
     */
    public static final String USERDATA_KEY = "J3DGeomGroup";

    //  Store the globally active rendering preferences.
    private static J3DRenderingPrefs _defDrawPrefs = new J3DRenderingPrefs();

    //  Store the rendering preferences used to render this object.
    private final J3DRenderingPrefs _drawPrefs;

    //  Reference to the geometry for this geometry group.
    private T _geometry;

    //  The display group containing the geometry.
    private Switch _dispG;

    //  Indicates of the mirrored version of this geometry is displayed.
    private boolean _mirrored = false;

    //  The RenderType used for this geometry.
    private RenderType _renderType = RenderType.SOLID_PLUS_WIREFRAME;

    //  Store the old group so it can potentially be used again in the future.
    private final J3DGeomGroup<T> _oldJ3DGroup;

    //  A reference to the Canvas3D that this geometry list is being rendered into.
    private final GeomSSCanvas3D _canvas;

    /**
     * Construct a J3DGeomGroup using the specified GeomElement as a reference.
     *
     * @param canvas   The canvas that the geometry is being rendered into.
     * @param geometry The GeomSS geometry to be turned into a Java3D node.
     */
    @SuppressWarnings({"OverridableMethodCallInConstructor", "LeakingThisInConstructor"})
    public J3DGeomGroup(GeomSSCanvas3D canvas, T geometry) {
        _geometry = requireNonNull(geometry);
        _canvas = requireNonNull(canvas);
        _drawPrefs = _defDrawPrefs;

        if (!(geometry instanceof Immutable)) {
            //  Add a change listener to the geometry and remove this group from the geometry
            //  if the geometry changes.
            _geometry.addChangeListener(new ChangeListener() {
                @Override
                public void stateChanged(ChangeEvent e) {
                    _geometry.removeUserData(USERDATA_KEY);
                    _geometry.removeChangeListener(this);
                }
            });
        }

        this.setCapability(BranchGroup.ALLOW_DETACH);
        this.setCapability(Group.ALLOW_CHILDREN_READ);

        //      Get any existing J3DGeomGroups in this geometry.
        _oldJ3DGroup = (J3DGeomGroup)geometry.getUserData(USERDATA_KEY);

        //      Create the scene graph for this group.
        createSceneGraph();

        //      Make sure this group has the same properties as the old one (if it exists).
        if (_oldJ3DGroup != null) {
            this.setMirrored(_oldJ3DGroup.isMirrored());
            this.setDisplayed(_oldJ3DGroup.isDisplayed());
            this.setRenderType(_oldJ3DGroup.getRenderType());
        }
        
                //      Store a reference to this group in the geometry element's user data
        //      (replacing any old data).
        geometry.putUserData(USERDATA_KEY, this);
    }

    /**
     * @return The canvas that this geometry is being rendered into.
     */
    protected GeomSSCanvas3D getCanvas3D() {
        return _canvas;
    }
    
    /**
     * @return the J3DGeomGroup that was used to render this geometry element previously
     *         (if any). If this geometry has not been rendered previously,
     *         <code>null</code> will be returned.
     */
    protected J3DGeomGroup<T> getOldJ3DGeomGroup() {
        return _oldJ3DGroup;
    }

    /**
     * @return the {@link GeomElement} that this group represents in the scene graph.
     */
    public T getGeomElement() {
        return _geometry;
    }

    /**
     * @return the geometry group containing the scene graph for this GeomGroup. This
     *         returns the same object that was created by "createSceneGraph()".
     * @see #createSceneGraph()
     */
    protected Group getSceneGraph() {
        return (Group)_dispG.getChild(0);
    }

    /**
     * Create a 3D scene group to represent the geometry.
     *
     * @see #getSceneGraph()
     */
    private void createSceneGraph() {

        //      Create a switch group so that sub-elements can be turned on or off.
        _dispG = new Switch(Switch.CHILD_ALL);
        _dispG.setCapability(Switch.ALLOW_SWITCH_READ);
        _dispG.setCapability(Switch.ALLOW_SWITCH_WRITE);

        //      Create the geometry itself.
        Group geomG = createGeometry();
        _dispG.addChild(requireNonNull(geomG));

        //      Add the root to this group.
        this.addChild(_dispG);
    }

    /**
     * Returns the display setting of this geometry group.
     *
     * @return true if the geometry is being displayed and false if it is not displayed.
     */
    public boolean isDisplayed() {
        return _dispG.getWhichChild() != Switch.CHILD_NONE;
    }

    /**
     * Sets the display of this geometry group to either displayed (true) or not displayed
     * (false). Subclasses that override this method should call "super.setDisplayed()" to
     * maintain proper state and object display.
     *
     * @param visible Flag indicating if the geometry is displayed or not.
     */
    public void setDisplayed(boolean visible) {
        if (visible) {
            _dispG.setWhichChild(Switch.CHILD_ALL);
            if (_mirrored)
                internalSetMirrored(true);
        } else {
            _dispG.setWhichChild(Switch.CHILD_NONE);
            if (_mirrored)
                internalSetMirrored(false);
        }
    }

    /**
     * Set the display of a copy of this geometry mirrored across the XZ plane to either
     * DISPLAYED (true) or NOT_DISPLAYED (false). Subclasses that override this method
     * should call "super.setMirrored(mirrored)" to maintain proper state information.
     *
     * @param mirrored Flag indicating if the mirrored geometry should be displayed or
     *                 not.
     * @see #isMirrored()
     * @see #internalSetMirrored(boolean)
     */
    public void setMirrored(boolean mirrored) {
        _mirrored = mirrored;
        internalSetMirrored(mirrored);
    }

    /**
     * Returns a flag indicating if the geometry display is currently mirrored about the
     * XZ plane of symmetry or not.
     *
     * @return true if mirroring across the XZ plane is being DISPLAYED and false if it is
     *         NOT_DISPLAYED.
     * @see #setMirrored(boolean)
     */
    public boolean isMirrored() {
        return _mirrored;
    }

    /**
     * Set the render type used for this group. Sub-classes must provide specific
     * implementations that depend on the implementation of the geometry and must call
     * "super.setRenderType()" to properly maintain state.
     *
     * @param type Value indicating the way that some objects should be rendered.
     * @see #getRenderType()
     */
    public void setRenderType(RenderType type) {
        _renderType = requireNonNull(type);
    }

    /**
     * Return the render type used for this group. Sub-classes must provide specific
     * implementations that depend on the the geometry being rendered.
     *
     * @return The render type used for this Group.
     * @see #setRenderType(geomss.j3d.RenderType)
     */
    public RenderType getRenderType() {
        return _renderType;
    }

    /**
     * @return the currently active rendering preferences that will be used to render
     *         future objects.
     */
    public static J3DRenderingPrefs getDefaultRenderingPrefs() {
        return _defDrawPrefs;
    }

    /**
     * Set the currently active rendering preferences that will be used to render future
     * objects.
     *
     * @param prefs The rendering preferences to make current.
     */
    public static void setDefaultRenderingPrefs(J3DRenderingPrefs prefs) {
        _defDrawPrefs = requireNonNull(prefs);
    }

    /**
     * @return the rendering preferences that were used, in the past, to render this
     *         object.
     */
    public J3DRenderingPrefs getRenderingPrefs() {
        return _drawPrefs;
    }

    /**
     * Set the color to use when rendering points. This is a convenience method for
     * <code>J3DGeomGroup.setDefaultRenderingPrefs(getDefaultRenderingPrefs().changePointColor(color))</code>.
     *
     * @param color The Color to use for rending Point objects in the future.
     */
    public static void setPointColor(Color color) {
        _defDrawPrefs = _defDrawPrefs.changePointColor(requireNonNull(color));
    }

    /**
     * Set the color to use when rendering curves and lines. This is a convenience method
     * for
     * <code>J3DGeomGroup.setDefaultRenderingPrefs(getDefaultRenderingPrefs().changeLineColor(color))</code>.
     *
     * @param color The Color to use for rending lines and curves objects in the future.
     */
    public static void setLineColor(Color color) {
        _defDrawPrefs = _defDrawPrefs.changeLineColor(requireNonNull(color));
    }

    /**
     * Set the size that Point objects are rendered in pixels. This is a convenience
     * method for
     * <code>J3DGeomGroup.setDefaultRenderingPrefs(getDefaultRenderingPrefs().changePointSize(pixels))</code>.
     *
     * @param pixels The size, in pixels, to use when rendering points in the future.
     * @throws IllegalArgumentException if the point size provided is &lt; 1 pixel.
     */
    public static void setPointSize(int pixels) {
        _defDrawPrefs = _defDrawPrefs.changePointSize(pixels);
    }

    /**
     * Set the width that line/curve objects are rendered in pixels. This is a convenience
     * method for
     * <code>J3DGeomGroup.setDefaultRenderingPrefs(getDefaultRenderingPrefs().changeLineWidth(pixels))</code>.
     *
     * @param pixels The width, in pixels, to use when rendering lines/curves in the
     *               future.
     * @throws IllegalArgumentException if the line size provided is &lt; 1 pixel.
     */
    public static void setLineWidth(int pixels) {
        _defDrawPrefs = _defDrawPrefs.changeLineWidth(pixels);
    }

    /**
     * Set the tolerance used when drawing parametric objects such as curves and surfaces.
     * 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. This is a convenience method for
     * <code>J3DGeomGroup.setDefaultRenderingPrefs(getDefaultRenderingPrefs().changeDrawTolerance(tol))</code>.
     *
     * @param tol The geometric tolerance to use when rendering parametric objects.
     */
    public static void setDrawTolerance(Parameter<Length> tol) {
        _defDrawPrefs = _defDrawPrefs.changeDrawTolerance(requireNonNull(tol));
    }

    /**
     * Set the display of a mirrored copy of this geometry. This is called from
     * "setDisplayed()" to turn on and off the display of mirrored geometry without
     * changing the "mirrored state" of the object. This call should not affect the output
     * of "isMirrored()".
     * <p>
     * Subclasses should override this to turn on or off a mirrored geometry in response
     * to the main geometry being set to displayed or not-displayed. The default
     * implementation does nothing.
     * </p>
     *
     * @param mirrored Flag indicating if the mirrored geometry should be displayed or
     *                 not.
     * @see #setMirrored(boolean)
     * @see #isMirrored() 
     */
    protected void internalSetMirrored(boolean mirrored) {
    }

    /**
     * Create a new Java 3D <code>Group</code> that contains the geometry contained in
     * this object. This method is called from <code>createSceneGraph</code>. Sub-classes
     * must over-ride this method to provide geometry specific implementations.
     *
     * @return New Java 3D Group that contains the geometry in this object.
     * @see #createSceneGraph
     */
    protected abstract Group createGeometry();

}