/*
    * Copyright (C) 2007-2012 Argeo GmbH
    *
    * Licensed under the Apache 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.apache.org/licenses/LICENSE-2.0
    *
   * 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.argeo.slc.lib.linux.rpmfactory;
  
  import java.io.File;
  import java.io.IOException;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Set;
  
  import org.apache.commons.exec.Executor;
  import org.apache.commons.io.FileUtils;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.argeo.slc.SlcException;
  import org.argeo.slc.core.execution.tasks.SystemCall;
  
  /** Rebuild an SRPM in mock. (Historical) Replaces the build-mock.sh script. */
  public class BuildInMock implements Runnable {
  	private final static Log log = LogFactory.getLog(BuildInMock.class);
  
  	/** Mock flavour provided by the EPEL repository */
  	public final static String EPEL = "EPEL";
  	/** Mock flavour provided by CentOS until v5 */
  	public final static String CENTOS = "CENTOS";
  
  	public final static String NOARCH = "noarch";
  
  	private String mockVar = "/var/lib/mock";
  
  	private String mockFlavour = EPEL;
  	private String mockConfig = null;
  
  	private String repository;
  	private String release = null;
  	private String level = null;
  	private String arch = NOARCH;
  
  	private String rpmPackage = null;
  
  	private Boolean mkdirs = true;
  
  	private RpmBuildEnvironment buildEnvironment;
  	private Executor executor;
  
  	private String debuginfoDirName = "debuginfo";
  
  	public void run() {
  		// TODO check if caller is in mock group
  
  		String cfgId = repository + "-" + release + "-" + arch;
  		String cfg = mockConfig != null ? mockConfig : "slc/" + cfgId;
  
  		// prepare mock call
  		SystemCall mock = new SystemCall();
  		if (arch != null)
  			mock.arg("setarch").arg(arch);
  		mock.arg("mock");
  		if (mockFlavour.equals(EPEL))
  			mock.arg("-v");
  		else if (mockFlavour.equals(CENTOS))
  			mock.arg("--debug");
  		if (arch != null)
  			mock.arg("--arch=" + arch);
  		mock.arg("-r").arg(cfg);
  
  		mock.arg("--scm-enable");
  		mock.arg("--scm-option").arg("package=" + rpmPackage);
  
  		mock.setLogCommand(true);
  
  		// mock command execution
  		mock.setExecutor(executor);
  		mock.run();
  
  		// File repoDir = new File(buildEnvironment.getStagingBase() + "/"
  		// + repository + "/" + level + "/" + release);
  		File repoDir = new File(buildEnvironment.getStagingBase() + "/"
  				+ repository + "-" + release + "-staging");
  		File srpmDir = new File(repoDir, "SRPMS");
  		if (mkdirs)
  			srpmDir.mkdirs();
  		File archDir = null;
  		File debuginfoDir = null;
 		if (!arch.equals(NOARCH)) {
 			archDir = new File(repoDir, arch);
 			debuginfoDir = new File(archDir, debuginfoDirName);
 			debuginfoDir.mkdirs();
 		}
 
 		// copy RPMs
 		Set<File> reposToRecreate = new HashSet<File>();
 		File resultDir = new File(mockVar + "/" + cfgId + "/result");
 		rpms: for (File file : resultDir.listFiles()) {
 			if (file.isDirectory())
 				continue rpms;
 
 			File[] targetDirs;
 			if (file.getName().contains(".src.rpm"))
 				targetDirs = new File[] { srpmDir };
 			else if (file.getName().contains("-debuginfo-"))
 				targetDirs = new File[] { debuginfoDir };
 			else if (!arch.equals(NOARCH)
 					&& file.getName().contains("." + arch + ".rpm"))
 				targetDirs = new File[] { archDir };
 			else if (file.getName().contains(".noarch.rpm")) {
 				List<File> dirs = new ArrayList<File>();
 				for (String arch : buildEnvironment.getArchs())
 					dirs.add(new File(repoDir, arch));
 				targetDirs = dirs.toArray(new File[dirs.size()]);
 			} else if (file.getName().contains(".rpm"))
 				throw new SlcException("Don't know where to copy " + file);
 			else {
 				if (log.isTraceEnabled())
 					log.trace("Skip " + file);
 				continue rpms;
 			}
 
 			reposToRecreate.addAll(Arrays.asList(targetDirs));
 			copyToDirs(file, targetDirs);
 		}
 
 		// recreate changed repos
 		for (File repoToRecreate : reposToRecreate) {
 			SystemCall createrepo = new SystemCall();
 			createrepo.arg("createrepo");
 			// sqllite db
 			createrepo.arg("-d");
 			// debuginfo
 			if (!repoToRecreate.getName().equals(debuginfoDirName))
 				createrepo.arg("-x").arg(debuginfoDirName + "/*");
 			// quiet
 			createrepo.arg("-q");
 			createrepo.arg(repoToRecreate.getAbsolutePath());
 
 			createrepo.setExecutor(executor);
 			createrepo.run();
 			log.info("Updated repo " + repoToRecreate);
 		}
 	}
 
 	protected void copyToDirs(File file, File[] dirs) {
 		for (File dir : dirs) {
 			try {
 				FileUtils.copyFileToDirectory(file, dir);
 				if (log.isDebugEnabled())
 					log.debug(file + " => " + dir);
 			} catch (IOException e) {
 				throw new SlcException("Cannot copy " + file + " to " + dir, e);
 			}
 		}
 	}
 
 	public void setMockFlavour(String mockFlavour) {
 		this.mockFlavour = mockFlavour;
 	}
 
 	public void setMockConfig(String mockConfig) {
 		this.mockConfig = mockConfig;
 	}
 
 	public void setRepository(String repo) {
 		this.repository = repo;
 	}
 
 	public void setRelease(String release) {
 		this.release = release;
 	}
 
 	public void setLevel(String level) {
 		this.level = level;
 	}
 
 	public void setArch(String arch) {
 		this.arch = arch;
 	}
 
 	public void setRpmPackage(String rpmPackage) {
 		this.rpmPackage = rpmPackage;
 	}
 
 	public void setMockVar(String mockVar) {
 		this.mockVar = mockVar;
 	}
 
 	public void setMkdirs(Boolean mkdirs) {
 		this.mkdirs = mkdirs;
 	}
 
 	public void setBuildEnvironment(RpmBuildEnvironment buildEnvironment) {
 		this.buildEnvironment = buildEnvironment;
 	}
 
 	public void setExecutor(Executor executor) {
 		this.executor = executor;
 	}
 
 }