/**
 * J3DGenScreenNote -- A Java3D node that represents a GenScreenNote in a J3D scene graph.
 *
 * Copyright (C) 2014-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.GenScreenNote;
import geomss.geom.GeomPoint;
import jahuwaldt.j3d.BGFGImage;
import java.awt.*;
import java.awt.image.BufferedImage;
import static java.util.Objects.requireNonNull;
import javax.measure.unit.SI;
import org.jogamp.java3d.*;
import org.jogamp.vecmath.*;

/**
 * A Java 3D node that represents a GenScreenNote in a Java 3D scene graph.
 *
 * <p> Modified by: Joseph A. Huwaldt </p>
 *
 * @author Joseph A. Huwaldt, Date: February 7, 2014
 * @version June 4, 2023
 */
public class J3DGenScreenNote extends J3DGeomGroup<GenScreenNote> {

    //  The switch for main or mirrored geometry.
    private Switch _symmSG;

    //  The overlay used to render the text to the screen.
    private final MyOverlay _overlay;

    /**
     * Construct a J3DGenScreenNote using the specified GenScreenNote as a reference.
     *
     * @param canvas   The canvas that the note is rendered into.
     * @param geometry The GeomSS geometry to be turned into a Java3D node.
     */
    public J3DGenScreenNote(GeomSSCanvas3D canvas, GenScreenNote geometry) {
        super(requireNonNull(canvas), requireNonNull(geometry));

        //  Create a overlay that renders the text of the note on the screen.
        GeomPoint location = geometry.getLocation().to(SI.METER);               //      Convert all geometry to meters.
        int dims = location.getPhyDimension();
        double x = location.getValue(0);
        double y = (dims > 1 ? location.getValue(1) : 0);
        double z = (dims > 2 ? location.getValue(2) : 0);
        Point3d location3d = new Point3d(x, y, z);
        _overlay = new MyOverlay(location3d, geometry);

        //  Add the overlay to the canvas.
        getCanvas3D().addOverlay(_overlay);
    }

    /**
     * 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 does not affect the output
     * of "isMirrored()".
     *
     * @param mirrored Flag indicating if the mirrored geometry should be displayed or
     *                 not.
     * @see #setMirrored(boolean)
     * @see #isMirrored()
     */
    @Override
    protected void internalSetMirrored(boolean mirrored) {
        if (mirrored)
            _symmSG.setWhichChild(Switch.CHILD_ALL);
        else
            _symmSG.setWhichChild(0);
    }

    /**
     * Create a new Java 3D <code>Group</code> that contains the geometry contained in
     * this object. This method is called from <code>createSceneGraph</code>.
     *
     * @return New Java 3D Group that contains the geometry in this object.
     * @see #createSceneGraph
     */
    @Override
    protected Group createGeometry() {
        J3DRenderingPrefs drawPrefs = getRenderingPrefs();

        //      Create a point array with a single point in it.
        GenScreenNote thisNote = this.getGeomElement();
        PointArray pointA = new PointArray(1, PointArray.COORDINATES | PointArray.COLOR_4);
        GeomPoint location = thisNote.getLocation().to(SI.METER);               //      Convert all geometry to meters.
        int dims = location.getPhyDimension();
        double x = location.getValue(0);
        double y = (dims > 1 ? location.getValue(1) : 0);
        double z = (dims > 2 ? location.getValue(2) : 0);
        Point3d location3d = new Point3d(x, y, z);
        pointA.setCoordinate(0, location3d);
        //pointA.setColor(0, drawPrefs.getPointColorJ3D());

        //  Set the color to be transparent.  Makes the point invisible, but still pickable.
        pointA.setColor(0, new Color4f(0f, 0f, 0f, 0f));

        //      Create a 3D shape from the point array
        Shape3D pointShape = new GeomShape3D(thisNote, pointA);
        Appearance pApp = new Appearance();
        pointShape.setAppearance(pApp);
        pApp.setPointAttributes(new PointAttributes(drawPrefs.getPointSize(), true));

        //      Add the basic unmirrored geometry to the switch.
        _symmSG = new Switch();
        _symmSG.setCapability(Switch.ALLOW_SWITCH_READ);
        _symmSG.setCapability(Switch.ALLOW_SWITCH_WRITE);
        _symmSG.addChild(pointShape);

        //      Clone the basic geometry to make the mirrored geometry.
        Node mirrored = pointShape.cloneTree();

        //      Create a mirror across the XZ plane of symmetry transform.
        Transform3D symmT = new Transform3D();
        symmT.setScale(new Vector3d(1, -1, 1));
        TransformGroup symmTG = new TransformGroup(symmT);

        //      Add the mirrored geometry to the symmetry transform group.
        symmTG.addChild(mirrored);

        //      Add the mirrored geometry to the switch.
        _symmSG.addChild(symmTG);

        //      By default, display only the main geometry (not the mirrored).
        _symmSG.setWhichChild(0);

        return _symmSG;
    }

    /**
     * Creates a new instance of the node. This routine is called by
     * <code>cloneTree</code> to duplicate the current node.
     *
     * @param forceDuplicate when set to <code>true</code>, causes the
     *                       <code>duplicateOnCloneTree</code> flag to be ignored. When
     *                       <code>false</code>, the value of each node's
     *                       <code>duplicateOnCloneTree</code> variable determines whether
     *                       NodeComponent data is duplicated or copied.
     * @return A new instance of this Java3D node.
     */
    @Override
    public Node cloneNode(boolean forceDuplicate) {
        J3DGenScreenNote node = new J3DGenScreenNote(getCanvas3D(), this.getGeomElement());
        node.duplicateNode(this, forceDuplicate);
        return node;
    }

