package org.openslx.dozmod.gui;

import java.awt.AWTEvent;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Frame;
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;
import java.awt.Insets;
import java.awt.KeyboardFocusManager;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.Toolkit;
import java.awt.Window;
import java.awt.event.AWTEventListener;
import java.lang.reflect.InvocationTargetException;
import java.net.URISyntaxException;
import java.util.concurrent.atomic.AtomicReference;

import javax.management.monitor.Monitor;
import javax.swing.Icon;
import javax.swing.JEditorPane;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.SwingUtilities;
import javax.swing.UIManager;
import javax.swing.event.HyperlinkEvent;
import javax.swing.event.HyperlinkListener;
import javax.swing.text.html.HTMLDocument;

import org.apache.log4j.Logger;
import org.openslx.dozmod.Config;
import org.openslx.dozmod.gui.helper.MessageType;
import org.openslx.dozmod.util.DesktopEnvironment;
import org.openslx.dozmod.util.ResourceLoader;
import org.openslx.util.QuickTimer;

public class Gui {

	private static final Logger LOGGER = Logger.getLogger(Gui.class);
	
	private static long lastUserActivity = System.currentTimeMillis();
	
	static {
		Toolkit.getDefaultToolkit().addAWTEventListener(new AWTEventListener() {
			@Override
			public void eventDispatched(AWTEvent event) {
				lastUserActivity = System.currentTimeMillis();
			}
		}, AWTEvent.MOUSE_EVENT_MASK | AWTEvent.KEY_EVENT_MASK);
	}

	private static Rectangle clientArea(GraphicsDevice gd) {
		Insets inset = Toolkit.getDefaultToolkit().getScreenInsets(gd.getDefaultConfiguration());
		Rectangle bounds = gd.getDefaultConfiguration().getBounds();
		bounds.x += inset.left;
		bounds.y += inset.top;
		bounds.width -= (inset.top + inset.bottom);
		bounds.height -= (inset.left + inset.right);
		return bounds;
	}

	/**
	 * Center the given shell on the {@link Monitor} it is displayed on.
	 * WARNING: Seems broken on Linux (depending on DE or WM)
	 * 
	 * @param shell Some shell
	 */
	public static void centerShell(Window shell) {
		GraphicsDevice activeMonitor = getMonitorFromRectangle(shell.getBounds(), true);
		Rectangle bounds = clientArea(activeMonitor);
		Rectangle rect = shell.getBounds();
		int x = bounds.x + (bounds.width - rect.width) / 2;
		int y = bounds.y + (bounds.height - rect.height) / 2;
		shell.setLocation(x, y);
	}

	/**
	 * Take a shell and center it relative to another shell
	 * 
	 * @param parent Parent shell, used as reference
	 * @param shellToCenter The shell that should be repositioned
	 */
	public static void centerShellOverShell(Window parent, Window shellToCenter) {
		Rectangle bounds = parent.getBounds();
		Rectangle rect = shellToCenter.getBounds();
		int x = bounds.x + (bounds.width - rect.width) / 2;
		int y = bounds.y + (bounds.height - rect.height) / 2;
		if (x < bounds.x)
			x = bounds.x;
		if (y < bounds.y)
			y = bounds.y;
		shellToCenter.setLocation(x, y);
	}

	/**
	 * Make sure the given shell fits the {@link GraphicsDevice} it is displayed
	 * on.
	 * 
	 * @param shell Some shell
	 */
	public static void limitShellSize(JFrame window) {
		GraphicsDevice activeMonitor = getMonitorFromRectangle(window.getBounds(), true);
		Rectangle bounds = clientArea(activeMonitor);
		Rectangle rect = window.getBounds();
		boolean changed = false;
		if (rect.width + 20 > bounds.width) {
			rect.width = bounds.width - 20;
			changed = true;
		}
		if (rect.height + 20 > bounds.height) {
			rect.height = bounds.height - 20;
			changed = true;
		}
		if (changed) {
			window.setSize(rect.width, rect.height);
			rect = window.getBounds();
		}
		changed = false;
		if (rect.x + rect.width >= bounds.x + bounds.width) {
			rect.x = 5;
			changed = true;
		}
		if (rect.y + rect.height >= bounds.y + bounds.height) {
			rect.y = 5;
			changed = true;
		}
		if (changed) {
			window.setLocation(rect.x, rect.y);
		}
	}

	/**
	 * Gets the given dimension scaled to the saved scaling factor
	 * 
	 * @param width starting width to scale
	 * @param height starting height to scale
	 * @return scaled dimension
	 */
	public static Dimension getScaledDimension(int width, int height) {
		int scale = Config.getFontScaling();
		return new Dimension(width * scale / 100, height * scale / 100);
	}
	
