package Growth;

import java.awt.Color;
import java.awt.image.BufferedImage;

import vxp.PixelSource;

public class NRGBColor extends GrowthInPixelSource {

	float redLower = .35f;

	float redUpper = .55f;

	float greenLower = .26f;

	float greenUpper = .35f;

	float redTarget = .45f;

	float greenTarget= .305f;

	float redTolerance = .1f;

	float greenTolerance= .045f;
	


	NRGBColor(PixelSource _ps, float _redTarget, float _greenTarget, float _redTolerance, float _greenTolerance, BufferedImage _debugImage) {
		super(_ps, _debugImage);
		redTarget = _redTarget;
		greenTarget = _greenTarget;
		greenTolerance = _greenTolerance;
		redTolerance = _redTolerance;
		computeLimits();

	}

	NRGBColor(PixelSource _ps, BufferedImage _debugImage) {
		super(_ps, _debugImage);
	}

	public boolean doesPixelQualify(int[] _rgb) {
		int total = (_rgb[1] + _rgb[2] + _rgb[3]);
		float nr = (float) _rgb[1] / total;
		float ng = (float) _rgb[2] / total;
		return (nr < redUpper && nr > redLower && ng < greenUpper && ng > greenLower);
	}

	public boolean newPoint(int _x, int _y) {
		boolean good = doesPixelQualify(ps.getPixel(_x, _y));
		if (good && debugLevel == SHOWGROWTH) {
			debugPixel(_x, _y);
		}
		return good;
	}

	public String getDebugString() {
		// String birth = String.valueOf((getBirthDate()));
		if (debugText.equals("color")) {
			String r = String.valueOf((redTarget));
			String g = String.valueOf((greenTarget));
			String rt = String.valueOf((redTolerance));
			String gt = String.valueOf((greenTolerance));
			String colors = "R:" + r.substring(0,Math.min(r.length(),4))+ " +-:" + rt.substring(0,Math.min(rt.length(),4)) + " G:" + g.substring(0,Math.min(g.length(),4))  + " +-:" + gt.substring(0,Math.min(gt.length(),4));
			return colors;
		}else{
			super.getDebugString();
		}
		return debugText; // birth.substring(birth.length()-4,birth.length()-1);
	}
	
	public void computeLimits() {
		redLower = redTarget - redTolerance;
		redUpper = redTarget + redTolerance;
		greenLower = greenTarget - greenTolerance;
		greenUpper = greenTarget + greenTolerance;
	}

	public float getGreenTarget() {
		return greenTarget;
	}

	public void setGreenTarget(float greenTarget) {
		this.greenTarget = greenTarget;
		 computeLimits();
	}

	public float getGreenTolerance() {
		return greenTolerance;
	}

	public void setGreenTolerance(float greenTolerance) {
		this.greenTolerance = greenTolerance;
		 computeLimits();
	}

	public float getRedTarget() {
		return redTarget;
	}

	public void setRedTarget(float redTarget) {
		this.redTarget = redTarget;
		 computeLimits();
	}

	public float getRedTolerance() {
		return redTolerance;
	}

	public void setRedTolerance(float redTolerance) {
		this.redTolerance = redTolerance;
		 computeLimits();
	}
	public void shiftRed(float _redShift){
		redUpper = redUpper + _redShift;
		redLower = redLower + _redShift;
	}
	public void shiftGreen(float _greenShift){
		greenUpper = greenUpper + _greenShift;
		greenLower = greenLower + _greenShift;
	}
    public float[] getRanges(){
      float[] a = {redLower, redUpper, greenLower, greenUpper};
      return a;
    }
    public void setRanges(float _redLower, float _redUpper, float _greenLower,float _greenUpper){
    	redLower = _redLower;
    	redUpper = _redUpper;
    	greenLower = _greenLower;
    	greenUpper = _greenUpper;
    }
}