package eu.dnetlib.functionality.modular.ui;

import java.io.IOException;
import java.lang.management.ManagementFactory;
import java.lang.management.RuntimeMXBean;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.maven.model.Model;
import org.apache.maven.model.Parent;
import org.apache.maven.model.io.xpp3.MavenXpp3Reader;
import org.springframework.beans.factory.annotation.Required;
import org.springframework.context.ResourceLoaderAware;
import org.springframework.core.io.Resource;
import org.springframework.core.io.ResourceLoader;
import org.springframework.core.io.support.ResourcePatternUtils;
import org.springframework.ui.ModelMap;

import com.google.common.collect.Lists;
import com.google.common.collect.Maps;

import eu.dnetlib.miscutils.datetime.DateUtils;
import eu.dnetlib.miscutils.datetime.HumanTime;

public class InfoController extends ModuleEntryPoint implements ResourceLoaderAware {

	private String hostname;
	private String port;
	private String context;

	private ResourceLoader resourceLoader;

	private static final Log log = LogFactory.getLog(InfoController.class);

	@Override
	protected void initialize(final ModelMap map, final HttpServletRequest request, final HttpServletResponse response) throws Exception {
		final RuntimeMXBean mxbean = ManagementFactory.getRuntimeMXBean();

		final Map<String, Map<String, String>> info = Maps.newLinkedHashMap();
		info.put("General", getGeneralInfo(mxbean));
		info.put("JVM", getJvmInfo(mxbean));
		info.put("Libraries and arguments", getLibInfo(mxbean));
		info.put("System properties", getSysInfo(mxbean));

		map.addAttribute("info", info);
		map.addAttribute("modules", getModules());

	}

	@SuppressWarnings("unchecked")
	private List<Map<String, Object>> getModules() throws IOException {
		final long start = System.currentTimeMillis();
		try {

			final Map<String, Map<String, Map<String, Object>>> modules = Maps.newLinkedHashMap();

			final MavenXpp3Reader reader = new MavenXpp3Reader();
			for (final Resource res : ResourcePatternUtils.getResourcePatternResolver(resourceLoader).getResources("classpath*:/META-INF/**/pom.xml")) {
				try {
					final Model model = reader.read(res.getInputStream());

					final String name = model.getArtifactId();

					String groupId = model.getGroupId();
					for (Parent parent = model.getParent(); (groupId == null) && (model.getParent() != null); parent = model.getParent()) {
						groupId = parent.getGroupId();
					}

					String version = model.getVersion();
					for (Parent parent = model.getParent(); (version == null) && (model.getParent() != null); parent = model.getParent()) {
						version = parent.getVersion();
					}

					if (!modules.containsKey(groupId)) {
						modules.put(groupId, new HashMap<String, Map<String, Object>>());
					}
					if (!modules.get(groupId).containsKey(name)) {
						final Map<String, Object> map = Maps.newHashMap();
						map.put("group", groupId);
						map.put("name", name);
						map.put("files", new ArrayList<String>());
						map.put("versions", new ArrayList<String>());
						modules.get(groupId).put(name, map);
					} else {
						// Artifact already found
						modules.get(groupId).get(name).put("warning", "1");
					}
					((List<String>) modules.get(groupId).get(name).get("versions")).add(version);
					((List<String>) modules.get(groupId).get(name).get("files")).add(res.getURI().toString());
				} catch (final Exception e) {
					log.error("Error evaluating pom: " + res.getURI());
					log.debug("-- ERROR --", e);
				}
			}

			final List<Map<String, Object>> list = Lists.newArrayList();
			for (final Entry<String, Map<String, Map<String, Object>>> e : modules.entrySet()) {
				for (final Entry<String, Map<String, Object>> e1 : e.getValue().entrySet()) {
					list.add(e1.getValue());
				}
			}

			Collections.sort(list, (o1, o2) -> {
				if (o1.get("group").equals(o2.get("group"))) {
					return o1.get("name").toString().compareTo(o2.get("name").toString());
				} else {
					return o1.get("group").toString().compareTo(o2.get("group").toString());
				}
			});

			return list;
		} finally {
			log.debug(" - getModules(): " + ((System.currentTimeMillis() - start) / 1000) + " seconds");
		}
	}

	private Map<String, String> getSysInfo(final RuntimeMXBean mxbean) {
		final long start = System.currentTimeMillis();
		try {
			return mxbean.getSystemProperties();
		} finally {
			log.debug(" - getSysInfo(): " + ((System.currentTimeMillis() - start) / 1000) + " seconds");
		}

	}

	private Map<String, String> getGeneralInfo(final RuntimeMXBean mxbean) {
		final long start = System.currentTimeMillis();
		try {
			final Map<String, String> genInfo = Maps.newLinkedHashMap();
			genInfo.put("Hostname", hostname);
			genInfo.put("Port", port);
			genInfo.put("Context", context);
			genInfo.put("Uptime", HumanTime.exactly(mxbean.getUptime()));
			genInfo.put("Start Time", DateUtils.calculate_ISO8601(mxbean.getStartTime()));
			return genInfo;
		} finally {
			log.debug(" - getGeneralInfo(): " + ((System.currentTimeMillis() - start) / 1000) + " seconds");
		}

	}

	private Map<String, String> getJvmInfo(final RuntimeMXBean mxbean) {
		final long start = System.currentTimeMillis();
		try {
			final Map<String, String> jvmInfo = Maps.newLinkedHashMap();
			jvmInfo.put("JVM Name", mxbean.getVmName());
			jvmInfo.put("JVM Vendor", mxbean.getVmVendor());
			jvmInfo.put("JVM Version", mxbean.getVmVersion());
			jvmInfo.put("JVM Spec Name", mxbean.getSpecName());
			jvmInfo.put("JVM Spec Vendor", mxbean.getSpecVendor());
			jvmInfo.put("JVM Spec Version", mxbean.getSpecVersion());
			jvmInfo.put("Running JVM Name", mxbean.getName());
			jvmInfo.put("Management Spec Version", mxbean.getManagementSpecVersion());
			return jvmInfo;
		} finally {
			log.debug(" - getJvmInfo(): " + ((System.currentTimeMillis() - start) / 1000) + " seconds");
		}

	}

	private Map<String, String> getLibInfo(final RuntimeMXBean mxbean) {
		final long start = System.currentTimeMillis();
		try {
			final Map<String, String> libInfo = Maps.newLinkedHashMap();
			libInfo.put("Classpath", mxbean.getClassPath().replaceAll(":", " : "));
			libInfo.put("Boot ClassPath", mxbean.getBootClassPath().replaceAll(":", " : "));
			libInfo.put("Input arguments", mxbean.getInputArguments().toString());
			libInfo.put("Library Path", mxbean.getLibraryPath().replaceAll(":", " : "));
			return libInfo;
		} finally {
			log.debug(" - getLibInfo(): " + ((System.currentTimeMillis() - start) / 1000) + " seconds");
		}

	}

	public String getHostname() {
		return hostname;
	}

	@Required
	public void setHostname(final String hostname) {
		this.hostname = hostname;
	}

	public String getPort() {
		return port;
	}

	@Required
	public void setPort(final String port) {
		this.port = port;
	}

	public String getContext() {
		return context;
	}

	@Required
	public void setContext(final String context) {
		this.context = context;
	}

	@Override
	public void setResourceLoader(final ResourceLoader resourceLoader) {
		this.resourceLoader = resourceLoader;
	}
}