package ar.com.hjg.pngj;

import java.util.Arrays;

import ar.com.hjg.pngj.chunks.PngChunkPLTE;
import ar.com.hjg.pngj.chunks.PngChunkTRNS;

/**
 * Bunch of utility static methods to proces an image line at the pixel level.
 * <p>
 * WARNING: this has little testing/optimizing, and this API is not stable. some
 * methods will probably be changed or
 * removed if future releases.
 * <p>
 * WARNING: most methods for getting/setting values work currently only for
 * ImageLine or ImageLineByte
 */
public class ImageLineHelper {

	static int[] DEPTH_UNPACK_1;
	static int[] DEPTH_UNPACK_2;
	static int[] DEPTH_UNPACK_4;
	static int[][] DEPTH_UNPACK;

	static {
		initDepthScale();
	}

	private static void initDepthScale() {
		DEPTH_UNPACK_1 = new int[2];
		for (int i = 0; i < 2; i++)
			DEPTH_UNPACK_1[i] = i * 255;
		DEPTH_UNPACK_2 = new int[4];
		for (int i = 0; i < 4; i++)
			DEPTH_UNPACK_2[i] = (i * 255) / 3;
		DEPTH_UNPACK_4 = new int[16];
		for (int i = 0; i < 16; i++)
			DEPTH_UNPACK_4[i] = (i * 255) / 15;
		DEPTH_UNPACK = new int[][] { null, DEPTH_UNPACK_1, DEPTH_UNPACK_2, null, DEPTH_UNPACK_4 };
	}

	/**
	 * When the bitdepth is less than 8, the imageLine is usually
	 * returned/expected unscaled. This method upscales it in
	 * place. Eg, if bitdepth=1, values 0-1 will be converted to 0-255
	 */
	public static void scaleUp(IImageLineArray line) {
		if (line.getImageInfo().indexed || line.getImageInfo().bitDepth >= 8)
			return;
		final int[] scaleArray = DEPTH_UNPACK[line.getImageInfo().bitDepth];
		if (line instanceof ImageLineInt) {
			ImageLineInt iline = (ImageLineInt) line;
			for (int i = 0; i < iline.getSize(); i++)
				iline.scanline[i] = scaleArray[iline.scanline[i]];
		} else if (line instanceof ImageLineByte) {
			ImageLineByte iline = (ImageLineByte) line;
			for (int i = 0; i < iline.getSize(); i++)
				iline.scanline[i] = (byte) scaleArray[iline.scanline[i]];
		} else
			throw new PngjException("not implemented");
	}

	/**
	 * Reverse of {@link #scaleUp(IImageLineArray)}
	 */
	public static void scaleDown(IImageLineArray line) {
		if (line.getImageInfo().indexed || line.getImageInfo().bitDepth >= 8)
			return;
		if (line instanceof ImageLineInt) {
			final int scalefactor = 8 - line.getImageInfo().bitDepth;
			if (line instanceof ImageLineInt) {
				ImageLineInt iline = (ImageLineInt) line;
				for (int i = 0; i < line.getSize(); i++)
					iline.scanline[i] = iline.scanline[i] >> scalefactor;
			} else if (line instanceof ImageLineByte) {
				ImageLineByte iline = (ImageLineByte) line;
				for (int i = 0; i < line.getSize(); i++)
					iline.scanline[i] = (byte) ((iline.scanline[i] & 0xFF) >> scalefactor);
			}
		} else
			throw new PngjException("not implemented");
	}

	public static byte scaleUp(int bitdepth, byte v) {
		return bitdepth < 8 ? (byte) DEPTH_UNPACK[bitdepth][v] : v;
	}

	public static byte scaleDown(int bitdepth, byte v) {
		return bitdepth < 8 ? (byte) (v >> (8 - bitdepth)) : v;
	}

	/**
	 * Given an indexed line with a palette, unpacks as a RGB array, or RGBA if
	 * a non nul PngChunkTRNS chunk is passed
	 * 
	 * @param line
	 *            ImageLine as returned from PngReader
	 * @param pal
	 *            Palette chunk
	 * @param trns
	 *            Transparency chunk, can be null (absent)
	 * @param buf
	 *            Preallocated array, optional
	 * @return R G B (A), one sample 0-255 per array element. Ready for
	 *         pngw.writeRowInt()
	 */
	public static int[] palette2rgb(ImageLineInt line, PngChunkPLTE pal, PngChunkTRNS trns, int[] buf) {
		return palette2rgb(line, pal, trns, buf, false);
	}

