/*  Naam: Renee Witsenburg
 *  Studentnummer: 10001388
 *  Studie: Informatica
 */

public class Test {
    public static void main (String[] args) {
        Afstand d1 = new Afstand (10, " mm ");
        Afstand d2 = new Afstand (2.5, " cm ");
        Afstand d3 = d1.optellen(d2);

        Punt p1 = new Punt (new Afstand (10, " mm "), new Afstand (15, " mm " ));
        Punt p2 = new Punt (new Afstand (30, " mm "), new Afstand (50, " mm " ));
        Punt p3 = new Punt (new Afstand (10, " mm "), new Afstand (50, " mm " ));

        Afstand d4 = p1.aftrekken(p2);

        Vorm[] list = new Vorm[3];

        list[0] = new Lijn(p1, p2 );
        list[1] = new Rechthoek(p1, d2, d3 );
        list[2] = new Cirkel(p3, d2 );

        System.out.println (" d1 : " + d1 );
        System.out.println (" d2 : " + d2 );
        System.out.println (" d3 : " + d3 );
        System.out.println (" d4 : " + d4 );
        System.out.println (" p1 : " + p1 );
        System.out.println (" p2 : " + p2 );
        System.out.println (" p3 : " + p3 );

        for(int i = 0; i < list.length ; i++) {
            System.out.println (" list [" + i + "]: " + list[i]);
            System.out.println (" Omtrek : " + list[i].omtrek());
            System.out.println (" Oppervlakte : " + list[i].oppervlakte() + " m ˆ2 " );
        }
    }
}

/* Afstanden: een 1-dimensonaal nummer met een meeteenheid (mm, cc, m, km).
 * Afstanden kun je optellen en
 * aftrekken liet hierbij wel op mogelijk verschillende meeteenheden.
 */
class Afstand{

    double lengte;
    String eenheid;

    Afstand(double l, String eenheid) {
        lengte = l;
        this.eenheid = eenheid;
    }
    Afstand aftrekken(Afstand d2) {
        return new Afstand(this.converteren() - d2.converteren(), "m");
    }
    Afstand optellen(Afstand d2) {
        return new Afstand((this.converteren() + d2.converteren()) * 100, "cm");
    }

	double converteren() {
		if(eenheid.equals("mm")) {
			return lengte / 1000;
		}
		if(eenheid.equals("cm")) {
			return lengte / 100;
		}
		if(eenheid.equals("km")) {
			return lengte * 1000;
		}
		else
			return lengte;
	}

	public String toString() {
		return(this.lengte + " " + this.eenheid);
	}
}

/* Punten: bestaande uit een verticale en horizontale afstand tot de oorsprong.
 * Een punt kan zijn afstand tot een ander punt berekenen.
 */
class Punt{
    public Afstand x, y;

    Punt(Afstand d1, Afstand d2){
        x = new Afstand(d1.lengte, d1.eenheid);
        y = new Afstand(d2.lengte, d2.eenheid);
        }

    Punt(Punt punt) {
        this.x = punt.x;
        this.y = punt.y;
    }

    public Afstand aftrekken(Punt punt) {
        double a, b;
        a = Math.abs(this.x.converteren() - punt.x.converteren());
        b = Math.abs(this.y.converteren() - punt.y.converteren());
        return new Afstand(Math.sqrt((a * a) + (b * b)), "mm");
    }

    public String toString() {
        return "(" + x + "; " + y + ")";
    }
}

/* ... zijn eigenschappen printen (e.g. radius, positie).
 * ... zijn omtrek printen.1
 * ... zijn oppervlakte printen.
 */
class Vorm {
	Punt p1;

	Vorm() {
	}
	Vorm(Punt x) {
	p1 = x;
	}
	double omtrek() {
		return new Afstand(0.0, "m");
	}
	double oppervlakte() {
		return new Afstand(0.0, "m");
	}
}
/* Lijnen: bestaande uit twee verschillende punten. Een lijn kan zijn eigen
 * lengte berekenen.
 */
class Lijn extends Vorm{
    Punt p1, p2;

    Lijn(Punt p, Punt o) {
		p1 = p;
		p2 = o;
	}
    Vorm omtrek() {
		double x, y, afstand;
		x = Math.abs(p2.x.converteren() - p1.x.converteren());
		y = Math.abs(p2.y.converteren() - p1.y.converteren());
			afstand = Math.sqrt((y * y) +(x * x));
			return new Afstand(afstand, "m");
	}
	Vorm oppervlakte() {
		return new Afstand(0.0, "m");
	}
}

/* Cirkels: bestaande uit een middenpunt en een radius (als afstand van het
 * middenpunt). Een cirkel kan zijn omtrek en oppervlakte berekenen.
 */
class Cirkel extends Vorm {
	public Punt p3, straal;

    Cirkel(){}

    Cirkel(Afstand d2, Punt p3) {
        straal = new Afstand(d2.lengte, d2.eenheid);
    }

    double oppervlakte(){
        //straal = Math.abs(d2.x.converteren());
		return(straal * straal * Math.PI);
    }

    double omtrek(){
        //straal = Math.abs(d2.x.converteren());
        return(straal * 2 * Math.PI);
    }
}

/* Rechthoek: bestaande uit een middenpunt en twee afstanden. Een rechthoek
 * kan zijn omtrek en oppervlakte berekenen.
 */
class Rechthoek extends Vorm {
    Afstand x, y;

	Rechthoek(Punt p) {
		super(p);
	}
	Rechthoek(Punt p, Afstand breedte, Afstand lengte) {
		super(p);
		x = breedte;
		y = lengte;
	}
	Afstand omtrek(){
	   	double x, y;
	  	double omtrek = ((lengte * 2) + (breedte * 2));
     	return new Afstand(omtrek, "m");
    }
    double oppervlakte(){
        double oppervlakte = (lengte * breedte);
        return new Afstand(oppervlakte, "m");
    }
}