package ar.com.hjg.pngj.pixels;

import java.util.Arrays;

import ar.com.hjg.pngj.FilterType;
import ar.com.hjg.pngj.ImageInfo;
import ar.com.hjg.pngj.PngHelperInternal;
import ar.com.hjg.pngj.PngjExceptionInternal;

/** for use in adaptative strategy */
public class FiltersPerformance {

	private final ImageInfo iminfo;
	private double memoryA = 0.7; // empirical (not very critical: 0.72)
	private int lastrow = -1;
	private double[] absum = new double[5];// depending on the strategy not all values might be
											// computed for all
	private double[] entropy = new double[5];
	private double[] cost = new double[5];
	private int[] histog = new int[256]; // temporary, not normalized
	private int lastprefered = -1;
	private boolean initdone = false;
	private double preferenceForNone = 1.0; // higher gives more preference to NONE

	// this values are empirical (montecarlo), for RGB8 images with entropy estimator for NONE and
	// memory=0.7
	// DONT MODIFY THIS
	public static final double[] FILTER_WEIGHTS_DEFAULT = { 0.73, 1.03, 0.97, 1.11, 1.22 }; // lower is
																							// better!

	private double[] filter_weights = new double[] { -1, -1, -1, -1, -1 };

	private final static double LOG2NI = -1.0 / Math.log(2.0);

	public FiltersPerformance(ImageInfo imgInfo) {
		this.iminfo = imgInfo;
	}

	private void init() {
		if (filter_weights[0] < 0) {// has not been set from outside
			System.arraycopy(FILTER_WEIGHTS_DEFAULT, 0, filter_weights, 0, 5);
			double wNone = filter_weights[0];
			if (iminfo.bitDepth == 16)
				wNone = 1.2;
			else if (iminfo.alpha)
				wNone = 0.8;
			else if (iminfo.indexed || iminfo.bitDepth < 8)
				wNone = 0.4; // we prefer NONE strongly
			wNone /= preferenceForNone;
			filter_weights[0] = wNone;
		}
		Arrays.fill(cost, 1.0);
		initdone = true;
	}

	public void updateFromFiltered(FilterType ftype, byte[] rowff, int rown) {
		updateFromRawOrFiltered(ftype, rowff, null, null, rown);
	}

	/** alternative: computes statistic without filtering */
	public void updateFromRaw(FilterType ftype, byte[] rowb, byte[] rowbprev, int rown) {
		updateFromRawOrFiltered(ftype, null, rowb, rowbprev, rown);
	}

	private void updateFromRawOrFiltered(FilterType ftype, byte[] rowff, byte[] rowb, byte[] rowbprev, int rown) {
		if (!initdone)
			init();
		if (rown != lastrow) {
			Arrays.fill(absum, Double.NaN);
			Arrays.fill(entropy, Double.NaN);
		}
		lastrow = rown;
		if (rowff != null)
			computeHistogram(rowff);
		else
			computeHistogramForFilter(ftype, rowb, rowbprev);
		if (ftype == FilterType.FILTER_NONE)
			entropy[ftype.val] = computeEntropyFromHistogram();
		else
			absum[ftype.val] = computeAbsFromHistogram();
	}

	/* WARNING: this is not idempotent, call it just once per cycle (sigh) */
	public FilterType getPreferred() {
		int fi = 0;
		double vali = Double.MAX_VALUE, val = 0; // lower wins
		for (int i = 0; i < 5; i++) {
			if (!Double.isNaN(absum[i])) {
				val = absum[i];
			} else if (!Double.isNaN(entropy[i])) {
				val = (Math.pow(2.0, entropy[i]) - 1.0) * 0.5;
			} else
				continue;
			val *= filter_weights[i];
			val = cost[i] * memoryA + (1 - memoryA) * val;
			cost[i] = val;
			if (val < vali) {
				vali = val;
				fi = i;
			}
		}
		lastprefered = fi;
		return FilterType.getByVal(lastprefered);
	}

