/*
  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.
*/

/**
 * Double modulus IFS 
 * @author Jesus Sosa
 * @date January 18, 2018
 * based on modulus used as a IFS:
 * 
 * Modifications by Brad Stefanov and Rick Sidwell
 * 
 */
package org.jwildfire.create.tina.variation;

import static org.jwildfire.base.mathlib.MathLib.fmod;


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

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

	private static final String PARAM_X = "x";
	private static final String PARAM_Y = "y";
	private static final String PARAM_ANGLE = "angle";
	private static final String PARAM_SHIFTX = "shiftx";
	private static final String PARAM_SHIFTY = "shifty";
	private static final String PARAM_COLOR1 = "color1";
	private static final String PARAM_SPEED1 = "speed1";
	private static final String PARAM_COLOR2 = "color2";
	private static final String PARAM_SPEED2 = "speed2";
	private static final String PARAM_SQUARE = "square";

	private static final String[] paramNames = { PARAM_X, PARAM_Y, PARAM_ANGLE,PARAM_SHIFTX, PARAM_SHIFTY, 
			PARAM_COLOR1, PARAM_SPEED1, PARAM_COLOR2, PARAM_SPEED2, PARAM_SQUARE };

	private double x = 2.0;
	private double y = 2.0;
	private double shiftx = 0.0;
	private double shifty = 0.0;
 	private double color1 = 0;
	private double color2 = 1;
	private double speed1 = 0;
	private double speed2 = 0;
	private double angle = 45.0;
	private int  square =  1;
	private double coscos, sincos, sinsin, rangle;

	@Override
	public void transform(FlameTransformationContext pContext, XForm pXForm, XYZPoint pAffineTP, XYZPoint pVarTP,
			double pAmount) {
		double xnew, ynew, xt, yt;

		// rangle = MathLib.M_PI*angle/180.0;
		// double w1,w2=Math.pow(Math.tan(rangle),2.0)*0.5;

		double p2 = coscos / (coscos + sinsin);
		double p1 = sinsin / (coscos + sinsin);

		/* Modulus in the Apophysis Plugin Pack */
		if (pAffineTP.x > x) {
			xnew = (-x + fmod(pAffineTP.x + x, _xr));
		} else if (pAffineTP.x < -x) {
			xnew = (x - fmod(x - pAffineTP.x, _xr));
		} else {
			xnew = pAffineTP.x;
		}

		if (pAffineTP.y > y) {
			ynew = (-y + fmod(pAffineTP.y + y, _yr));
		} else if (pAffineTP.y < -y) {
			ynew = (y - fmod(y - pAffineTP.y, _yr));
		} else {
			ynew = pAffineTP.y;
		}

		double p = pContext.random();

		if (angle <= 45.0) {
			if (p < p2) {
				xt = xnew * coscos + ynew * sincos + x;
				yt = -xnew * sincos + ynew * coscos - y;
				newColor = oldColor * c11 + c12;
			} else {
				xt = xnew * sincos + ynew * sinsin;
				yt = -xnew * sinsin + ynew * sincos;
				newColor = oldColor * c21 + c22;
			}
		} else {
			if (p < p1) {
				xt = xnew * sincos + ynew * sinsin;
				yt = -xnew * sinsin + ynew * sincos;
				newColor = oldColor * c21 + c22;
			} else {
				xt = xnew * coscos + ynew * sincos + x;
				yt = -xnew * sincos + ynew * coscos - y;
				newColor = oldColor * c11 + c12;
			}
		}
		
		xt += shiftx;
		yt += shifty;
		
		if (square == 0) { 
			pVarTP.x += pAmount * xt;
			pVarTP.y += pAmount * yt;	      
        } 
		else {
	    if (xt > x) {
	        pVarTP.x += pAmount * (-x + fmod(xt + x, _xr));
	      }
	      else if (xt < -x) {
	        pVarTP.x += pAmount * (x - fmod(x - xt, _xr));
	      }
	      else {
	        pVarTP.x += pAmount * xt;
	      }

	      if (yt > y) {
	        pVarTP.y += pAmount * (-y + fmod(yt + y, _yr));
	      }
	      else if (yt < -y) {
	        pVarTP.y += pAmount * (y - fmod(y - yt, _yr));
	      }
	      else {
	        pVarTP.y += pAmount * yt;
	      }
	    }

		if (pContext.isPreserveZCoordinate()) {
			pVarTP.z += pAmount * pAffineTP.z;
		}

	    pVarTP.color = fmod(newColor, 1);
	    oldColor = newColor;
	}

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

	@Override
	public Object[] getParameterValues() {
		return new Object[] { x, y, angle, shiftx, shifty, color1, speed1, color2, speed2, square };
	}

	@Override
	public void setParameter(String pName, double pValue) {
		if (PARAM_X.equalsIgnoreCase(pName))
			x = pValue;
		else if (PARAM_Y.equalsIgnoreCase(pName))
			y = pValue;
		else if (PARAM_ANGLE.equalsIgnoreCase(pName)) {
			angle = pValue;
			rangle = MathLib.M_PI * angle / 180.0;
			coscos = MathLib.cos(rangle) * MathLib.cos(rangle);
			sinsin = MathLib.sin(rangle) * MathLib.sin(rangle);
			sincos = MathLib.sin(rangle) * MathLib.cos(rangle);
		}
		else if (PARAM_SHIFTX.equalsIgnoreCase(pName))
			shiftx = pValue;
		else if (PARAM_SHIFTY.equalsIgnoreCase(pName))
			shifty = pValue;
		else if (PARAM_COLOR1.equalsIgnoreCase(pName))
			color1 = pValue;
		else if (PARAM_SPEED1.equalsIgnoreCase(pName))
			speed1 = pValue;
		else if (PARAM_COLOR2.equalsIgnoreCase(pName))
			color2 = pValue;
		else if (PARAM_SPEED2.equalsIgnoreCase(pName))
			speed2 = pValue;
		else if (PARAM_SQUARE.equalsIgnoreCase(pName))
			square = limitIntVal(Tools.FTOI(pValue), 0, 1);
		else
			throw new IllegalArgumentException(pName);
	}

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

	private double _xr, _yr, c11, c12, c21, c22, oldColor, newColor;

	@Override
	public void init(FlameTransformationContext pContext, Layer pLayer, XForm pXForm, double pAmount) {
		_xr = 2.0 * x;
		_yr = 2.0 * y;

        c11 = (1 + speed1) / 2;
        c12 = color1 * (1 - speed1) / 2;
        c21 = (1 + speed2) / 2;
        c22 = color2 * (1 - speed2) / 2;
        
        oldColor = 0.5;
	}

}