package org.openslx.dozmod;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URI;
import java.net.URISyntaxException;
import java.nio.file.FileSystem;
import java.nio.file.FileSystems;
import java.nio.file.FileVisitResult;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.SimpleFileVisitor;
import java.nio.file.StandardCopyOption;
import java.nio.file.attribute.BasicFileAttributes;
import java.security.CodeSource;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Properties;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.openslx.dozmod.Config.ProxyMode;
import org.openslx.dozmod.util.OsHelper;
import org.openslx.util.Util;

public final class Branding {

	private final static Logger LOGGER = LogManager.getLogger(Branding.class);

	private static final String VIRTUALIZER_WEBSITE = "virtualizer.website";
	private static final String SERVICE_EMAIL = "service.email";
	private static final String CONFIG_DIRECTORY = "config.directory";
	private static final String SERVICE_NAME = "service.name";
	private static final String SERVICE_FAQ_WEBSITE = "service.faq.website";
	private static final String APPLICATION_NAME = "application.name";
	private static final String MASTERSERVER_IDM = "masterserver.idm";
	private static final String MASTERSERVER_ADDRESS = "masterserver.address";
	private static final String UPDATESERVER_ADDRESS = "updateserver.address";

	private final static String PROPERTIES_FILE = "branding.properties";
	private final static Properties PROPERTIES = new Properties();
	private final static List<Path> RESOURCES = new ArrayList<Path>();

	public static final String RESOURCE_FS_DIR;

	private final static Map<String, String> DEFAULTS = new HashMap<String, String>() {
		private static final long serialVersionUID = -5625624201188857134L;

		{
			put(MASTERSERVER_ADDRESS, "bwlp-masterserver.ruf.uni-freiburg.de");
			put(MASTERSERVER_IDM, "DFN-AAI");
			put(APPLICATION_NAME, "bwLehrpool-Suite");
			put(SERVICE_FAQ_WEBSITE, "https://www.bwLehrpool.de");
			put(SERVICE_NAME, "bwLehrpool");
			put(CONFIG_DIRECTORY, "bwSuite");
			put(SERVICE_EMAIL, "support@bwlehrpool.de");
			put(VIRTUALIZER_WEBSITE, "https://www.bwlehrpool.de/doku.php/allgemein/virtualisierer");
			put(UPDATESERVER_ADDRESS, "https://bwlp-masterserver.ruf.uni-freiburg.de/dozmod/");
		}
	};

	static {
		String path = null;
		try {
			RESOURCES.add(Paths.get(PROPERTIES_FILE));
			RESOURCES.add(Paths.get("img"));
			RESOURCES.add(Paths.get("txt"));
			// Built-in properties file takes precedence
			boolean ok = false;
			try (InputStream in = App.class.getClassLoader().getResourceAsStream(PROPERTIES_FILE)) {
				PROPERTIES.load(in);
				LOGGER.info("Loaded branding from jar");
				ok = true;
			} catch (Exception e) {
				LOGGER.debug("Failed to read 'jar:" + PROPERTIES_FILE + "': ");
			}
			if (!ok) {
				// Try CWD
				try (InputStream in = new FileInputStream(PROPERTIES_FILE)) {
					PROPERTIES.load(in);
					LOGGER.info("Loaded branding from current working directory");
					path = "./";
					ok = true;
				} catch (Exception e) {
					LOGGER.debug("Failed to read './" + PROPERTIES_FILE + "': ");
				}
			}
			if (!ok) {
				// Try system-wide defaults
				if (OsHelper.isWindows()) {
					path = System.getenv("ProgramData");
					if (Util.isEmptyString(path)) {
						path = "C:\\ProgramData";
					}
				} else {
					path = "/etc";
				}
				path = path + "/bwlp/";
				try (InputStream in = new FileInputStream(path + PROPERTIES_FILE)) {
					PROPERTIES.load(in);
					LOGGER.info("Loaded system-wide branding");
					ok = true;
				} catch (Exception e) {
					LOGGER.debug("Failed to read '" + path + PROPERTIES_FILE + "': ");
					path = null;
				}
			}
			// Fill in missing fields
			for (Entry<String, String> it : DEFAULTS.entrySet()) {
				if (!PROPERTIES.containsKey(it.getKey())) {
					PROPERTIES.setProperty(it.getKey(), it.getValue());
				}
			}
		} catch (Throwable t) {
			t.printStackTrace();
			System.exit(1);
		}
		RESOURCE_FS_DIR = path;
	}

	public final static String getMasterServerAddress() {
		return PROPERTIES.getProperty(MASTERSERVER_ADDRESS);
	}

	public final static String getMasterServerIdm() {
		return PROPERTIES.getProperty(MASTERSERVER_IDM);
	}

	public final static String getApplicationName() {
		return PROPERTIES.getProperty(APPLICATION_NAME);
	}

	public final static String getServiceFAQWebsite() {
		return PROPERTIES.getProperty(SERVICE_FAQ_WEBSITE);
	}

	public final static String getServiceName() {
		return PROPERTIES.getProperty(SERVICE_NAME);
	}