	public final void computeHistogramForFilter(FilterType filterType, byte[] rowb, byte[] rowbprev) {
		Arrays.fill(histog, 0);
		int i, j, imax = iminfo.bytesPerRow;
		switch (filterType) {
			case FILTER_NONE:
				for (i = 1; i <= imax; i++)
					histog[rowb[i] & 0xFF]++;
				break;
			case FILTER_PAETH:
				for (i = 1; i <= imax; i++)
					histog[PngHelperInternal.filterRowPaeth(rowb[i], 0, rowbprev[i] & 0xFF, 0)]++;
				for (j = 1, i = iminfo.bytesPixel + 1; i <= imax; i++, j++)
					histog[PngHelperInternal.filterRowPaeth(rowb[i], rowb[j] & 0xFF, rowbprev[i] & 0xFF, rowbprev[j] & 0xFF)]++;
				break;
			case FILTER_SUB:
				for (i = 1; i <= iminfo.bytesPixel; i++)
					histog[rowb[i] & 0xFF]++;
				for (j = 1, i = iminfo.bytesPixel + 1; i <= imax; i++, j++)
					histog[(rowb[i] - rowb[j]) & 0xFF]++;
				break;
			case FILTER_UP:
				for (i = 1; i <= iminfo.bytesPerRow; i++)
					histog[(rowb[i] - rowbprev[i]) & 0xFF]++;
				break;
			case FILTER_AVERAGE:
				for (i = 1; i <= iminfo.bytesPixel; i++)
					histog[((rowb[i] & 0xFF) - ((rowbprev[i] & 0xFF)) / 2) & 0xFF]++;
				for (j = 1, i = iminfo.bytesPixel + 1; i <= imax; i++, j++)
					histog[((rowb[i] & 0xFF) - ((rowbprev[i] & 0xFF) + (rowb[j] & 0xFF)) / 2) & 0xFF]++;
				break;
			default:
				throw new PngjExceptionInternal("Bad filter:" + filterType);
		}
	}

	public void computeHistogram(byte[] rowff) {
		Arrays.fill(histog, 0);
		for (int i = 1; i < iminfo.bytesPerRow; i++)
			histog[rowff[i] & 0xFF]++;
	}

	public double computeAbsFromHistogram() {
		int s = 0;
		for (int i = 1; i < 128; i++)
			s += histog[i] * i;
		for (int i = 128, j = 128; j > 0; i++, j--)
			s += histog[i] * j;
		return s / (double) iminfo.bytesPerRow;
	}

	public final double computeEntropyFromHistogram() {
		double s = 1.0 / iminfo.bytesPerRow;
		double ls = Math.log(s);

		double h = 0;
		for (int x : histog) {
			if (x > 0)
				h += (Math.log(x) + ls) * x;
		}
		h *= s * LOG2NI;
		if (h < 0.0)
			h = 0.0;
		return h;
	}

	/**
	 * If larger than 1.0, NONE will be more prefered. This must be called
	 * before init
	 * 
	 * @param preferenceForNone
	 *            around 1.0 (default: 1.0)
	 */
	public void setPreferenceForNone(double preferenceForNone) {
		this.preferenceForNone = preferenceForNone;
	}

	/**
	 * Values greater than 1.0 (towards infinite) increase the memory towards 1.
	 * Values smaller than 1.0 (towards zero)
	 * decreases the memory .
	 * 
	 */
	public void tuneMemory(double m) {
		if (m == 0)
			memoryA = 0.0;
		else
			memoryA = Math.pow(memoryA, 1.0 / m);
	}

	/**
	 * To set manually the filter weights. This is not recommended, unless you
	 * know what you are doing. Setting this
	 * ignores preferenceForNone and omits some heuristics
	 * 
	 * @param weights
	 *            Five doubles around 1.0, one for each filter type. Lower is
	 *            preferered
	 */
	public void setFilterWeights(double[] weights) {
		System.arraycopy(weights, 0, filter_weights, 0, 5);
	}
}