/**
    * Copyright 2004-2014 The Kuali Foundation
    *
    * Licensed under the Educational Community License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    * http://www.opensource.org/licenses/ecl2.php
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package org.kuali.common.maven.spring;
  
  import static java.lang.String.format;
  import static org.apache.commons.lang3.StringUtils.isBlank;
  import static org.kuali.common.core.scm.maven.MavenScmUtils.MAVEN_SCM_CONNECTION_KEY;
  import static org.kuali.common.core.scm.maven.MavenScmUtils.MAVEN_SCM_DEVELOPER_CONNECTION_KEY;
  import static org.kuali.common.core.scm.maven.MavenScmUtils.MAVEN_SCM_REVISION_KEY;
  import static org.kuali.common.core.scm.maven.MavenScmUtils.MAVEN_SCM_TAG_KEY;
  import static org.kuali.common.core.scm.maven.MavenScmUtils.MAVEN_SCM_URL_KEY;
  import static org.kuali.common.core.scm.maven.MavenScmUtils.getMavenUrl;
  import static org.kuali.common.util.base.Exceptions.illegalState;
  import static org.kuali.common.util.base.Precondition.checkNotNull;
  import static org.kuali.common.util.log.Loggers.newLogger;
  
  import java.util.ArrayList;
  import java.util.List;
  import java.util.Properties;
  
  import org.apache.maven.model.Scm;
  import org.apache.maven.project.MavenProject;
  import org.apache.maven.settings.Settings;
  import org.kuali.common.core.scm.api.ScmContext;
  import org.kuali.common.core.scm.api.ScmType;
  import org.kuali.common.core.scm.maven.MavenScmUtils;
  import org.kuali.common.util.CollectionUtils;
  import org.kuali.common.util.LocationUtils;
  import org.kuali.common.util.maven.RepositoryUtils;
  import org.kuali.common.util.maven.model.Dependency;
  import org.kuali.common.util.nullify.NullUtils;
  import org.slf4j.Logger;
  
  import com.google.common.base.Optional;
  
  /**
   * Maven related utilities that are aware of the Maven model objects eg MavenProject
   */
  public class MavenAwareUtils {
  
  	private static final Logger logger = newLogger();
  
  	public static ScmType getScmType(Scm scm) {
  		if (!isBlank(scm.getDeveloperConnection())) {
  			return MavenScmUtils.getScmType(scm.getDeveloperConnection());
  		} else if (!isBlank(scm.getConnection())) {
  			return MavenScmUtils.getScmType(scm.getConnection());
  		} else {
  			throw illegalState("unable to determine scm type. both connection and developerConnection are blank");
  		}
  	}
  
  	public static void updateMavenScm(MavenProject project, ScmContext context) {
  		checkNotNull(project, "project");
  		checkNotNull(context, "context");
  		Scm scm = checkNotNull(project.getScm(), "scm");
  		ScmType type = context.getType();
  		scm.setDeveloperConnection(checkConverted(MAVEN_SCM_DEVELOPER_CONNECTION_KEY, type, scm.getDeveloperConnection(), context.getPushUrl()));
  		scm.setConnection(checkConverted(MAVEN_SCM_CONNECTION_KEY, type, scm.getConnection(), context.getFetchUrl()));
  		scm.setUrl(checkEquals(MAVEN_SCM_URL_KEY, type, scm.getUrl(), context.getBrowseUrl()));
  		scm.setTag(checkEquals(MAVEN_SCM_TAG_KEY, scm.getTag(), context.getLabel()));
  		String revision = context.getRevision().isPresent() ? context.getRevision().get() : NullUtils.NONE;
  		project.getProperties().setProperty(MAVEN_SCM_REVISION_KEY, revision);
  	}
  
  	private static String checkEquals(String label, String oldTag, Optional<String> newTag) {
  		String newTagValue = newTag.isPresent() ? newTag.get() : NullUtils.NONE;
  		if (!newTagValue.equals(oldTag)) {
  			logUpdate(label, oldTag, newTagValue);
  		}
  		return newTagValue;
  	}
  
  	private static String checkEquals(String label, ScmType type, String oldUrl, String newUrl) {
  		if (!newUrl.equals(oldUrl)) {
  			logUpdate(label, oldUrl, newUrl);
  		}
  		return newUrl;
  	}
  
  	private static String checkConverted(String label, ScmType type, String oldMavenUrl, String newRawUrl) {
  		String newMavenUrl = getMavenUrl(type, newRawUrl);
  		if (!newMavenUrl.equals(oldMavenUrl)) {
  			logUpdate(label, oldMavenUrl, newMavenUrl);
  		}
  		return newMavenUrl;
 	}
 
 	private static void logUpdate(String label, String before, String after) {
 		logger.info(format("updating -> %s", label));
 		logger.info(format("before   -> %s", before));
 		logger.info(format("after    -> %s", after));
 	}
 
 	public static Properties getInternalProperties(MavenProject project, Settings settings) {
 		Properties properties = new Properties();
 		nullSafeSet(properties, "project.id", project.getId());
 		nullSafeSet(properties, "project.groupId", project.getGroupId());
 		nullSafeSet(properties, "project.artifactId", project.getArtifactId());
 		nullSafeSet(properties, "project.version", project.getVersion());
 		nullSafeSet(properties, "project.packaging", project.getPackaging());
 		nullSafeSet(properties, "project.name", project.getName());
 		nullSafeSet(properties, "project.description", project.getDescription());
 		nullSafeSet(properties, "project.inceptionYear", project.getInceptionYear());
 		nullSafeSet(properties, "project.basedir", LocationUtils.getCanonicalPath(project.getBasedir()));
 		if (project.getCiManagement() != null) {
 			nullSafeSet(properties, "project.ciManagement.system", project.getCiManagement().getSystem());
 			nullSafeSet(properties, "project.ciManagement.url", project.getCiManagement().getUrl());
 		}
 		if (project.getIssueManagement() != null) {
 			nullSafeSet(properties, "project.issueManagement.system", project.getIssueManagement().getSystem());
 			nullSafeSet(properties, "project.issueManagement.url", project.getIssueManagement().getUrl());
 		}
 		if (project.getBuild() != null) {
 			nullSafeSet(properties, "project.build.directory", project.getBuild().getDirectory());
 			nullSafeSet(properties, "project.build.outputDirectory", project.getBuild().getOutputDirectory());
 			nullSafeSet(properties, "project.build.testOutputDirectory", project.getBuild().getTestOutputDirectory());
 			nullSafeSet(properties, "project.build.sourceDirectory", project.getBuild().getSourceDirectory());
 			nullSafeSet(properties, "project.build.scriptSourceDirectory", project.getBuild().getScriptSourceDirectory());
 			nullSafeSet(properties, "project.build.testSourceDirectory", project.getBuild().getTestSourceDirectory());
 		}
 		if (project.getScm() != null) {
 			nullSafeSet(properties, MAVEN_SCM_CONNECTION_KEY, project.getScm().getConnection());
 			nullSafeSet(properties, MAVEN_SCM_DEVELOPER_CONNECTION_KEY, project.getScm().getDeveloperConnection());
 			nullSafeSet(properties, MAVEN_SCM_URL_KEY, project.getScm().getUrl());
 			nullSafeSet(properties, MAVEN_SCM_TAG_KEY, project.getScm().getTag());
 		}
 		nullSafeSet(properties, "project.pom.location", getPomLocation(project));
 		List<Dependency> dependencies = convertToSimplePojos(project.getDependencies());
 		nullSafeSet(properties, "project.dependencies", getDependenciesCSV(dependencies));
 		if (settings != null) {
 			nullSafeSet(properties, "settings.localRepository", settings.getLocalRepository());
 			nullSafeSet(properties, "settings.modelEncoding", settings.getModelEncoding());
 			nullSafeSet(properties, "settings.sourceLevel", settings.getSourceLevel());
 			if (settings.getInteractiveMode() != null) {
 				nullSafeSet(properties, "settings.interactiveMode", settings.getInteractiveMode() + "");
 			}
 		}
 		return properties;
 	}
 
 	public static Properties getInternalProperties(MavenProject project) {
 		return getInternalProperties(project, null);
 	}
 
 	/**
 	 * Don't call setProperty() if value is null
 	 */
 	public static void nullSafeSet(Properties properties, String key, String value) {
 		if (value != null) {
 			properties.setProperty(key, value);
 		}
 	}
 
 	// Maven automatically stores the pom to this location
 	public static String getPomLocation(MavenProject project) {
 		StringBuilder sb = new StringBuilder();
 		sb.append("classpath:");
 		sb.append("META-INF");
 		sb.append("/");
 		sb.append("maven");
 		sb.append("/");
 		sb.append(project.getGroupId());
 		sb.append("/");
 		sb.append(project.getArtifactId());
 		sb.append("/");
 		sb.append("pom.xml");
 		return sb.toString();
 	}
 
 	/**
 	 * Convert the formal Maven dependency objects into vanilla pojo objects
 	 */
 	public static List<Dependency> convertToSimplePojos(List<org.apache.maven.model.Dependency> dependencies) {
 		List<Dependency> pojos = new ArrayList<Dependency>();
 		for (org.apache.maven.model.Dependency d : CollectionUtils.toEmptyList(dependencies)) {
 			Dependency pojo = new Dependency.Builder(d.getGroupId(), d.getArtifactId(), d.getVersion()).classifier(d.getClassifier()).type(d.getType()).scope(d.getScope()).build();
 			pojos.add(pojo);
 		}
 		return pojos;
 
 	}
 
 	/**
 	 * Convert the list of dependencies into a CSV string
 	 */
 	public static String getDependenciesCSV(List<Dependency> dependencies) {
 		if (CollectionUtils.isEmpty(dependencies)) {
 			return NullUtils.NONE;
 		}
 		StringBuilder sb = new StringBuilder();
 		for (int i = 0; i < dependencies.size(); i++) {
 			if (i != 0) {
 				sb.append(",");
 			}
 			Dependency dependency = dependencies.get(i);
 			sb.append(RepositoryUtils.toString(dependency));
 		}
 		return sb.toString();
 	}
 }