import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.geom.AffineTransform;
import java.awt.image.AffineTransformOp;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

import javax.imageio.ImageIO;
import javax.imageio.ImageReader;
import javax.imageio.metadata.IIOMetadata;
import javax.imageio.stream.ImageInputStream;

import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import MAndEngine.Engine;
import MAndEngine.ImageCreator;

public class Item {
	
	//to track when to advance frame
	private long lastTime = System.currentTimeMillis();
	//every how many ms?
	private long interval = 100;
	
	//because we need something to tell us which image we're looking at!
	private int pointer = 0;
	
	// cropped to a thumb nail, of size 80*80
	private final BufferedImage thumbnail;

	// the original image, not cropped or anything.
	private final BufferedImage[] image;

	// Absolute path, i think.
	private final String path;
	private String name;

	// we need this because im scared.
	// if literally anything in the creating of an item
	// goes MODERATELY wrong, you set this to FALSE.
	// then we don't try and render something that
	// makes no sense.
	// set this to false by the end of the constructor
	// and when it comes back to be added to the list,
	// it'll get thrown out.
	private boolean seemsLegit = true;

	public Item(String path) {

		BufferedImage thumbnail = null;
		BufferedImage[] images = null;

		try {
			File file = new File(path);
			if (file.isDirectory()) {
				thumbnail = ImageCreator.creatImageWithStripes(Viewer.THUMBNAIL_SIZE, Viewer.THUMBNAIL_SIZE, Color.BLUE);

				name = file.getName();

			} else {
				if (!path.endsWith(".gif")) {
					// try and do the image thing!
					images = new BufferedImage[] { ImageIO.read(file) };
				} else {
					//do da gif ting! O YA, I CAN DO DAT NAO
					ArrayList<BufferedImage> imageList = getGif(path);
					images = new BufferedImage[imageList.size()];
					for(int i = 0; i < imageList.size(); i ++)
						images[i] = imageList.get(i);
				}
				thumbnail = (getScaledImage(images[0], 80, 80));
				path = file.getAbsolutePath();

				name = "";
			}
		} catch (Exception e) {
			seemsLegit = false;
			System.out.println("wat: " + e.getMessage());
			System.out.println("wat was in " + path);
		}

		this.image = images;
		this.path = path;
		this.thumbnail = thumbnail;
	}

	public boolean getSeemsLegit() {
		return seemsLegit;
	}

	private static BufferedImage getScaledImage(BufferedImage image, int width, int height) throws IOException {

		int imageWidth = image.getWidth();
		int imageHeight = image.getHeight();

		double scaleY = (double) height / imageHeight;
		double scaleX = (double) width / imageWidth;

		// fill or fit bit
		if (scaleX < scaleY)
			scaleX = scaleY;
		else
			scaleY = scaleX;

		// give us the transform object thing
		AffineTransform scaleTransform = AffineTransform.getScaleInstance(scaleX, scaleY);

		// then make the scaling algorithm thing.
		AffineTransformOp bilinearScaleOp = new AffineTransformOp(scaleTransform, AffineTransformOp.TYPE_BILINEAR);

		// out new image that we need to crop onto the buffer with the right
		// dimensions.
		BufferedImage newImage = bilinearScaleOp.filter(image, new BufferedImage((int) (imageWidth * scaleX), (int) (imageHeight * scaleY), image.getType()));
		// Image newImage = image.getScaledInstance((int) (imageWidth * scaleX),
		// (int) (imageWidth * scaleY), Image.SCALE_SMOOTH);

		// make the buffer
		BufferedImage buffer = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
		Graphics g = buffer.getGraphics();

		int newImageWidth = newImage.getWidth(null);
		int newImageHeight = newImage.getHeight(null);

		Engine.log("original: " + imageWidth + " x " + imageHeight);
		Engine.log("new:      " + width + " x " + height);
		Engine.log("after:    " + newImageWidth + " x " + newImageHeight);

		// do math, shove it on.
		g.drawImage(newImage, (width - newImageWidth) / 2, (height - newImageHeight) / 2, null);

		// return dat
		return buffer;
	}

	public BufferedImage getImage() {
		
		if (System.currentTimeMillis() > lastTime + interval) {
			pointer ++;
			if (pointer == image.length) {
				pointer = 0;
			}
			lastTime = System.currentTimeMillis();
		}

		System.out.println(pointer);
		
		return image[pointer];
	}

	public BufferedImage getThumbnail() {
		return thumbnail;
	}

	public String getPath() {
		return path;
	}

	public String getName() {
		return name;
	}
	
	public static ArrayList<BufferedImage> getGif(String path) {
		try {

			ArrayList<BufferedImage> images = new ArrayList<BufferedImage>();

			String[] imageatt = new String[] { "imageLeftPosition", "imageTopPosition", "imageWidth", "imageHeight" };

			ImageReader reader = (ImageReader) ImageIO.getImageReadersByFormatName("gif").next();
			ImageInputStream ciis = ImageIO.createImageInputStream(new File(path));
			reader.setInput(ciis, false);

			int noi = reader.getNumImages(true);

			BufferedImage master = null;

			for (int i = 0; i < noi; i++) {

				BufferedImage image = reader.read(i);
				IIOMetadata metadata = reader.getImageMetadata(i);

				Node tree = metadata.getAsTree("javax_imageio_gif_image_1.0");

				NodeList children = tree.getChildNodes();

				for (int j = 0; j < children.getLength(); j++) {

					Node nodeItem = children.item(j);

					if (nodeItem.getNodeName().equals("ImageDescriptor")) {

						Map<String, Integer> imageAttr = new HashMap<String, Integer>();

						for (int k = 0; k < imageatt.length; k++) {

							NamedNodeMap attr = nodeItem.getAttributes();

							Node attnode = attr.getNamedItem(imageatt[k]);

							imageAttr.put(imageatt[k], Integer.valueOf(attnode.getNodeValue()));

						}
						
						//if first time round
						if(i == 0)
							master = new BufferedImage(imageAttr.get("imageWidth"), imageAttr.get("imageHeight"), BufferedImage.TYPE_INT_RGB);

						master.getGraphics().drawImage(image, imageAttr.get("imageLeftPosition"), imageAttr.get("imageTopPosition"), null);

					}
				}

				BufferedImage newThing = new BufferedImage(master.getWidth(), master.getHeight(), master.getType());
				newThing.getGraphics().drawImage(master, 0, 0, null);
				images.add(newThing);

			}
			
			return images;

		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			return null;
		}
	}

}