package org.opentrafficsim.draw.lane;

import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.geom.Path2D;
import java.awt.image.ImageObserver;
import java.lang.reflect.Field;
import java.rmi.RemoteException;
import java.util.LinkedHashSet;
import java.util.Set;

import javax.naming.NamingException;

import org.djutils.exceptions.Try;
import org.opentrafficsim.core.geometry.OTSLine3D;
import org.opentrafficsim.core.geometry.OTSPoint3D;
import org.opentrafficsim.core.gtu.GTU;
import org.opentrafficsim.road.gtu.lane.perception.LaneStructureRecord;
import org.opentrafficsim.road.gtu.lane.perception.RollingLaneStructure;
import org.opentrafficsim.road.gtu.lane.perception.RollingLaneStructureRecord;
import org.opentrafficsim.road.gtu.lane.perception.RollingLaneStructureRecord.RecordLink;

import nl.tudelft.simulation.dsol.animation.D2.Renderable2D;
import nl.tudelft.simulation.language.d3.DirectedPoint;

/**
 * LaneStructureAnimation.java. <br>
 * <br>
 * Copyright (c) 2003-2019 Delft University of Technology, Jaffalaan 5, 2628 BX Delft, the Netherlands. All rights reserved. See
 * for project information <a href="https://www.simulation.tudelft.nl/" target="_blank">www.simulation.tudelft.nl</a>. The
 * source code and binary code of this software is proprietary information of Delft University of Technology.
 * @author <a href="https://www.tudelft.nl/averbraeck" target="_blank">Alexander Verbraeck</a>
 */
public class LaneStructureAnimation extends Renderable2D<LaneStructureLocatable>
{
    /** Destroyed. */
    private boolean isDestroyed = false;

    /**
     * @param source LaneStructureLocatable; dummy locatable
     * @throws NamingException on naming exception
     * @throws RemoteException on remote exception
     */
    LaneStructureAnimation(final LaneStructureLocatable source) throws NamingException, RemoteException
    {
        super(source, source.getGtu().getSimulator());
        this.setFlip(false);
        this.setRotate(false);
    }

    /** {@inheritDoc} */
    @Override
    public void paint(final Graphics2D graphics, final ImageObserver observer) throws RemoteException
    {
        if (!this.isDestroyed)
        {
            if (getSource().getGtu().isDestroyed())
            {
                this.isDestroyed = true;
                Try.execute(() -> destroy(), "Exception during deletion of LaneStructureAnimation.");
                return;
            }
            else
            {
                LaneStructureRecord rt = getSource().getRollingLaneStructure().getRootRecord();
                if (rt != null)
                {
                    paintRecord(rt, graphics);
                }
            }
        }
    }

