/*
 * Copyright (c) 2022, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code 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 General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

/* @test
 * @summary Pass if app exits without error code
 * @bug 8264999
 */

import java.awt.*;
import java.io.*;
import java.util.List;
import java.util.ArrayList;
import java.awt.geom.*;
import javax.imageio.*;
import java.awt.image.*;

/**
 * This tests redundant line segments. That is: if you draw a line from A to B, and then a line from
 * B to B, then the expected behavior is for the last redundant segment to NOT affect the miter stroke.
 */
public class JoinMiterRedundantLineSegmentsTest {

    public static void main(String[] args) throws Exception {
        System.out.println("This test defines a series of shapes with optional shape data. The optional data (which is enclosed in brackets) should not make a difference in how the shape is rendered. This test renders the shape data with and without the bracketed segments and tests to see if those renderings are identical.");

        List<Test> tests = createTests();
        int sampleCtr = 1;
        boolean[] booleans = new boolean[] {false, true};
        boolean failed = false;
        String header = null;
        for (Test test : tests) {
            header = null;

            for (Object strokeHint : new Object[] { RenderingHints.VALUE_STROKE_PURE, RenderingHints.VALUE_STROKE_NORMALIZE } ) {
                for (boolean createStrokedShape : booleans) {
                    for (boolean closePath : booleans) {
                        try {
                            test.run(strokeHint, createStrokedShape, closePath);
                        } catch(TestException e) {
                            failed = true;

                            if (header == null) {
                                System.out.println();

                                header = "#############################\n";
                                header += "## " + test.name + "\n";
                                header += "## " + test.description + "\n";
                                header += "## " + test.shapeString + "\n";
                                header += "#############################";
                                System.out.println(header);
                            }

                            System.out.println();
                            System.out.println("# sample index = " + (sampleCtr));
                            System.out.println("strokeHint = " + strokeHint);
                            System.out.println("createStrokedShape = " + createStrokedShape);
                            System.out.println("closePath = " + closePath);
                            System.out.println("FAILED");
                            e.printStackTrace(System.out);
                            BufferedImage bi = e.getImage();
                            File file = new File("failure-"+sampleCtr+".png");
                            ImageIO.write(bi, "png", file);
                        }

                        sampleCtr++;
                    }
                }
            }
        }

        if (failed)
            System.exit(1);
    }