	/**
	 * Warning: the line should be upscaled, see
	 * {@link #scaleUp(IImageLineArray)}
	 */
	static int[] lineToARGB32(ImageLineByte line, PngChunkPLTE pal, PngChunkTRNS trns, int[] buf) {
		boolean alphachannel = line.imgInfo.alpha;
		int cols = line.getImageInfo().cols;
		if (buf == null || buf.length < cols)
			buf = new int[cols];
		int index, rgb, alpha, ga, g;
		if (line.getImageInfo().indexed) {// palette
			int nindexesWithAlpha = trns != null ? trns.getPalletteAlpha().length : 0;
			for (int c = 0; c < cols; c++) {
				index = line.scanline[c] & 0xFF;
				rgb = pal.getEntry(index);
				alpha = index < nindexesWithAlpha ? trns.getPalletteAlpha()[index] : 255;
				buf[c] = (alpha << 24) | rgb;
			}
		} else if (line.imgInfo.greyscale) { // gray
			ga = trns != null ? trns.getGray() : -1;
			for (int c = 0, c2 = 0; c < cols; c++) {
				g = (line.scanline[c2++] & 0xFF);
				alpha = alphachannel ? line.scanline[c2++] & 0xFF : (g != ga ? 255 : 0);
				buf[c] = (alpha << 24) | g | (g << 8) | (g << 16);
			}
		} else { // true color
			ga = trns != null ? trns.getRGB888() : -1;
			for (int c = 0, c2 = 0; c < cols; c++) {
				rgb = ((line.scanline[c2++] & 0xFF) << 16) | ((line.scanline[c2++] & 0xFF) << 8) | (line.scanline[c2++] & 0xFF);
				alpha = alphachannel ? line.scanline[c2++] & 0xFF : (rgb != ga ? 255 : 0);
				buf[c] = (alpha << 24) | rgb;
			}
		}
		return buf;
	}

	/**
	 * Warning: the line should be upscaled, see
	 * {@link #scaleUp(IImageLineArray)}
	 */
	static byte[] lineToRGBA8888(ImageLineByte line, PngChunkPLTE pal, PngChunkTRNS trns, byte[] buf) {
		boolean alphachannel = line.imgInfo.alpha;
		int cols = line.imgInfo.cols;
		int bytes = cols * 4;
		if (buf == null || buf.length < bytes)
			buf = new byte[bytes];
		int index, rgb, ga;
		byte val;
		if (line.imgInfo.indexed) {// palette
			int nindexesWithAlpha = trns != null ? trns.getPalletteAlpha().length : 0;
			for (int c = 0, b = 0; c < cols; c++) {
				index = line.scanline[c] & 0xFF;
				rgb = pal.getEntry(index);
				buf[b++] = (byte) ((rgb >> 16) & 0xFF);
				buf[b++] = (byte) ((rgb >> 8) & 0xFF);
				buf[b++] = (byte) (rgb & 0xFF);
				buf[b++] = (byte) (index < nindexesWithAlpha ? trns.getPalletteAlpha()[index] : 255);
			}
		} else if (line.imgInfo.greyscale) { //
			ga = trns != null ? trns.getGray() : -1;
			for (int c = 0, b = 0; b < bytes;) {
				val = line.scanline[c++];
				buf[b++] = val;
				buf[b++] = val;
				buf[b++] = val;
				buf[b++] = alphachannel ? line.scanline[c++] : ((int) (val & 0xFF) == ga) ? (byte) 0 : (byte) 255;
			}
		} else { // true color
			if (alphachannel) // same format!
				System.arraycopy(line.scanline, 0, buf, 0, bytes);
			else {
				for (int c = 0, b = 0; b < bytes;) {
					buf[b++] = line.scanline[c++];
					buf[b++] = line.scanline[c++];
					buf[b++] = line.scanline[c++];
					buf[b++] = (byte) (255); // tentative (probable)
					if (trns != null && buf[b - 3] == (byte) trns.getRGB()[0] && buf[b - 2] == (byte) trns.getRGB()[1] && buf[b - 1] == (byte) trns.getRGB()[2]) // not
																																									// very
																																									// efficient,
																																									// but
																																									// not
																																									// frecuent
						buf[b - 1] = 0;
				}
			}
		}
		return buf;
	}

