package org.expeditee.gio.swing;

import java.awt.Toolkit;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.Transferable;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.io.File;
import java.io.IOException;
import java.util.LinkedList;
import java.util.List;

import org.expeditee.core.Image;
import org.expeditee.core.Point;
import org.expeditee.gio.ClipboardManager;
import org.expeditee.gio.DragAndDropManager;
import org.expeditee.gio.EcosystemManager;
import org.expeditee.gui.DisplayController;

/** TODO: Comment. cts16 */
public class SwingClipboardManager extends ClipboardManager {

	public static final DataFlavor expediteeDataFlavour = new DataFlavor(Object.class, "expediteeDataFlavour");
	
	// The return flavour of data in preferential order
	public static final DataFlavor[] flavours = {
			SwingClipboardManager.expediteeDataFlavour,
			DataFlavor.imageFlavor,
			DataFlavor.stringFlavor, 
			DataFlavor.javaFileListFlavor
	};
	
	private static SwingClipboardManager _instance;
	
	public static SwingClipboardManager getInstance()
	{
		if (_instance == null) {
			_instance = new SwingClipboardManager();
		}
		
		return _instance;
	}
	
	@Override
	public void set(ClipboardData data)
	{
		if (data == null) return;
		
		SwingClipboardGeneralTransferable t = new SwingClipboardGeneralTransferable(data.data);
		t.addImageRepresentation(SwingMiscManager.getIfUsingSwingImageManager().getBufferedImageForImage(data.imageRepresentation));
		t.addStringRepresentation(data.stringRepresentation);
		
		Toolkit.getDefaultToolkit().getSystemClipboard().setContents(t, null);
	}

	@Override
	public ClipboardData get()
	{
		Transferable content = Toolkit.getDefaultToolkit().getSystemClipboard().getContents(null);
		
		// No clipboard contents
		if (content == null) return null;
		
		ClipboardData ret = new ClipboardData();
		
		// Try each flavour
		for (DataFlavor flavour : flavours) {
			if (content.isDataFlavorSupported(flavour)) {
				try {
					handleGet(flavour, content, ret);
				} catch (IOException e) {
					// Data stale, just move on to next flavour
				} catch (UnsupportedFlavorException e) {
					// Shouldn't get here because we just checked, but just move on anyway
				}
			}
		}
		
		// No supported content
		return ret;
	}
	
	private void handleGet(DataFlavor flavour, Transferable content, ClipboardData out) throws IOException, UnsupportedFlavorException
	{
		if (expediteeDataFlavour.equals(flavour)) {
			out.data = content.getTransferData(flavour);
		} else if (DataFlavor.imageFlavor.equals(flavour)) {
			out.imageRepresentation = handleGetImage(content);
		} else if (DataFlavor.stringFlavor.equals(flavour)) {
			out.stringRepresentation = (String) content.getTransferData(flavour);
		} else if (DataFlavor.javaFileListFlavor.equals(flavour)) {
			@SuppressWarnings("unchecked")
			List<File> transferData = (List<File>) content.getTransferData(flavour);
			out.fileRepresentation = transferData;
		}
 	}
	
	private Image handleGetImage(Transferable content) throws IOException, UnsupportedFlavorException
	{
		Object o = content.getTransferData(DataFlavor.imageFlavor);
		
		SwingImageManager manager = SwingMiscManager.getIfUsingSwingImageManager();
		
		if (manager == null) return null;
		
		return manager.createImage((java.awt.Image) o);
	}

	/** TODO: Comment. cts16 */
	private class SwingClipboardGeneralTransferable implements Transferable
	{
		Object _data;
		java.awt.Image _imageRep;
		String _stringRep;
		
		private List<DataFlavor> _flavours;
		
		@SuppressWarnings("unused")
		public SwingClipboardGeneralTransferable()
		{
			this(null);
		}
		
		public SwingClipboardGeneralTransferable(Object data)
		{
			_flavours = new LinkedList<DataFlavor>();
			
			addGenericRepresentation(data);
		}
		
		public void addGenericRepresentation(Object data)
		{
			if (data == null) return;
			
			_data = data;
			addDataFlavour(SwingClipboardManager.expediteeDataFlavour);
		}
		
		public void addImageRepresentation(java.awt.Image image)
		{
			if (image == null) return;
			
			_imageRep = image;
			addDataFlavour(DataFlavor.imageFlavor);
		}
		
		public void addStringRepresentation(String string)
		{
			if (string == null) return;
			
			_stringRep = string;
			addDataFlavour(DataFlavor.stringFlavor);
		}

		public void addDataFlavour(DataFlavor flavour)
		{
			_flavours.add(flavour);
		}
		
		@Override
		public DataFlavor[] getTransferDataFlavors()
		{
			DataFlavor[] ret = new DataFlavor[_flavours.size()];
			int i = 0;
			for (DataFlavor flavour : _flavours) {
				ret[i] = flavour;
				i++;
			}
			return ret;
		}

		@Override
		public boolean isDataFlavorSupported(DataFlavor flavor)
		{
			for (DataFlavor flavour : _flavours) {
				if (flavour.equals(flavor)) return true;
			}
			return false;
		}

		@Override
		public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException, IOException
		{
			if (isDataFlavorSupported(flavor)) {
				if (flavor.equals(DataFlavor.imageFlavor)) {
					return _imageRep;
				} else if (flavor.equals(DataFlavor.stringFlavor)) {
					return _stringRep;
				} else {
					return _data;
				}
			} else {
				throw new UnsupportedFlavorException(flavor);
			}
		}
		
	}
	
	
}