	/**
	 * Load given icon resource, optionally scaling it while taking
	 * the user's zoom factor into account.
	 *
	 * @param path resource path
	 * @param description resource description
	 * @param maxHeight maximum height of image, which it will be scaled to
	 * @param context context component, for alpha blending
	 * @return scaled icon, if too large, otherwise the unmodified icon
	 */
	public static Icon getScaledIconResource(String path, String description, int maxHeight, Component context) {
		int height = maxHeight * Config.getFontScaling() / 100;
		return ResourceLoader.getIcon(path, description, height, context);
	}

	/**
	 * Get the {@link GraphicsDevice} which the given {@link Point} lies in.
	 * 
	 * @param point The point in question
	 * @param defaultToPrimary if no monitor matches the check, return the
	 *            primary monitor if true, <code>null</code> otherwise
	 * @return the {@link GraphicsDevice}
	 */
	private static GraphicsDevice getMonitorFromPoint(GraphicsDevice[] screens, Point point,
			boolean defaultToPrimary) {
		LOGGER.debug("Finding monitor for point " + point.toString());
		for (GraphicsDevice dev : screens) {
			Rectangle bounds = dev.getDefaultConfiguration().getBounds();
			LOGGER.debug("Checking monitor " + bounds.toString());
			if (bounds.contains(point))
				return dev;
		}
		if (defaultToPrimary) {
			LOGGER.debug("Defaulting to primary...");
			return GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice();
		}
		return null;
	}

	/**
	 * Get the {@link GraphicsDevice} which most of the given rectangle
	 * overlaps.
	 * 
	 * @param rect The rectangle to check
	 * @param defaultToPrimary if no monitor matches the check, return the
	 *            primary monitor if true, <code>null</code> otherwise
	 * @return the {@link GraphicsDevice}
	 */
	public static GraphicsDevice getMonitorFromRectangle(Rectangle rect, boolean defaultToPrimary) {
		// Make sure rectangle is in bounds. This is not completely accurate
		// in case there are multiple monitors that have different resolutions.
		GraphicsDevice[] screens = GraphicsEnvironment.getLocalGraphicsEnvironment().getScreenDevices();
		Rectangle bounds = new Rectangle();
		for (GraphicsDevice dev : screens) {
			bounds = bounds.union(dev.getDefaultConfiguration().getBounds());
		}
		LOGGER.debug("Display bounds are " + bounds.toString() + ", rect is " + rect.toString());
		if (rect.x + rect.width >= bounds.x + bounds.width) {
			rect.width -= (rect.x + rect.width) - (bounds.x + bounds.width);
			if (rect.width < 1)
				rect.width = 1;
		}
		if (rect.y + rect.height >= bounds.y + bounds.height) {
			rect.height -= (rect.y + rect.height) - (bounds.y + bounds.height);
			if (rect.height < 1)
				rect.height = 1;
		}
		if (rect.x < bounds.x) {
			rect.width -= bounds.x - rect.x;
			rect.x = bounds.x;
		}
		if (rect.y < bounds.y) {
			rect.height -= bounds.y - rect.y;
			rect.y = bounds.y;
		}
		LOGGER.debug("After correction: " + rect.toString());
		// Now just use the same code as *FromPoint by using the rectangle's center
		return getMonitorFromPoint(screens, new Point(rect.x + rect.width / 2, rect.y + rect.height / 2),
				defaultToPrimary);
	}

	/**
	 * Run given task in the GUI thread, blocking the calling thread until the
	 * task is done.
	 * 
	 * @param task Task to run
	 * @return return value of the task
	 */
	public static <T> T syncExec(final GuiCallable<T> task) {
		final AtomicReference<T> instance = new AtomicReference<>();
		final AtomicReference<Throwable> thrown = new AtomicReference<>();
		if (SwingUtilities.isEventDispatchThread()) {
			return task.run();
		}
		try {
			SwingUtilities.invokeAndWait(new Runnable() {
				@Override
				public void run() {
					try {
						instance.set(task.run());
					} catch (Throwable e) {
						thrown.set(e);
					}
				}
			});
		} catch (InvocationTargetException | InterruptedException e) {
			LOGGER.warn("syncExec() failed", e);
			return null;
		}
		if (thrown.get() != null) {
			throw new RuntimeException("task passed to syncExec() failed", thrown.get());
		}
		return instance.get();
	}

	/**
	 * Run given task as soon as possible in the GUI thread, but don't block
	 * calling thread.
	 * 
	 * @param task Task to run
	 */
	public static void asyncExec(final Runnable task) {
		SwingUtilities.invokeLater(task);
	}

	/**
	 * Pretty much the same as Callable, but no exceptions are allowed.
	 * 
	 * @param <T> return value
	 */
	public static interface GuiCallable<T> {
		T run();
	}