	public final static String getConfigDirectory() {
		return PROPERTIES.getProperty(CONFIG_DIRECTORY);
	}

	public final static String getServiceEmail() {
		return PROPERTIES.getProperty(SERVICE_EMAIL);
	}

	public final static String getVirtualizerWebsite() {
		return PROPERTIES.getProperty(VIRTUALIZER_WEBSITE);
	}

	public final static String getProxyMode() {
		return PROPERTIES.getProperty("proxy.mode", ProxyMode.AUTO.toString());
	}

	public final static String getUpdateServerAddress() {
		return PROPERTIES.getProperty("updateserver.address");
	}

	public static void dump(final String localDir) {
		if (localDir == null || localDir.isEmpty())
			return;
		final Path dumpDir = Paths.get(localDir);
		if (!Files.isDirectory(dumpDir)) {
			try {
				Files.createDirectories(dumpDir);
			} catch (IOException e) {
				LOGGER.error("Failed to create missing dump directory: ", e);
				return;
			}
		}
		final URI jarUri = getRunningJarURI();
		if (jarUri == null || jarUri.getPath() == null || jarUri.getPath().isEmpty())
			return;
		copyBranding(jarUri, dumpDir.toString(), false);

	}

	public static void pack(final String localDir, final String outputJar) {
		final URI jarUri = getRunningJarURI();
		if (jarUri == null || jarUri.getPath() == null || jarUri.getPath().isEmpty())
			return;

		final File brandingDir = new File(localDir);
		if (!brandingDir.isDirectory()) {
			LOGGER.error("Given path is not a directory: " + localDir);
			return;
		}
		final Path newJarPath = Paths.get(outputJar);
		try {
			Files.copy(Paths.get(jarUri), newJarPath);
		} catch (Exception e) {
			LOGGER.error("Failed to copy jar file at location '" + jarUri.getPath() + "' to '" + newJarPath
					+ "': ", e);
			try {
				Files.delete(newJarPath);
			} catch (IOException e1) {
				LOGGER.error("Failed to cleanup '" + newJarPath + ": ", e1);
			}
		}
		// copied jar successfully, now insert the contents from the directory
		copyBranding(newJarPath.toUri(), localDir, true);
	}

	private static void copyBranding(final URI jarUri, final String localDir, final boolean pack) {
		try (FileSystem fs = FileSystems.newFileSystem(URI.create("jar:" + jarUri),
				new HashMap<String, String>() {
					private static final long serialVersionUID = -5625624201188857134L;

					{
						put("create", "true");
						put("encoding", "UTF-8");
					}
				})) {
			// hacky default using the fs' separator as root directory
			Path rootPathJar = fs.getPath(fs.getSeparator());
			Iterator<Path> it = fs.getRootDirectories().iterator();
			if (it.hasNext()) {
				rootPathJar = it.next();
				if (it.hasNext()) {
					// there should only be one ... TODO handle multiples?
					LOGGER.debug("Multiple root directories within the JAR found? Trying with first one '"
							+ rootPathJar + "'...");
				}
			}
			Path rootPathLocal = Paths.get(localDir);
			for (Path res : RESOURCES) {
				final Path src, dst;
				if (pack) {
					src = rootPathLocal.resolve(res);
					dst = rootPathJar.resolve(rootPathLocal.relativize(res).toString());
				} else {
					src = rootPathJar.resolve(res.toString());
					dst = rootPathLocal.resolve(res);
				}
				if (!Files.isReadable(src)) {
					if (!pack && res.endsWith(PROPERTIES_FILE)) {
						// Missing properties file is OK, just dump current state
						try (FileOutputStream fos = new FileOutputStream(dst.toFile())) {
							PROPERTIES.store(fos, "");
						}
					} else {
						LOGGER.error("Failed to find or read '" + src + "'.");
					}
					continue;
				}

				if (Files.isDirectory(src)) {
					Files.walkFileTree(src, new SimpleFileVisitor<Path>() {
						@Override
						public FileVisitResult visitFile(Path file, BasicFileAttributes attrs)
								throws IOException {
							Path cur = dst.resolve(src.relativize(file).toString());
							if (!Files.isDirectory(cur.getParent())) {
								Files.createDirectory(cur.getParent());
							}
							Files.copy(file, cur, StandardCopyOption.REPLACE_EXISTING);
							return FileVisitResult.CONTINUE;
						}
					});
				} else if (Files.isRegularFile(src)) {
					Files.copy(src, dst, StandardCopyOption.REPLACE_EXISTING);
				} else {
					LOGGER.error("Unknown file type for '" + src + "'.");
				}
			}
		} catch (Exception e) {
			LOGGER.error("Failed to dump branding resources from JAR: ", e);
			return;
		}
	}

	private static URI getRunningJarURI() {
		CodeSource cs = App.class.getProtectionDomain().getCodeSource();
		if (cs == null) {
			LOGGER.error("Failed to get code source of this class.");
			return null;
		}
		try {
			return cs.getLocation().toURI();
		} catch (URISyntaxException e) {
			LOGGER.error("Failed to get location of this JAR.");
		}
		return null;
	}
}