package org.simantics.district.network.ui.nodes;

import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.Stroke;
import java.awt.geom.AffineTransform;
import java.awt.geom.Path2D;
import java.awt.geom.Point2D;
import java.awt.geom.Rectangle2D;

import org.simantics.district.network.ModelledCRS;
import org.simantics.district.network.ui.DistrictNetworkEdge;
import org.simantics.scenegraph.g2d.G2DNode;
import org.simantics.scenegraph.utils.GeometryUtils;
import org.simantics.scenegraph.utils.NodeUtil;

public class DistrictNetworkEdgeNode extends G2DNode {

    private static final long serialVersionUID = 8049769475036519806L;
    
    private static final Stroke     SELECTION_STROKE = new BasicStroke(1f, BasicStroke.CAP_BUTT, BasicStroke.JOIN_MITER);
    private static final Color      SELECTION_COLOR  = new Color(255, 0, 255, 96);
    
    private DistrictNetworkEdge edge;
    private Rectangle2D bounds;
    
    private static final Stroke STROKE = new BasicStroke(4, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND);
    private boolean scaleStroke = true;

    private Color color;

    @Override
    public void init() {
    }
    
    @Override
    public void render(Graphics2D g2d) {
        
        AffineTransform ot = null;
        AffineTransform t = getTransform();
        if (t != null && !t.isIdentity()) {
            ot = g2d.getTransform();
            g2d.transform(getTransform());
        }
        
        Object aaHint = g2d.getRenderingHint(RenderingHints.KEY_ANTIALIASING);
        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

        Color oldColor = g2d.getColor();
        BasicStroke oldStroke = (BasicStroke) g2d.getStroke();
//        boolean selected = isSelected();
//        if (selected) {
//            Path2D selectionPath = edge.getPath();
//            Shape selectionShape = SELECTION_STROKE.createStrokedShape(selectionPath);
//            g2d.setColor(SELECTION_COLOR);
//            g2d.fill(selectionShape);
//        }
//        
        g2d.setColor(color);
        if (STROKE != null) {
            if (scaleStroke && STROKE instanceof BasicStroke) {
                BasicStroke bs = GeometryUtils.scaleStroke(STROKE, (float) (1.0 / GeometryUtils.getScale(g2d.getTransform())));
                g2d.setStroke(bs);
            } else {
                g2d.setStroke(STROKE);
            }
        }

        g2d.draw(calculatePath(edge));
        
        // Reset
        g2d.setStroke(oldStroke);
        g2d.setColor(oldColor);
        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, aaHint);
        
        if (ot != null)
            g2d.setTransform(ot);
    }
    
    public static Path2D calculatePath(DistrictNetworkEdge edge) {
        // Convert to screen coordinates
        double startX = ModelledCRS.longitudeToX(edge.getStartPoint().getX());
        double startY = ModelledCRS.latitudeToY(edge.getStartPoint().getY());
        double endX = ModelledCRS.longitudeToX(edge.getEndPoint().getX());
        double endY = ModelledCRS.latitudeToY(edge.getEndPoint().getY());
        
        // render
        Path2D path = new Path2D.Double();
        path.moveTo(startX, startY);
        path.lineTo(endX, endY);
        return path;
    }

    private boolean isSelected() {
        return NodeUtil.isSelected(this, 1);
    }

    @Override
    public Rectangle2D getBoundsInLocal() {
        return bounds;
    }
    
    private void updateBounds() {
        Rectangle2D oldBounds = bounds;
        if (oldBounds == null)
            oldBounds = new Rectangle2D.Double();
        bounds = calculateBounds(oldBounds);
    }

    private Rectangle2D calculateBounds(Rectangle2D rect) {
        return calculatePath(edge).getBounds2D();
    }

    public void setDNEdge(DistrictNetworkEdge edge) {
        this.edge = edge;
        updateBounds();
    }

    public void setColor(Color color) {
        this.color = color;
    }
    
    public Color getColor() {
        return color;
    }

}