    /**
     * @param lsr LaneStructureRecord; record
     * @param graphics Graphics2D; graphics
     */
    @SuppressWarnings({ "unchecked" })
    private void paintRecord(final LaneStructureRecord lsr, final Graphics2D graphics)
    {
        // line
        DirectedPoint loc = Try.assign(() -> getSource().getLocation(), "Unable to return location.");
        graphics.setStroke(new BasicStroke(
                getSource().getRollingLaneStructure().animationAccess.getCrossSectionRecords().containsValue(lsr) ? 1.0f
                        : 0.5f));
        graphics.setColor(
                getSource().getRollingLaneStructure().animationAccess.getCrossSectionRecords().containsValue(lsr) ? Color.PINK
                        : getSource().getRollingLaneStructure().animationAccess.getUpstreamEdge().contains(lsr) ? Color.MAGENTA
                                : getSource().getRollingLaneStructure().animationAccess.getDownstreamEdge().contains(lsr)
                                        ? Color.GREEN : Color.CYAN);
        OTSLine3D line = Try.assign(() -> lsr.getLane().getCenterLine().extractFractional(0.1, 0.9),
                "Exception while painting LaneStructures");
        Path2D.Double path = new Path2D.Double();
        boolean start = true;
        for (OTSPoint3D point : line.getPoints())
        {
            if (start)
            {
                path.moveTo(point.x - loc.x, -(point.y - loc.y));
                start = false;
            }
            else
            {
                path.lineTo(point.x - loc.x, -(point.y - loc.y));
            }
        }
        graphics.draw(path);
        // connection
        Field sourceField = Try.assign(() -> RollingLaneStructureRecord.class.getDeclaredField("source"),
                "Exception while painting LaneStructure");
        sourceField.setAccessible(true);
        LaneStructureRecord src =
                Try.assign(() -> (LaneStructureRecord) sourceField.get(lsr), "Exception while painting LaneStructure");
        if (src != null)
        {
            Field sourceLinkField = Try.assign(() -> RollingLaneStructureRecord.class.getDeclaredField("sourceLink"),
                    "Exception while painting LaneStructure");
            sourceLinkField.setAccessible(true);
            RecordLink link = (RecordLink) Try.assign(() -> sourceLinkField.get(lsr), "Exception while painting LaneStructure");
            float f1 = link.equals(RecordLink.DOWN) ? 0.9f : link.equals(RecordLink.UP) ? 0.1f : 0.5f;
            float f2 = link.equals(RecordLink.DOWN) ? 0.0f : link.equals(RecordLink.UP) ? 1.0f : 0.5f;
            f1 = src.getDirection().isPlus() ? f1 : 1.0f - f1;
            f2 = lsr.getDirection().isPlus() ? f2 : 1.0f - f2;
            float f3 = f1;
            float f4 = f2;
            DirectedPoint p1 = Try.assign(() -> src.getLane().getCenterLine().getLocationFraction(f3),
                    "Exception while painting LaneStructure");
            DirectedPoint p2 = Try.assign(() -> line.getLocationFraction(f4), "Exception while painting LaneStructure");
            path = new Path2D.Double();
            path.moveTo(p1.x - loc.x, -(p1.y - loc.y));
            path.lineTo(p2.x - loc.x, -(p2.y - loc.y));
            graphics.setStroke(
                    new BasicStroke(0.15f, BasicStroke.CAP_SQUARE, BasicStroke.JOIN_MITER, 10f, new float[] { .3f, 1.2f }, 0f));
            graphics.setColor(Color.DARK_GRAY);
            graphics.draw(path);
        }
        // left/right
        paintLateralConnection(lsr, lsr.getLeft(), Color.RED, graphics, loc);
        paintLateralConnection(lsr, lsr.getRight(), Color.BLUE, graphics, loc);
        // recursion to depending records
        Field dependentField = Try.assign(() -> RollingLaneStructureRecord.class.getDeclaredField("dependentRecords"),
                "Exception while painting LaneStructure");
        dependentField.setAccessible(true);
        Set<LaneStructureRecord> dependables =
                (Set<LaneStructureRecord>) Try.assign(() -> dependentField.get(lsr), "Exception while painting LaneStructure");
        if (dependables != null)
        {
            for (LaneStructureRecord dependable : new LinkedHashSet<>(dependables)) // concurrency
            {
                paintRecord(dependable, graphics);
            }
        }
    }

    /**
     * Paint the connection to a lateral record.
     * @param main LaneStructureRecord; main record
     * @param adj LaneStructureRecord; adjacent record, can be {@code null}
     * @param color Color; color
     * @param graphics Graphics2D; graphics
     * @param loc DirectedPoint; location
     */
    private void paintLateralConnection(final LaneStructureRecord main, final LaneStructureRecord adj, final Color color,
            final Graphics2D graphics, final DirectedPoint loc)
    {
        if (adj == null)
        {
            return;
        }
        float f1 = main.getDirection().isPlus() ? 0.45f : 0.55f;
        float f2 = adj.getDirection().isPlus() ? 0.55f : 0.45f;
        DirectedPoint p1 = Try.assign(() -> main.getLane().getCenterLine().getLocationFraction(f1),
                "Exception while painting LaneStructure");
        DirectedPoint p2 = Try.assign(() -> adj.getLane().getCenterLine().getLocationFraction(f2),
                "Exception while painting LaneStructure");
        Path2D.Double path = new Path2D.Double();
        path.moveTo(p1.x - loc.x, -(p1.y - loc.y));
        path.lineTo(p2.x - loc.x, -(p2.y - loc.y));
        graphics.setStroke(
                new BasicStroke(0.05f, BasicStroke.CAP_SQUARE, BasicStroke.JOIN_MITER, 10f, new float[] { .15f, 0.6f }, 0f));
        graphics.setColor(color);
        graphics.draw(path);
    }

    /**
     * Enables visualization of this lane structure. This is purely for debugging purposes.
     * @param rollingLaneStructure RollingLaneStructure; the lane structure to visualize
     * @param gtu GTU; GTU to animate the LaneStructure of
     */
    public static final void visualize(final RollingLaneStructure rollingLaneStructure, final GTU gtu)
    {
        Try.execute(() -> new LaneStructureAnimation(new LaneStructureLocatable(rollingLaneStructure, gtu)),
                "Could not create animation.");
    }

}