package Fractals.PythagorasTree;

import Fractals.NumberCalculation.Fibonacci;

/**
 * Class Fractals.PythagorasTree.PythagorasTriangle
 *
 * @author Jan Christian Grünhage
 */
public class PythagorasTriangle {
    private double leftSizeFactor;
    private double leftAngle;
    private double rightSizeFactor;
    private double rightAngle;
    boolean irregularRandom;

    public PythagorasTriangle(PythagorasTree.PythagorasTreeVariant variant, int momentaryDepth, Fibonacci fibonacci, Double angle) {

        irregularRandom = false;

        switch (variant) {


            case SymetricPythagorasTree:
                leftAngle = 45;
                break;


            case AsymetricPythagorasTree:
                if (angle < 0 || angle > 90) return;
                leftAngle = angle;
                break;


            case RegularRandomPythagorasTree:
                leftAngle = Math.random() * 50 + 20;
                break;


            case RandomPythagorasTree:
                leftAngle = 0;
                irregularRandom = true;
                //Calculation in here doesn't matter, will get overridden later.
                break;


            case PisanoPythagorasTreeOne:
                leftAngle = (fibonacci.calcFibonacci(momentaryDepth) % 4) * 10 + 30;
                break;


            case PisanoPythagorasTreeTwo:
                leftAngle = (fibonacci.calcFibonacci(momentaryDepth) % 2) * 30 + 30;
                break;


            case PisanoPythagorasTreeThree:
                leftAngle = (fibonacci.calcFibonacci(momentaryDepth) % 7) * 5 + 30;
                break;


            case PisanoPythagorasTreeFour:
                leftAngle = (fibonacci.calcFibonacci(momentaryDepth) % 31) + 30;
                break;


            case PisanoPythagorasTreeFive:
                leftAngle = (fibonacci.calcFibonacci(momentaryDepth) % 9) * 4 + 29;
                break;

            case KilianEhrmannPythagorasTree:
                leftAngle = kilianEhrmannAngle(momentaryDepth);
                break;
            default:
                leftAngle = 45;
                break;
        }
        rightAngle = (double) 90 - leftAngle;
        leftSizeFactor = Math.sin(Math.toRadians(leftAngle));
        rightSizeFactor = Math.sin(Math.toRadians(rightAngle));
    }

    private double kilianEhrmannAngle(int index) {
        if (index == 0 || index == 1) index = 2;
        double result_1;
        double result_2;
        result_1 = 100000000 * Math.pow(index, (1 / 13));
        result_2 = 70000 % index;
        result_2 = Math.cos(Math.tan(result_2));
        result_2 = index - Math.pow(result_2, 3);
        result_2 *= index + (1 / (Math.pow(index, (1 / 17.3))));
        result_2 = Math.pow(result_2, (1 / index));
        result_1 /= result_2;
        result_1 = result_1 % 30;
        result_1 += 30;
        System.out.println("Calculationdepth: " + index);
        return result_1;
    }

    public double getLeftSizeFactor() {
        return leftSizeFactor;
    }

    public double getLeftAngle() {
        if (irregularRandom) {
            leftAngle = Math.random() * 50 + 20;
            rightAngle = (double) 90 - leftAngle;
            leftSizeFactor = Math.sin(Math.toRadians(leftAngle));
            rightSizeFactor = Math.sin(Math.toRadians(rightAngle));
        }
        return leftAngle;
    }

    public double getRightSizeFactor() {
        return rightSizeFactor;
    }

    public double getRightAngle() {
        return rightAngle;
    }
}