	static byte[] lineToRGB888(ImageLineByte line, PngChunkPLTE pal, byte[] buf) {
		boolean alphachannel = line.imgInfo.alpha;
		int cols = line.imgInfo.cols;
		int bytes = cols * 3;
		if (buf == null || buf.length < bytes)
			buf = new byte[bytes];
		byte val;
		int[] rgb = new int[3];
		if (line.imgInfo.indexed) {// palette
			for (int c = 0, b = 0; c < cols; c++) {
				pal.getEntryRgb(line.scanline[c] & 0xFF, rgb);
				buf[b++] = (byte) rgb[0];
				buf[b++] = (byte) rgb[1];
				buf[b++] = (byte) rgb[2];
			}
		} else if (line.imgInfo.greyscale) { //
			for (int c = 0, b = 0; b < bytes;) {
				val = line.scanline[c++];
				buf[b++] = val;
				buf[b++] = val;
				buf[b++] = val;
				if (alphachannel)
					c++; // skip alpha
			}
		} else { // true color
			if (!alphachannel) // same format!
				System.arraycopy(line.scanline, 0, buf, 0, bytes);
			else {
				for (int c = 0, b = 0; b < bytes;) {
					buf[b++] = line.scanline[c++];
					buf[b++] = line.scanline[c++];
					buf[b++] = line.scanline[c++];
					c++;// skip alpha
				}
			}
		}
		return buf;
	}

	/**
	 * Same as palette2rgbx , but returns rgba always, even if trns is null
	 * 
	 * @param line
	 *            ImageLine as returned from PngReader
	 * @param pal
	 *            Palette chunk
	 * @param trns
	 *            Transparency chunk, can be null (absent)
	 * @param buf
	 *            Preallocated array, optional
	 * @return R G B (A), one sample 0-255 per array element. Ready for
	 *         pngw.writeRowInt()
	 */
	public static int[] palette2rgba(ImageLineInt line, PngChunkPLTE pal, PngChunkTRNS trns, int[] buf) {
		return palette2rgb(line, pal, trns, buf, true);
	}

	public static int[] palette2rgb(ImageLineInt line, PngChunkPLTE pal, int[] buf) {
		return palette2rgb(line, pal, null, buf, false);
	}

	/** this is not very efficient, only for tests and troubleshooting */
	public static int[] convert2rgba(IImageLineArray line, PngChunkPLTE pal, PngChunkTRNS trns, int[] buf) {
		ImageInfo imi = line.getImageInfo();
		int nsamples = imi.cols * 4;
		if (buf == null || buf.length < nsamples)
			buf = new int[nsamples];
		int maxval = imi.bitDepth == 16 ? (1 << 16) - 1 : 255;
		Arrays.fill(buf, maxval);

		if (imi.indexed) {
			int tlen = trns != null ? trns.getPalletteAlpha().length : 0;
			for (int s = 0; s < imi.cols; s++) {
				int index = line.getElem(s);
				pal.getEntryRgb(index, buf, s * 4);
				if (index < tlen) {
					buf[s * 4 + 3] = trns.getPalletteAlpha()[index];
				}
			}
		} else if (imi.greyscale) {
			int[] unpack = null;
			if (imi.bitDepth < 8)
				unpack = ImageLineHelper.DEPTH_UNPACK[imi.bitDepth];
			for (int s = 0, i = 0, p = 0; p < imi.cols; p++) {
				buf[s++] = unpack != null ? unpack[line.getElem(i++)] : line.getElem(i++);
				buf[s] = buf[s - 1];
				s++;
				buf[s] = buf[s - 1];
				s++;
				if (imi.channels == 2)
					buf[s++] = unpack != null ? unpack[line.getElem(i++)] : line.getElem(i++);
				else
					buf[s++] = maxval;
			}
		} else {
			for (int s = 0, i = 0, p = 0; p < imi.cols; p++) {
				buf[s++] = line.getElem(i++);
				buf[s++] = line.getElem(i++);
				buf[s++] = line.getElem(i++);
				buf[s++] = imi.alpha ? line.getElem(i++) : maxval;
			}
		}
		return buf;
	}