    private static List<Test> createTests() {
        List<Test> tests = new ArrayList<>();

        tests.add(new Test("Redundant diagonal line endpoint",
                "m 0 0 l 10 10 [l 10 10]",
                "This creates a diagonal line with a redundant endpoint; this is the core problem demonstrated in JDK-8264999."));

        tests.add(new Test("jdk-8264999",
                "m 24.954517 159 l 21.097446 157.5 [l 21.097446 157.5] l 17.61364 162 [l 17.61364 162] l 13.756569 163.5 [l 13.756569 163.5] l 11.890244 160.5",
                "This is the original shape reported in https://bugs.openjdk.org/browse/JDK-8264999"));

        tests.add(new Test("2x and 3x redundant lines",
                "m 24.954517 159 l 21.097446 157.5 [l 21.097446 157.5 l 21.097446 157.5] l 17.61364 162 [l 17.61364 162 l 17.61364 162 l 17.61364 162] l 13.756569 163.5 [l 13.756569 163.5 l 13.756569 163.5 l 13.756569 163.5] l 11.890244 160.5",
                "This is a derivative of JDK-8264999 that includes two or three redundant lines (instead of just one)."));

        tests.add(new Test("cubic curve with redundant line",
                "m 17 100 c 7 130 27 130 17 100 [l 17 100]",
                "This creates a simple cubic curve (a teardrop shape) with one redundant line at the end."));

        tests.add(new Test("degenerate cubic curve",
                "m 19 180 l 20 181 [c 20 181 20 181 20 181]",
                "This creates a degenerate cubic curve after the last end point."));

        tests.add(new Test("degenerate quadratic curve",
                "m 19 180 l 20 181 [q 20 181 20 181]",
                "This creates a degenerate quadratic curve after the last end point."));

        // This test reaches the line in Stroker.java where we detect a change of (+0, +0)
        // and manually change the dx:
        // dx = 1.0d;

//        tests.add(new Test("Redundant lineTo after moveTo",
//                "m 0 0 [l 0 0] l 10 10",
//                "This creates a diagonal line that may include a redundant lineTo after the moveTo"));

        // This test does NOT reach the same "dx = 1.0d" line. I'm not sure what the expected behavior here is.

//        tests.add(new Test("lineTo after close",
//                "m 0 0 z [l 10 10]",
//                "This tests a lineTo after a close (but without a second moveTo)"));

        // The following 2 tests fail because the mitered stroke covers different ares.
        // They might (?) be working as expected, and I just don't understand the expected behavior?

//        tests.add(new Test("Diagonal line, optional lineTo back",
//                "m 0 0 l 20 20 [l 0 0]",
//                "This creates a diagonal line and optionally returns to the starting point."));
//
//        tests.add(new Test("Diagonal line, optional close",
//                "m 0 0 l 20 20 l 0 0 [z]",
//                "This creates a diagonal line, returns to the starting point, and optionally closes the path."));

        // We've decided the following commented-out tests are invalid. The current interpretation is:
        // "a moveTo statement without any additional information should NOT result in rendering anything"

//        tests.add(new Test("empty line",
//                "m 19 180 [l 19 180]",
//                "This creates an empty shape with a lineTo the starting point."));
//
//        tests.add(new Test("empty degenerate cubic curve",
//                "m 19 180 [c 19 180 19 180 19 180]",
//                "This creates an empty degenerate cubic curve that is effectively a line to the starting point."));
//
//        tests.add(new Test("empty degenerate quadratic curve",
//                "m 19 180 [q 19 180 19 180]",
//                "This creates an empty degenerate quadratic curve that is effectively a line to the starting point."));
//
//        tests.add(new Test("moveTo then close",
//                "m 19 180 [z]",
//                "This moves to a starting position and then optionally closes the path."));

        return tests;
    }
}

class TestException extends Exception {
    BufferedImage bi;

    public TestException(Throwable t, BufferedImage bi) {
        super(t);
        this.bi = bi;
    }

    public BufferedImage getImage() {
        return bi;
    }
}

class Test {
    Path2D path_expected, path_actual;
    String name, description, shapeString;

    /**
     * @param name a short name of this test
     * @param shape shape data, including optional phrases in brackets. The shape should render the same
     *              whether the data in brackets is included or not.
     * @param description a sentence describing this test
     */
    public Test(String name, String shape, String description) {
        // make sure the test contains optional path data. Because if it doesn't: this test
        // is meaningless because nothing will change.
        if (!shape.contains("["))
            throw new IllegalArgumentException("The shape must contain optional path data.");

        this.shapeString = shape;
        this.name = name;
        this.description = description;
        path_expected = parse(shape, false);
        path_actual = parse(shape, true);
    }

    @Override
    public String toString() {
        return name;
    }

    private String stripBracketPhrases(String str) {
        StringBuffer sb = new StringBuffer();
        int ctr = 0;
        for (int a = 0; a < str.length(); a++) {
            char ch = str.charAt(a);
            if (ch == '[') {
                ctr++;
            } else if (ch == ']') {
                ctr--;
            } else if (ctr == 0) {
                sb.append(ch);
            }
        }
        return sb.toString();
    }

    private Path2D.Double parse(String str, boolean includeBrackets) {
        if (includeBrackets) {
            str = str.replace('[', ' ');
            str = str.replace(']', ' ');
        } else {
            str = stripBracketPhrases(str);
        }
        Path2D.Double path = new Path2D.Double();
        String[] terms = str.split(" ");
        int a = 0;
        while (a < terms.length) {
            if ("m".equals(terms[a])) {
                path.moveTo(Double.parseDouble(terms[a + 1]), Double.parseDouble(terms[a + 2]));
                a += 3;
            } else if ("l".equals(terms[a])) {
                path.lineTo( Double.parseDouble(terms[a+1]), Double.parseDouble(terms[a+2]) );
                a += 3;
            } else if ("q".equals(terms[a])) {
                path.quadTo( Double.parseDouble(terms[a+1]), Double.parseDouble(terms[a+2]),
                        Double.parseDouble(terms[a+3]), Double.parseDouble(terms[a+4]) );
                a += 5;
            } else if ("c".equals(terms[a])) {
                path.curveTo( Double.parseDouble(terms[a+1]), Double.parseDouble(terms[a+2]),
                        Double.parseDouble(terms[a+3]), Double.parseDouble(terms[a+4]),
                        Double.parseDouble(terms[a+5]), Double.parseDouble(terms[a+6]) );
                a += 7;
            } else if ("z".equals(terms[a])) {
                path.closePath();
                a += 1;
            } else if(terms[a].trim().isEmpty()) {
                a += 1;
            } else {
                throw new RuntimeException("\""+terms[a]+"\" in \""+str+"\"");
            }
        }
        return path;
    }