    /**
     * Detaches this BranchGroup from its parent. This implementation also removes the
     * note overlay from the canvas it was rendered into.
     */
    @Override
    public void detach() {
        super.detach();

        //  Remove our overlay from the rendering canvas.
        getCanvas3D().removeOverlay(_overlay);

        //  Force J3DGeomGroupFactory to create a new J3DGenScreenNote the next time
        //  the note is drawn, by removing it from the notes meta-data.
        getGeomElement().removeUserData(USERDATA_KEY);
    }

    /**
     * An overlay image that contains the rendered text for the screen note.
     */
    private final class MyOverlay implements BGFGImage {

        private final Point3d modelPoint;
        private final String noteString;
        private final Font noteFont;

        //  The ascent and overall height of the font in pixels.
        private int ascent, height, width;

        //  The X,Y location of the model point when projected onto the screen.
        private int px, py;

        //  Stored for efficiency to prevent wasteful object creation.
        private BufferedImage bufImg;
        private final Rectangle imgBounds = new Rectangle();
        private final Rectangle canvasBounds = new Rectangle();

        //  Used as optimizations to get3DTo2DPoint() to prevent wastefull object creation.
        private final Transform3D T_VL = new Transform3D();   //  Vworld wrt Local
        private final Transform3D T_IV = new Transform3D();   //  ImagePlate wrt Vworld
        private final Point3d _p3d = new Point3d();           //  A temporary point3d object.

        public MyOverlay(Point3d point, GenScreenNote note) {
            modelPoint = point;
            noteString = note.getNote();
            noteFont = note.getFont();
        }

        /**
         * Returns the overlay used to show a drag rectangle.
         */
        @Override
        public synchronized BufferedImage getImage() {
            GeomSSCanvas3D canvas = getCanvas3D();
            if (bufImg == null) {
                //  The buffered image doesn't exist, so create it.

                //  Measure the note string.
                FontMetrics fm = canvas.getFontMetrics(noteFont);
                ascent = fm.getAscent();
                height = fm.getHeight();
                width = fm.stringWidth(noteString);

                //  TYPE_INT_ARGB is required to get transparency.  However, the buffer only gets
                //  rendered as a square with the given width no matter the height specified.
                //  So, this is using the max of width & height to work around this problem
                //  which must be a bug in Java3D(?).
                int max = Math.max(width, height);
                bufImg = new BufferedImage(max, max, BufferedImage.TYPE_INT_ARGB);
                Graphics2D g2d = bufImg.createGraphics();

                //  Clear the buffer to transparent.
                clearSurface(g2d, max, max);

                //  Render the text into the buffered image.
                Color textColor = SystemColor.textText;
                g2d.setPaint(textColor);
                g2d.setFont(noteFont);
                g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
                        RenderingHints.VALUE_TEXT_ANTIALIAS_GASP);
                g2d.drawString(noteString, 0, ascent);
                //g2d.drawLine(0,ascent,0,ascent);
            }

            //  Convert the model space 3D point to a screen pixel location.
            Point2d p2d = get3DTo2DPoint(modelPoint);
            px = (int)Math.round(p2d.getX());
            py = (int)Math.round(p2d.getY());

            //  Is this inside the displayed area of the canvas?
            imgBounds.x = px;
            imgBounds.y = py;
            imgBounds.width = width;
            imgBounds.height = height;
            canvas.getBounds(canvasBounds);
            canvasBounds.x = 0;
            canvasBounds.y = 0;
            if (canvasBounds.intersects(imgBounds)) {
                //  Return the buffered image.
                return bufImg;
            }

            //  If the point is outside the canvas, then return nothing.
            return null;
        }

        /**
         * Returns the X coordinate of the upper left corner of the image.
         */
        @Override
        public int getImageX() {
            return px;
        }

        /**
         * Return the Y coordinate of the upper left corner of the drag rectangle.
         */
        @Override
        public int getImageY() {
            return py - ascent;
        }

        /**
         * Clears the buffered image to be 100% transparent.
         */
        private void clearSurface(Graphics2D drawg2d, int width, int height) {
            drawg2d.setComposite(AlphaComposite.getInstance(AlphaComposite.CLEAR, 0.0f));
            drawg2d.fillRect(0, 0, width + 1, height + 1);
            drawg2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 1.0f));
        }

        /**
         * Converts a 3D point in model space to it's projected 2D screen coordinate
         * location.
         *
         * @param point3d The 3D model space point to be projected.
         * @return the 2D projected pixel location on the screen of the 3D point
         *         projection.
         */
        private Point2d get3DTo2DPoint(Point3d point3d) {
            _p3d.set(point3d);      //  Must defensively copy the input point.

            //  Get the required transforms.
            _symmSG.getChild(0).getLocalToVworld(T_VL);
            GeomSSCanvas3D canvas = getCanvas3D();
            canvas.getVworldToImagePlate(T_IV);

            //  Convert from local coordinates to image plate coordinates.
            //  T_IL = T_IV * T_VL = ImagePlate wrt Local
            T_IV.mul(T_VL);
            T_IV.transform(_p3d);

            //  Convert from image plate to AWT pixel locations.
            Point2d point2d = new Point2d();
            canvas.getPixelLocationFromImagePlate(_p3d, point2d);

            return point2d;
        }
    }
}