	private static int[] palette2rgb(IImageLine line, PngChunkPLTE pal, PngChunkTRNS trns, int[] buf,
			boolean alphaForced) {
		boolean isalpha = trns != null;
		int channels = isalpha ? 4 : 3;
		ImageLineInt linei = (ImageLineInt) (line instanceof ImageLineInt ? line : null);
		ImageLineByte lineb = (ImageLineByte) (line instanceof ImageLineByte ? line : null);
		boolean isbyte = lineb != null;
		int cols = linei != null ? linei.imgInfo.cols : lineb.imgInfo.cols;
		int nsamples = cols * channels;
		if (buf == null || buf.length < nsamples)
			buf = new int[nsamples];
		int nindexesWithAlpha = trns != null ? trns.getPalletteAlpha().length : 0;
		for (int c = 0; c < cols; c++) {
			int index = isbyte ? (lineb.scanline[c] & 0xFF) : linei.scanline[c];
			pal.getEntryRgb(index, buf, c * channels);
			if (isalpha) {
				int alpha = index < nindexesWithAlpha ? trns.getPalletteAlpha()[index] : 255;
				buf[c * channels + 3] = alpha;
			}
		}
		return buf;
	}

	/**
	 * what follows is pretty uninteresting/untested/obsolete, subject to change
	 */
	/**
	 * Just for basic info or debugging. Shows values for first and last pixel.
	 * Does not include alpha
	 */
	public static String infoFirstLastPixels(ImageLineInt line) {
		return line.imgInfo.channels == 1 ? String.format("first=(%d) last=(%d)", line.scanline[0], line.scanline[line.scanline.length - 1]) : String.format("first=(%d %d %d) last=(%d %d %d)", line.scanline[0], line.scanline[1], line.scanline[2], line.scanline[line.scanline.length - line.imgInfo.channels], line.scanline[line.scanline.length - line.imgInfo.channels + 1], line.scanline[line.scanline.length - line.imgInfo.channels + 2]);
	}

	/**
	 * integer packed R G B only for bitdepth=8! (does not check!)
	 * 
	 **/
	public static int getPixelRGB8(IImageLine line, int column) {
		if (line instanceof ImageLineInt) {
			int offset = column * ((ImageLineInt) line).imgInfo.channels;
			int[] scanline = ((ImageLineInt) line).getScanline();
			return (scanline[offset] << 16) | (scanline[offset + 1] << 8) | (scanline[offset + 2]);
		} else if (line instanceof ImageLineByte) {
			int offset = column * ((ImageLineByte) line).imgInfo.channels;
			byte[] scanline = ((ImageLineByte) line).getScanline();
			return ((scanline[offset] & 0xff) << 16) | ((scanline[offset + 1] & 0xff) << 8) | ((scanline[offset + 2] & 0xff));
		} else
			throw new PngjException("Not supported " + line.getClass());
	}

	public static int getPixelARGB8(IImageLine line, int column) {
		if (line instanceof ImageLineInt) {
			int offset = column * ((ImageLineInt) line).imgInfo.channels;
			int[] scanline = ((ImageLineInt) line).getScanline();
			return (scanline[offset + 3] << 24) | (scanline[offset] << 16) | (scanline[offset + 1] << 8) | (scanline[offset + 2]);
		} else if (line instanceof ImageLineByte) {
			int offset = column * ((ImageLineByte) line).imgInfo.channels;
			byte[] scanline = ((ImageLineByte) line).getScanline();
			return (((scanline[offset + 3] & 0xff) << 24) | ((scanline[offset] & 0xff) << 16) | ((scanline[offset + 1] & 0xff) << 8) | ((scanline[offset + 2] & 0xff)));
		} else
			throw new PngjException("Not supported " + line.getClass());
	}

