/*
  JWildfire - an image and animation processor written in Java 
  Copyright (C) 1995-2011 Andreas Maschke

  This is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser 
  General Public License as published by the Free Software Foundation; either version 2.1 of the 
  License, or (at your option) any later version.
 
  This software is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without 
  even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License along with this software; 
  if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.jwildfire.create.tina.variation;

import static org.jwildfire.base.mathlib.MathLib.fabs;
import static org.jwildfire.base.mathlib.MathLib.pow;

import org.jwildfire.base.Tools;
import org.jwildfire.create.tina.base.Layer;
import org.jwildfire.create.tina.base.XForm;
import org.jwildfire.create.tina.base.XYZPoint;

public class CrobFunc extends VariationFunc {
  private static final long serialVersionUID = 1L;

  private static final String PARAM_TOP = "top";
  private static final String PARAM_BOTTOM = "bottom";
  private static final String PARAM_LEFT = "left";
  private static final String PARAM_RIGHT = "right";
  private static final String PARAM_BLUR = "blur";
  private static final String PARAM_RATIOBLUR = "ratioBlur";
  private static final String PARAM_DIRECTBLUR = "directBlur";

  private static final String[] paramNames = { PARAM_TOP, PARAM_BOTTOM, PARAM_LEFT, PARAM_RIGHT, PARAM_BLUR, PARAM_RATIOBLUR, PARAM_DIRECTBLUR };

  private double left = -1.0;
  private double top = -1.0;
  private double right = 1.0;
  private double bottom = 1.0;
  private int blur = 1;
  private double ratioblur = 0.05;
  private double directblur = 2.0;
  
  @Override
  public void transform(FlameTransformationContext pContext, XForm pXForm, XYZPoint pAffineTP, XYZPoint pVarTP, double pAmount) {
	  // crob by FractalDesire, https://fractaldesire.deviantart.com/art/crob-plugin-260173724

	  double gradTmp, secTmp;
	  double xTmp = pAffineTP.x;
	  double yTmp = pAffineTP.y;
	  
	  if ((pAffineTP.x < left_border) || (pAffineTP.x > right_border) || (pAffineTP.y < top_border) || (pAffineTP.y > bottom_border)) {
		  //***** Case: no edge *****
		  if (blur == 0) {
			  xTmp = 0;
			  yTmp = 0;
		  }
		  //***** Case: with edge *****
		  else {
			  secTmp = pContext.random();
			  
			  // ***** Drawing top and bottom *****
			  if (secTmp < setProb) {
				  do {
					  yTmp = top + pContext.random()*yInt_2;
					  xTmp = right - pow(pContext.random(), directblur)*ratioblur*minInt_2;
					  gradTmp = (yTmp - y0c)/(xTmp - x0c);
				  } while (gradTmp < -1.0);
				  
				  if (secTmp < setProbH) xTmp = left + right - xTmp;
				  if ((secTmp > setProbQ) && (secTmp < setProbTQ)) yTmp = bottom + top - yTmp;
			  }
			  
			  // ***** Drawing left and right *****
			  else {
				  do {
					  xTmp = right - pContext.random()*xInt_2;
					  yTmp = top + pow(pContext.random(), directblur)*ratioblur*minInt_2;
					  gradTmp = (yTmp - y0c)/(xTmp - x0c);
				  } while ((gradTmp <= 0.0) && (gradTmp > -1.0));
				  
				  if (secTmp > setCompProbH) yTmp = bottom + top - yTmp;
				  if ((secTmp > setCompProbQ) && (secTmp < setCompProbTQ)) xTmp = left + right - xTmp;
			  }
		  }
	  }
	  
	  pVarTP.x += xTmp;
	  pVarTP.y += yTmp;
	  if (pContext.isPreserveZCoordinate()) {
		  pVarTP.z += pAmount * pAffineTP.z;
    }
  }

  @Override
  public String[] getParameterNames() {
    return paramNames;
  }

  @Override
  public Object[] getParameterValues() {
    return new Object[] { top, bottom, left, right, blur, ratioblur, directblur };
  }

  @Override
  public void setParameter(String pName, double pValue) {
    if (PARAM_LEFT.equalsIgnoreCase(pName))
      left = pValue;
    else if (PARAM_RIGHT.equalsIgnoreCase(pName))
      right = pValue;
    else if (PARAM_TOP.equalsIgnoreCase(pName))
      top = pValue;
    else if (PARAM_BOTTOM.equalsIgnoreCase(pName))
      bottom = pValue;
    else if (PARAM_BLUR.equalsIgnoreCase(pName))
      blur = Tools.FTOI(pValue);
    else if (PARAM_RATIOBLUR.equalsIgnoreCase(pName))
      ratioblur = pValue;
    else if (PARAM_DIRECTBLUR.equalsIgnoreCase(pName))
      directblur = pValue;
    else
      throw new IllegalArgumentException(pName);
  }

  @Override
  public String getName() {
    return "crob";
  }

  private double top_border, bottom_border, left_border, right_border;
  private double xInterval, yInterval, xInt_2, yInt_2, minInt_2;
  private double x0, y0, x0c, y0c;
  private double setProb, setProbH, setProbQ, setProbTQ, setCompProb, setCompProbH, setCompProbQ, setCompProbTQ;

  @Override
  public void init(FlameTransformationContext pContext, Layer pLayer, XForm pXForm, double pAmount) {
	  double tmp;

	  // ***** Preventing bad inputs *****
	  if (top > bottom) {
		  tmp = top;
		  top = bottom;
		  bottom = tmp;
	  }
	  if (top == bottom) {
		  top = -1.0;
		  bottom = 1.0;
	  }
	  if (left > right) {
		  tmp = left;
		  left = right;
		  right = tmp;
	  }
	  if (left == right) {
		  left = -1.0;
		  right = 1.0;
	  }
	  if (directblur < 0.0) directblur = 0.0;
	  
	  // ***** Initializing intervals *****
	  if (blur != 0) blur = 1;
	  xInterval = fabs(right - left);
	  yInterval = fabs(bottom - top);
	  xInt_2 = xInterval/2.0;
	  yInt_2 = yInterval/2.0;
	  minInt_2 = (xInt_2 > yInt_2) ? yInt_2 : xInt_2;
	  x0 = right - xInt_2;
	  y0 = top + yInt_2;
	  
	  // ***** Initializing reference point *****
	  if (xInt_2 > yInt_2) {
		  x0c = right - minInt_2;
		  y0c = y0;
	  }
	  else if (xInt_2 < yInt_2) {
		  x0c = x0;
		  y0c = top + minInt_2;
	  }
	  else {
		  x0c = x0;
		  y0c = y0;
	  }
	  
	  // ***** Initializing probabilities *****
	  setProb = yInterval / (xInterval + yInterval);
	  setProbQ = 0.25 * setProb;
	  setProbH = 0.50 * setProb;
	  setProbTQ = 0.75 * setProb;
	  setCompProb = 1.0 - setProb;
	  setCompProbQ = setProb + 0.25 * setCompProb;
	  setCompProbH = setProb + 0.50 * setCompProb;
	  setCompProbTQ = setProb + 0.75 * setCompProb;
	  
	  // ***** Defining inner area *****
	  if (blur == 0) {
		  top_border = top;
		  bottom_border = bottom;
		  left_border = left;
		  right_border = right;
	  }
	  else {
		  top_border = top + minInt_2 * ratioblur;
		  bottom_border = bottom - minInt_2 * ratioblur;
		  left_border = left + minInt_2 * ratioblur;
		  right_border = right - minInt_2 * ratioblur;
	  }
  }

}