/*

* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*

*/

package com.nokia.carbide.cpp.ui.tests;

import org.eclipse.core.runtime.*;

import org.eclipse.core.runtime.Path;

import org.eclipse.swt.graphics.*;

import com.nokia.cpp.internal.api.utils.core.Pair;

import com.nokia.cpp.internal.api.utils.core.Triple;

import java.io.IOException;

import java.net.URL;

import junit.framework.TestCase;

public abstract class BaseTest extends TestCase {

	/**

	 * 

	 */

	public BaseTest() {

		super();

	}

	/**

	 * @param name

	 */

	public BaseTest(String name) {

		super(name);

	}

	/**

	 * @return

	 */

	protected IPath getProjectPath() throws IOException {

		if (Platform.isRunning()) {

			URL url = FileLocator.find(Activator.getDefault().getBundle(), new Path("."), null);

			return new Path(FileLocator.toFileURL(url).getPath());

		} else {

			return new Path(".");

		}

	}

	/**

	 * @param pixels

	 * @return

	 */

	protected Pair<Point, RGB>[] removeAlpha(Triple<Point, RGB, Integer>[] pixels) {

		Pair[] pairs = new Pair[pixels.length];

		for (int idx = 0; idx <pixels.length; idx++)

			pairs[idx] = new Pair(pixels[idx].first, pixels[idx].second);

		return pairs;

	}

	/**

	 * @param pixels

	 * @return

	 */

	protected Pair<Point, Integer>[] extractAlpha(Triple<Point, RGB, Integer>[] pixels) {

		Pair<Point, Integer>[] alphas = new Pair[pixels.length];

		for (int idx = 0; idx <pixels.length; idx++)

			alphas[idx] = new Pair<Point, Integer>(pixels[idx].first, pixels[idx].third);

		return alphas;

	}

	/**

	 * Scale pixel data up.  Due to blending, test the extreme edges.

	 * A pixel of 1,1 inside a size of 2,2 really is at 1.9999, 1.9999, for instance.

	 * @param pixels

	 * @param i

	 * @param j

	 * @return

	 */

	protected Pair<Point, RGB>[] scalePixels(Pair<Point, RGB>[] pixels, 

			Point origSize, Point newSize) {

		Pair[] newPixels = new Pair[pixels.length];

		int idx = 0;

		for (Pair<Point, RGB> pixel : pixels) {

			float virtualX = (float)pixel.first.x * origSize.x / (origSize.x - 1);

			float virtualY = (float)pixel.first.y * origSize.y / (origSize.y - 1);

			int newX = (int) Math.floor(virtualX * (newSize.x - 1) / origSize.x);

			int newY = (int) Math.floor(virtualY * (newSize.y - 1) / origSize.y);

			Pair<Point, RGB> newPixel = new Pair<Point, RGB>(

					new Point(newX, newY),

					pixel.second);

			newPixels[idx++] = newPixel;

		}

		return newPixels;

	}

	protected Pair<Point, Integer>[] scaleAlphas(Pair<Point, Integer>[] alphas, 

			Point origSize, Point newSize) {

		if (alphas == null)

			return null;

		Pair[] newAlphas = new Pair[alphas.length];

		int idx = 0;

		for (Pair<Point, Integer> pixel : alphas) {

			float virtualX = (float)pixel.first.x * origSize.x / (origSize.x - 1);

			float virtualY = (float)pixel.first.y * origSize.y / (origSize.y - 1);

			int newX = (int) Math.floor(virtualX * (newSize.x - 1) / origSize.x);

			int newY = (int) Math.floor(virtualY * (newSize.y - 1) / origSize.y);

			Pair<Point, Integer> newPixel = new Pair<Point, Integer>(

					new Point(newX, newY),

					pixel.second);

			newAlphas[idx++] = newPixel;

		}

		return newAlphas;

	}

	protected void doTestImageMatching(ImageData imageData,

			Point expectedSize, int expectedDepth, 

			Pair<Point, RGB>[] pixels,

			Pair<Point, Integer>[] alphas) {

		assertEquals(expectedSize.x, imageData.width);

		assertEquals(expectedSize.y, imageData.height);

		assertEquals(expectedDepth, imageData.depth);

		for (Pair<Point, RGB> pixel : pixels) {

			RGB rgb = imageData.palette.getRGB(imageData.getPixel(pixel.first.x, pixel.first.y));

			if (!pixel.second.equals(rgb)) {

				fail("pixel mismatch at " + pixel.first + "; expected " + pixel.second + " but got " + rgb);

			}

		}

		if (alphas != null) {

			for (Pair<Point, Integer> pixel : alphas) {

				int alpha = imageData.getAlpha(pixel.first.x, pixel.first.y);

				if (!pixel.second.equals(alpha)) {

					fail("alpha mismatch at " + pixel.first + "; expected " + pixel.second + " but got " + alpha);

				}

			}

		}

	}

	// obejct to check for transparent (color) pixel

	static RGB transparent = new RGB(0, 0, 0);

	static class Pixel {

		private int alpha;

		int x, y;

		RGB rgb;

		public Pixel(int i, int j, RGB theRgb, int theAlpha) {

			x = i;

			y = j;

			rgb = theRgb;

			alpha = theAlpha;

		}

		public Pixel(ImageData data, int x2, int y2) {

			x = x2;

			y = y2;

			rgb = data.palette.getRGB(data.getPixel(x2, y2));

			alpha = data.getAlpha(x2, y2);

		}

		public Pixel(int i, int j, RGB rgb) {

			this(i, j, rgb, 255);

		}

		/* (non-Javadoc)

		 * @see java.lang.Object#toString()

		 */

		@Override

		public String toString() {

			return "Pixel("+x+","+y+"@"+rgb+"/"+alpha+")";

		}

//

		public void match(ImageData data) {

			int thePixel = data.getPixel(x,y);

			int theAlpha = data.getAlpha(x,y);

			if (rgb == transparent) {

				if (data.transparentPixel != -1) {

					assertEquals(thePixel, data.transparentPixel);

				} 

				else

					fail("no transparency");

			} else {

				if (rgb != null)

					assertEquals(rgb, data.palette.getRGB(thePixel));

				assertEquals(alpha, theAlpha);

			}

		}

	}

	protected void checkImage(ImageData data, int x, int y, Pixel[] pixels) {

		assertNotNull(data);

		assertEquals(x, data.width);

		assertEquals(y, data.height);

		StringBuffer buffer = new StringBuffer();

		for (int i = 0; i < pixels.length; i++) {

			Pixel p = pixels[i];

			try {

				p.match(data);

			} catch (Throwable t) {

				buffer.append(t.getMessage());

				buffer.append("\n");

			}

		}

		if (buffer.length() > 0)

			fail(buffer.toString());

	}

}