	public static void setPixelsRGB8(ImageLineInt line, int[] rgb) {
		for (int i = 0, j = 0; i < line.imgInfo.cols; i++) {
			line.scanline[j++] = ((rgb[i] >> 16) & 0xFF);
			line.scanline[j++] = ((rgb[i] >> 8) & 0xFF);
			line.scanline[j++] = ((rgb[i] & 0xFF));
		}
	}

	public static void setPixelRGB8(ImageLineInt line, int col, int r, int g, int b) {
		col *= line.imgInfo.channels;
		line.scanline[col++] = r;
		line.scanline[col++] = g;
		line.scanline[col] = b;
	}

	public static void setPixelRGB8(ImageLineInt line, int col, int rgb) {
		setPixelRGB8(line, col, (rgb >> 16) & 0xFF, (rgb >> 8) & 0xFF, rgb & 0xFF);
	}

	public static void setPixelsRGBA8(ImageLineInt line, int[] rgb) {
		for (int i = 0, j = 0; i < line.imgInfo.cols; i++) {
			line.scanline[j++] = ((rgb[i] >> 16) & 0xFF);
			line.scanline[j++] = ((rgb[i] >> 8) & 0xFF);
			line.scanline[j++] = ((rgb[i] & 0xFF));
			line.scanline[j++] = ((rgb[i] >> 24) & 0xFF);
		}
	}

	public static void setPixelRGBA8(ImageLineInt line, int col, int r, int g, int b, int a) {
		col *= line.imgInfo.channels;
		line.scanline[col++] = r;
		line.scanline[col++] = g;
		line.scanline[col++] = b;
		line.scanline[col] = a;
	}

	public static void setPixelRGBA8(ImageLineInt line, int col, int rgb) {
		setPixelRGBA8(line, col, (rgb >> 16) & 0xFF, (rgb >> 8) & 0xFF, rgb & 0xFF, (rgb >> 24) & 0xFF);
	}

	public static void setValD(ImageLineInt line, int i, double d) {
		line.scanline[i] = double2int(line, d);
	}

	public static int interpol(int a, int b, int c, int d, double dx, double dy) {
		// a b -> x (0-1)
		// c d
		double e = a * (1.0 - dx) + b * dx;
		double f = c * (1.0 - dx) + d * dx;
		return (int) (e * (1 - dy) + f * dy + 0.5);
	}

	public static double int2double(ImageLineInt line, int p) {
		return line.imgInfo.bitDepth == 16 ? p / 65535.0 : p / 255.0;
		// TODO: replace my multiplication? check for other bitdepths
	}

	public static double int2doubleClamped(ImageLineInt line, int p) {
		// TODO: replace my multiplication?
		double d = line.imgInfo.bitDepth == 16 ? p / 65535.0 : p / 255.0;
		return d <= 0.0 ? 0 : (d >= 1.0 ? 1.0 : d);
	}

	public static int double2int(ImageLineInt line, double d) {
		d = d <= 0.0 ? 0 : (d >= 1.0 ? 1.0 : d);
		return line.imgInfo.bitDepth == 16 ? (int) (d * 65535.0 + 0.5) : (int) (d * 255.0 + 0.5); //
	}

	public static int double2intClamped(ImageLineInt line, double d) {
		d = d <= 0.0 ? 0 : (d >= 1.0 ? 1.0 : d);
		return line.imgInfo.bitDepth == 16 ? (int) (d * 65535.0 + 0.5) : (int) (d * 255.0 + 0.5); //
	}

	public static int clampTo_0_255(int i) {
		return i > 255 ? 255 : (i < 0 ? 0 : i);
	}

	public static int clampTo_0_65535(int i) {
		return i > 65535 ? 65535 : (i < 0 ? 0 : i);
	}

	public static int clampTo_128_127(int x) {
		return x > 127 ? 127 : (x < -128 ? -128 : x);
	}

	public static int getMaskForPackedFormats(int bitDepth) { // Utility function for pack/unpack
		if (bitDepth == 4)
			return 0xf0;
		else if (bitDepth == 2)
			return 0xc0;
		else
			return 0x80; // bitDepth == 1
	}

	public static int getMaskForPackedFormatsLs(int bitDepth) { // Utility function for pack/unpack
		if (bitDepth == 4)
			return 0x0f;
		else if (bitDepth == 2)
			return 0x03;
		else
			return 0x01; // bitDepth == 1
	}

}