import java.applet.Applet;
import java.awt.AlphaComposite;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionListener;
import java.awt.AlphaComposite;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionListener;


public class OhTannenbaum extends Applet implements MouseMotionListener{
    final public int STARTPOINTCOUNT = 15;
    final public int STARTPOINTS[][] = new int [STARTPOINTCOUNT][2];
    final public int APPLETWIDTH = 640;
    final public int APPLETHEIGHT = 480;
    public int maxDisplacement = 3;
    public int tannenbaumRepeats = 10;
    public int drawedPoints[][][] = new int[100][STARTPOINTCOUNT][2];

    /**
     * Initialisierung des Applets
     */
    public void init() {
        // Fenstergröße des Applets einstellen
        setSize(APPLETWIDTH,APPLETHEIGHT);
        // Die Startpunkte für die Form des Tannenbaums
        STARTPOINTS[0][0] = 300; STARTPOINTS[0][1] = 400;
        STARTPOINTS[1][0] = 200; STARTPOINTS[1][1] = 400;
        STARTPOINTS[2][0] = 200; STARTPOINTS[2][1] = 350;
        STARTPOINTS[3][0] = 50;  STARTPOINTS[3][1] = 350;
        STARTPOINTS[4][0] = 150; STARTPOINTS[4][1] = 250;
        STARTPOINTS[5][0] = 100; STARTPOINTS[5][1] = 250;
        STARTPOINTS[6][0] = 200; STARTPOINTS[6][1] = 150;
        STARTPOINTS[7][0] = 150; STARTPOINTS[7][1] = 150;
        STARTPOINTS[8][0] = 250; STARTPOINTS[8][1] = 50;
        STARTPOINTS[9][0] = 350; STARTPOINTS[9][1] = 150;
        STARTPOINTS[10][0] = 300; STARTPOINTS[10][1] = 150;
        STARTPOINTS[11][0] = 400; STARTPOINTS[11][1] = 250;
        STARTPOINTS[12][0] = 350; STARTPOINTS[12][1] = 250;
        STARTPOINTS[13][0] = 450; STARTPOINTS[13][1] = 350;
        STARTPOINTS[14][0] = 300; STARTPOINTS[14][1] = 350;
        drawedPoints[0] = STARTPOINTS;
        //STARTPOINTS = scalePointPosition(STARTPOINTS,0.7f);
        // Applet wird selbst als MouseMotionListener angemeldet, so dass es auf Maus-Ereignisse hoert
        addMouseMotionListener(this);
    }


    /**
     * Zeichen der Figur
     *
     * @param g Grafik-Kontext des Applets, auf den gezeichnet wird
     */
    public void paint(Graphics g){
        // Casting des Grafik-Kontextes, so dass man auch Antialiasing verwenden kann
        Graphics2D g2d = (Graphics2D)g;

        // setze dann wirklich den ANTIALIASING-Modus fuer das Zeichnen
        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

        // definiere die Transparenz als Alpha-Wert, mit der gezeichnet werden soll
        AlphaComposite ac1 = AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.21f);
        g2d.setComposite(ac1);
        // Mit den Startkoordinaten des Tannenbaums anfangen
        int recentlyDrawedPoints[][] = STARTPOINTS;
        // und dann kann das Zeichnen auch endlich losgehen
        for (int i = 0; i < tannenbaumRepeats; i++) {
            recentlyDrawedPoints = STARTPOINTS;
            recentlyDrawedPoints = calculatePointPosition(STARTPOINTS, maxDisplacement, 1);
            for (int j = 0; j < recentlyDrawedPoints.length; j++) {
                int nextPoint = j+1;
                if (nextPoint >= recentlyDrawedPoints.length) {
                    nextPoint = 0;
                }
                g2d.drawLine(recentlyDrawedPoints[j][0], recentlyDrawedPoints[j][1], recentlyDrawedPoints[nextPoint][0], recentlyDrawedPoints[nextPoint][1]);
            }
        }
    }

    // Berechnet die Abweichung der übergebenen Figur "figure" mit der maximalen Abweichung "randomFactor".
    public int[][] calculatePointPosition(int figure[][], int randomFactor, int calculateRepeats) {
        if (randomFactor == 0) {
            return figure;
        }
        for (int i = 0; i < calculateRepeats; i++) {
            for (int j = 0; j < figure.length; j++) {
                figure[j][0]+=(int)(Math.random()*maxDisplacement*2-maxDisplacement);
                figure[j][1]+=(int)(Math.random()*maxDisplacement*2-maxDisplacement);
            }
        }
        return figure;
    }

    // Berechnet die Skalierung der übergebenen Figur "figure" mit dem Skalierungsfaktor "scaleFactor".
    public int[][] scalePointPosition(int figure[][], float scaleFactor) {
        if (scaleFactor <= 0) {
            return figure;
        }
        for (int i = 0; i < figure.length; i++) {
            figure[i][0]*=scaleFactor;
            figure[i][1]*=scaleFactor;
        }
        return figure;
    }

    // Berechnet die Translation (Verschiebung) der übergebenen Figur "figure" mit dem X-Wert "translateX" und dem Y-Wert "translateY"
    public int[][] translatePointPosition(int figure[][], int translateX, int translateY) {
        if (translateX == 0 && translateY == 0) {
            return figure;
        }
        for (int i = 0; i < figure.length; i++) {
            figure[i][0]+=translateX;
            figure[i][1]+=translateY;
        }
        return figure;
    }

    /**
     * Maus-Bewegung steuert die Berechnung der Figur und stoesst den Zeichenprozess neu an.
     *
     * @param e Event-Objekt, in dem die Informationen über die Maus-Position stehen
     */
    @Override
    public void mouseDragged(MouseEvent e) {
        /* diese Methode muss zwar da sein, falls ein passendes Ereignis passiert,
         *  aber es wird in dem Fall nichts gemacht
         */
    }

    /**
     * Maus-Bewegung steuert die Berechnung der Figur und stoesst den Zeichenprozess neu an.
     *
     * @param e Event-Objekt, in dem die Informationen über die Maus-Position stehen
     */
    @Override
    public void mouseMoved(MouseEvent e) {
        int x;
        int y;

        // Hole die Koordinaten der Maus aus dem Event
        x = e.getX();
        y = e.getY();

        /* berechne Faktor von 0 (linke Seite) bis 1 (rechte Seite).
         * Um die Breite des Fensters fuer die Berechnung zu kann man
         * die Methode getWidth() aufrufen, die dann die Breite in Pixel
         * zurueck gibt.
         */

        // mit dem neuen Faktor sollte man dann die Figur auch neu berechnen


        // und wenn alles neu berechnet wurde, wird das Zeichnen mit repaint() angestossen
        repaint();
    }

}