class FuzzyController {

	private FuzzySet xLow, xMed, xHigh; //pkt
	private FuzzySet yLow, yMed, yHigh; //oct/pkt
	private FuzzySet zLow, zMed, zHigh; //output
	
	private double xl, xm, xh, yl, ym, yh; // input of membership
	private double clow, cmed, chigh; // center of low, med, high
	
	private final boolean LEFT = true;
	private final boolean RIGHT = false;
	
	double low[] = new double[4];
	double med[] = new double[3];
	double high[] = new double[2];
	
	private double[] xlow = {20, 310};
	private double[] xmed = {200, 600, 1000};
	private double[] xhigh = {700, 1300};
	
	private double[] ylow = {50, 200};
	private double[] ymed = {150, 475, 800};
	private double[] yhigh = {600, 900};
	
	//Z ranging from -10 to 10
	/*private double[] zlow = {-, -3};
	private double[] zmed = {-6, 0, 6};
	private double[] zhigh = {3, 6};*/
	
	//Z ranging from 0 to 10
	private final double[] Z = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
	
	public FuzzyController() {		
		xLow = new FuzzySet(2, xlow);
		xMed = new FuzzySet(1, xmed);
		xHigh = new FuzzySet(2, xhigh);
		
		yLow = new FuzzySet(2, ylow);
		yMed = new FuzzySet(1, ymed);
		yHigh = new FuzzySet(2, yhigh);
	}
	
	private double getRSSInferencing(double[] membership) {
		double sum = 0.0;
		for(int i=0; i<membership.length; i++) {
			sum += Math.pow(membership[i], 2);
		}
		return Math.sqrt(sum);
	}
	
	private double getMinMaxInferencing(double[] membership) {
		double res = 0.0;
		for(int i=0; i<membership.length; i++) {
			res = Math.max(res, membership[i]);
		}
		return res;
	}
	
	private double getEdgeValue(double sidelimit, double medlimit, double side, double med, double xres, double yres) {
		double x = (sidelimit >= side)? xres : sidelimit; //eg: side=0.6666; xres=0.6667
		double y = (medlimit >= med)? yres : medlimit; //eg: med=0.3333; xres=0.3333
		return Math.max(x,y);
	}
	
	private double getZvalue(double[] centers, double[] strength) {
		double sum = 0.0;
		double sum_str = 0.0;
		for(int i=0; i<strength.length; i++) {
			sum += (centers[i] * strength[i]);
			sum_str += strength[i];
		}
		return sum/sum_str;
	}
		
	public double getOutput(double x, double y) {
		
		xl = xLow.getTrapzMembership(LEFT, x);
		xm = xMed.getTriMembership(x);
		xh = xHigh.getTrapzMembership(RIGHT, x);
		
		yl = yLow.getTrapzMembership(LEFT, y);
		ym = yMed.getTriMembership(y);
		yh = yHigh.getTrapzMembership(RIGHT, y);
		
		low[0] = Math.min(xl, yh); // Z is LOW when X is LOW and Y is HIGH
		low[1] = Math.min(xl, ym); // Z is LOW when X is LOW and Y is MED
		low[2] = Math.min(xl, yl); // Z is LOW when X is LOW and Y is LOW
		low[3] = Math.min(xh, yh); // Z is LOW when X is HIGH and Y is HIGH
	
		med[0] = Math.min(xm, ym); // Z is MED when X is MED and Y is MED
		med[1] = Math.min(xh, ym); // Z is MED when X is HIGH and Y is MED
		med[2] = Math.min(xm, yh); // Z is MED when X is MED and Y is HIGH
		//med[3] = Math.min(xh, yh); // Z is MED when X is HIGH and Y is HIGH
		
		high[0] = Math.min(xm, yl); // Z is HIGH when X is MED and Y is LOW
		high[1] = Math.min(xh, yl); // Z is HIGH when X is HIGH and Y is LOW

		
		//System.out.println("x:"+xm);
		//System.out.println("y:"+yl);
		//System.out.println();
		
		for(int i=0; i<4; i++) {
			System.out.println(low[i]);
		}
		System.out.println();
		for(int i=0; i<3; i++) {
			System.out.println(med[i]);
		}
		System.out.println();
		for(int i=0; i<2; i++) {
			System.out.println(high[i]);
		}
		System.out.println();
		
		clow = getMinMaxInferencing(low);
		cmed = getMinMaxInferencing(med);
		chigh = getMinMaxInferencing(high);
		
		double strength[] = new double[11];
		strength[0] = clow;
		strength[1] = clow;
		strength[2] = clow;
		strength[3] = getEdgeValue(clow, cmed, 0.6666, 0.3333, 0.6667, 0.3333);
		strength[4] = getEdgeValue(clow, cmed, 0.3333, 0.6666, 0.3333, 0.6667);
		strength[5] = cmed;
		strength[6] = getEdgeValue(chigh, cmed, 0.3333, 0.6666, 0.3333, 0.6667);
		strength[7] = getEdgeValue(chigh, cmed, 0.6666, 0.3333, 0.6667, 0.3333);
		strength[8] = chigh;
		strength[9] = chigh;
		strength[10] = chigh;
		
		for(int i=0; i<Z.length; i++)
		System.out.println(strength[i]);
		System.out.println();
		
		return getZvalue(Z, strength);
	}
	
}