    public void run(Object strokeRenderingHint, boolean createStrokedShape, boolean closePath) throws Exception {
        BufferedImage bi_expected = new BufferedImage(400, 400, BufferedImage.TYPE_INT_ARGB);
        BufferedImage bi_actual = new BufferedImage(400, 400, BufferedImage.TYPE_INT_ARGB);

        paint(path_expected, bi_expected, Color.black, strokeRenderingHint, createStrokedShape, closePath);
        paint(path_actual, bi_actual, Color.black, strokeRenderingHint, createStrokedShape, closePath);

        try {
            assertEquals(bi_expected, bi_actual);
        } catch(Exception e) {
            BufferedImage composite = new BufferedImage(400, 400, BufferedImage.TYPE_INT_ARGB);
            paint(path_expected, composite, Color.blue, strokeRenderingHint, createStrokedShape, closePath);
            paint(path_actual, composite, new Color(255,0,0,100), strokeRenderingHint, createStrokedShape, closePath);
            throw new TestException(e, composite);
        }
    }

    /**
     * Throw an exception if two images are not equal.
     */
    private static void assertEquals(BufferedImage bi1, BufferedImage bi2) {
        int w = bi1.getWidth();
        int h = bi1.getHeight();
        int[] row1 = new int[w];
        int[] row2 = new int[w];
        for (int y = 0; y < h; y++) {
            bi1.getRaster().getDataElements(0,y,w,1,row1);
            bi2.getRaster().getDataElements(0,y,w,1,row2);
            for (int x = 0; x < w; x++) {
                if (row1[x] != row2[x])
                    throw new RuntimeException("failure at ("+x+", "+y+"): 0x"+Integer.toHexString(row1[x])+" != 0x"+Integer.toHexString(row2[x]));
            }
        }
    }

    /**
     * Create a transform that maps from one rectangle to another.
     */
    private AffineTransform createTransform(Rectangle2D oldRect,Rectangle2D newRect) {
        double scaleX = newRect.getWidth() / oldRect.getWidth();
        double scaleY = newRect.getHeight() / oldRect.getHeight();

        double translateX = -oldRect.getX() * scaleX + newRect.getX();
        double translateY = -oldRect.getY() * scaleY + newRect.getY();
        return new AffineTransform(scaleX, 0, 0, scaleY, translateX, translateY);
    }

    /**
     * Paint a path to an image.
     */
    private void paint(Path2D path, BufferedImage dst, Color color, Object strokeRenderingHint,
                       boolean createStrokedShape, boolean closePath) {
        Rectangle2D pathBounds = path.getBounds2D();
        pathBounds.setFrame(pathBounds.getX() - 10,
                pathBounds.getY() - 10,
                pathBounds.getWidth() + 20,
                pathBounds.getHeight() + 20);
        Rectangle imageBounds = new Rectangle(0, 0, dst.getWidth(), dst.getHeight());

        Path2D p = new Path2D.Double();
        p.append(path, false);
        if (closePath)
            p.closePath();

        Graphics2D g = dst.createGraphics();
        g.transform(createTransform(pathBounds, imageBounds));
        g.setColor(color);
        g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        g.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL, strokeRenderingHint);
        Stroke stroke = new BasicStroke(3);
        if (createStrokedShape) {
            g.fill( stroke.createStrokedShape(p) );
        } else {
            g.setStroke(stroke);
            g.draw(p);
        }
        g.dispose();
    }
}