	/**
	 * Exit application - dispose all shells, so mainloop will terminate.
	 * 
	 * @param code
	 */
	public static void exit(int code) {
		QuickTimer.cancel();
		Window[] ownerlessWindows = Frame.getOwnerlessWindows();
		for (Window w : ownerlessWindows) {
			w.dispose();
		}
		System.exit(code);
	}

	/**
	 * Generic helper to show a message box to the user, and optionally log the
	 * message to the log file.
	 * 
	 * @param parent parent window (used for positioning/modality). If null,
	 *            the active window will be used
	 * @param message Message to display. Can be multi line.
	 * @param messageType Type of message (warning, information)
	 * @param logger Logger instance to log to. Can be null.
	 * @param exception Exception related to this message. Can be null.
	 * @return true if OK or YES was clicked, false for CANCEL/NO/(X)
	 */
	public static boolean showMessageBox(Component parent, String message, MessageType messageType,
			Logger logger, Throwable exception) {
		if (logger != null)
			logger.log(messageType.logPriority, message, exception);
		// Only needs to be done, if parent isn't already a window
		if (parent == null) {
			parent = KeyboardFocusManager.getCurrentKeyboardFocusManager().getActiveWindow();
		} else if (!(parent instanceof Window)) {
			Window ancestor = SwingUtilities.getWindowAncestor(parent);
			if (ancestor != null) {
				parent = ancestor;
			}
		}

		if (exception != null) {
			message += "\n\n" + exception.getClass().getSimpleName() + "\n" + exception.getMessage() + "\n"
					+ " (Für Stack-Trace siehe Logdatei)";
		}
		if (message.startsWith("<html>")) {
			JEditorPane ep = new JEditorPane("text/html", message);
			ep.setEditable(false);
			ep.setOpaque(false);

			Font font = UIManager.getFont("Label.font");
			String bodyRule = "body { font-family: " + font.getFamily() + "; " +
					"font-size: " + font.getSize() + "pt; }";
			((HTMLDocument)ep.getDocument()).getStyleSheet().addRule(bodyRule);

			ep.addHyperlinkListener(new HyperlinkListener() {
				@Override
				public void hyperlinkUpdate(HyperlinkEvent e) {
					if (e.getEventType().equals(HyperlinkEvent.EventType.ACTIVATED)) {
						try {
							DesktopEnvironment.openWebpageUri(e.getURL().toURI());
						} catch (URISyntaxException ex) {
							LOGGER.error("Couldn't parse hyperlink", ex);
						}
					}
				}
			});
			JOptionPane.showMessageDialog(parent, ep, messageType.title, messageType.optionPaneId);
			return true;
		}
		if (messageType.buttons == -1) {
			JOptionPane.showMessageDialog(parent, message, messageType.title, messageType.optionPaneId);
			return true;
		}
		// TODO set the default button that has focus
		int ret = JOptionPane.showConfirmDialog(parent, message, messageType.title, messageType.buttons,
				messageType.optionPaneId);
		return ret == JOptionPane.OK_OPTION || ret == JOptionPane.YES_OPTION;
	}

	/**
	 * Generic helper to show a message box to the user, and optionally log the
	 * message to the log file.
	 * 
	 * @param message Message to display. Can be multi line.
	 * @param messageType Type of message (warning, information)
	 * @param logger Logger instance to log to. Can be null.
	 * @param exception Exception related to this message. Can be null.
	 * @return true if OK or YES was clicked, false for CANCEL/NO/(X)
	 */
	public static boolean showMessageBox(String message, MessageType messageType, Logger logger,
			Throwable exception) {
		return showMessageBox(null, message, messageType, logger, exception);
	}

	/**
	 * Show a message box to the user asynchronously, and optionally log the
	 * message to the log file. This is most useful when working from another
	 * thread.
	 * 
	 * @param message Message to display. Can be multi line.
	 * @param messageType Type of message (warning, information)
	 * @param logger Logger instance to log to. Can be null.
	 * @param exception Exception related to this message. Can be null.
	 * @return true if OK or YES was clicked, false for CANCEL/NO/(X)
	 */
	public static void asyncMessageBox(final String message, final MessageType messageType,
			final Logger logger, final Throwable exception) {
		if (SwingUtilities.isEventDispatchThread()) {
			Gui.showMessageBox(message, messageType, logger, exception);
			return;
		}
		SwingUtilities.invokeLater(new Runnable() {
			@Override
			public void run() {
				showMessageBox(null, message, messageType, logger, exception);
			}
		});
	}
	
	/**
	 * Get last user activity timestamp.
	 * This considers mouse clicks and key presses.
	 */
	public static long getLastUserActivityMillis() {
		return lastUserActivity;
	}

}