package Fractals.PythagorasTree;

import ch.aplu.turtle.Turtle;

import Fractals.TurtleTools.TurtleState;

import java.awt.*;

import static Fractals.TurtleTools.DrawingTools.drawSquare;

/**
 * Created by Christian on 10.02.2015.
 */
public class PythagorasTree {
    private PythagorasTree rightSubTree;
    private PythagorasTree leftSubTree;
    private PythagorasTreeVariant variant;
    private PythagorasTriangleList triangles;
    private Turtle turtle;
    private double size;
    private int momentaryDepth;
    private int maximalDepth;
    private int minimalSize = 1;
    private TurtleState turtleState;

    public PythagorasTree(PythagorasTreeVariant variant, PythagorasTriangleList triangles, Turtle turtle, double size, int momentaryDepth, int maximalDepth) {
        this.variant = variant;
        this.triangles = triangles;
        this.turtle = turtle;
        this.size = size;
        this.momentaryDepth = momentaryDepth;
        this.maximalDepth = maximalDepth;
        this.turtleState = new TurtleState(turtle);
    }

    public static boolean drawNextTree(PythagorasTreeQueue queue) {
        if (queue.size() == 0) return false;
        PythagorasTree tree = queue.remove();

        if (tree.momentaryDepth > tree.maximalDepth && tree.size <= tree.minimalSize) {
            return true;
        }
        tree.turtle.getFrame().setTitle("Pythagoras Tree - Depth: " + tree.momentaryDepth + " - Target Depth: " + tree.maximalDepth + " - Queuesize: " + queue.size());

        tree.turtle.setPenColor(drawColor(tree.momentaryDepth, tree.maximalDepth));
        tree.turtleState.returnToState(tree.turtle);
        drawSquare(tree.turtle, tree.size);

        if (tree.momentaryDepth >= tree.maximalDepth && tree.size < tree.minimalSize) {
            return true;
        }

        tree.turtle.forward(tree.size);

        tree.turtle.pushState();
        tree.turtle.right(tree.triangles.getLeftAngle(tree.momentaryDepth));
        tree.rightSubTree = new PythagorasTree(tree.variant, tree.triangles, tree.turtle, tree.size * tree.triangles.getRightSizeFactor(tree.momentaryDepth), tree.momentaryDepth + 1, tree.maximalDepth);
        queue.add(tree.rightSubTree);

        tree.turtle.popState();
        tree.turtle.left(tree.triangles.getRightAngle(tree.momentaryDepth));

        tree.turtle.penUp();
        tree.turtle.forward(tree.size * tree.triangles.getRightSizeFactor(tree.momentaryDepth));
        tree.turtle.penDown();


        tree.leftSubTree = new PythagorasTree(tree.variant, tree.triangles, tree.turtle, tree.size * tree.triangles.getLeftSizeFactor(tree.momentaryDepth), tree.momentaryDepth + 1, tree.maximalDepth);
        queue.add(tree.leftSubTree);
        return true;
    }


    public static Color drawColor(int momentaryDepth, int maximalDepth) {

        double colorFactor = 255 / maximalDepth;

        int red = (int) (colorFactor * (maximalDepth - momentaryDepth));
        if (red > 139) red = 139;
        if (red < 0) red = 0;
        int green = 255 - (int) (colorFactor * (maximalDepth - momentaryDepth));
        if (green > 255) green = 255;
        if (green < 69) green = 69;
        int blue = (int) (colorFactor * ((maximalDepth - momentaryDepth) / 5));
        if (blue > 19) blue = 19;
        if (blue < 0) blue = 0;
        return new Color(red, green, blue);
    }

    public enum PythagorasTreeVariant {
        SymetricPythagorasTree, AsymetricPythagorasTree, RegularRandomPythagorasTree, RandomPythagorasTree,
        PisanoPythagorasTreeOne, PisanoPythagorasTreeTwo, PisanoPythagorasTreeThree, PisanoPythagorasTreeFour, PisanoPythagorasTreeFive,
        KilianEhrmannPythagorasTree,
        unselected,
    }
}