<?php

include_once dirname(__FILE__) . '/SilverStripeBuildTask.php';

/**
 * A phing task to load modules from a specific URL via SVN, git checkout, or
 * through the "piston" binary (http://piston.rubyforge.org).
 *
 * Passes commands directly to the commandline to actually perform the
 * svn checkout/updates, so you must have these on your path when this
 * runs.
 *
 * @author Marcus Nyeholt <marcus@silverstripe.com.au>
 *
 */
class LoadModulesTask extends SilverStripeBuildTask {
	/**
	 * Character used to separate the module/revision name from the output path
	 */
	const MODULE_SEPARATOR = ':';

	/**
	 * The file that defines the dependency
	 *
	 * @var String
	 */
	private $file = '';
	/**
	 * Optionally specify a module name
	 *
	 * @var String
	 */
	private $name = '';
	/**
	 * And a module url
	 * @var String
	 */
	private $url = '';
	
	/**
	 * Is this a non-interactive build session?
	 * @var boolean
	 */
	private $nonInteractive = false;
	
	public function setNoninteractive($v) {
		if (!strpos($v, '${') && $v == 'true' || $v == 1) {
			$this->nonInteractive = true;
		}
	}

	public function setFile($v) {
		$this->file = $v;
	}

	public function setName($v) {
		$this->name = $v;
	}

	public function setUrl($v) {
		$this->url = $v;
	}

	public function main() {
		// $this->configureEnvFile();

		if ($this->name) {
			$this->loadModule($this->name, $this->url);
		} else {
			// load the items from the dependencies file
			if (!file_exists($this->file)) {
				throw new BuildException("Modules file " . $this->modulesFile . " cannot be read");
			}

			$items = file($this->file);
			foreach ($items as $item) {
				$item = trim($item);
				if (strpos($item, '#') === 0) {
					continue;
				}

				$bits = preg_split('/\s+/', $item);
				// skip malformed lines
				if (count($bits) < 2) {
					continue;
				}

				$moduleName = trim($bits[0], '/');
				$url = trim($bits[1], '/');
				$storeLocally = false;
				$usePiston = false;
				if (isset($bits[2])) {
					$devBuild = $bits[2] == 'true';
					$storeLocally = $bits[2] == 'local';
					$usePiston = $bits[2] == 'piston';
					if (isset($bits[3])) {
						$storeLocally = $bits[3] == 'local';
						$usePiston = $bits[3] == 'piston';
					}
				}
				
				$this->loadModule($moduleName, $url, $devBuild, $storeLocally, $usePiston);
			}
		}
	}

	/**
	 * Actually load the module!
	 *
	 * @param String $moduleName
	 * @param String $url
	 * @param boolean $devBuild
	 * 			Do we run a dev/build?
	 * @param boolean $storeLocally
	 *			Should we store the module locally, for it to be included in 
	 *			the local project's repository?
	 * @param boolean $usePiston Same as $storeLocally, but retain versioning metadata in piston.
	 */
	protected function loadModule($moduleName, $url, $devBuild = false, $storeLocally=false, $usePiston=false) {
		$git = strrpos($url, '.git') == (strlen($url) - 4);
		$branch = 'master';
		
		$originalName = $moduleName;

		if (strpos($moduleName, self::MODULE_SEPARATOR) > 0) {
			$branch = substr($moduleName, strpos($moduleName, self::MODULE_SEPARATOR) + 1);
			$moduleName = substr($moduleName, 0, strpos($moduleName, self::MODULE_SEPARATOR));
		}

		$md = $this->loadMetadata();
		if (!isset($md['store'])) {
			// backwards compatibility
			$md['store'] = false;
		}
		
		// create loader
		if($usePiston) {
			$loader = new LoadModulesTask_PistonLoader($this, $moduleName, $url, $branch);
		} elseif($git) {
			$loader = new LoadModulesTask_GitLoader($this, $moduleName, $url, $branch);
		} else {
			$loader = new LoadModulesTask_SubversionLoader($this, $moduleName, $url, $branch);
		}

		// check the module out if it doesn't exist
		if (!file_exists($moduleName)) {
			$this->log("Check out $moduleName from $url");
			
			// Create new working copy
			$loader->checkout($storeLocally);

			// Ignore locally added modules from base working copy.
			// Only applies when this base contains versioning information.
			// Note: This is specific to the base working copy, not the module itself.
			if (!$storeLocally && !$usePiston && file_exists('.gitignore')) {
				$gitIgnore = file_get_contents('.gitignore');
				if (strpos($gitIgnore, $moduleName) === false) {
					$this->exec("echo $moduleName >> .gitignore");
				}
			}
		} else {
			$this->log("Updating $moduleName $branch from $url");
			
			// Check for modifications
			// TODO Shows all files as modified when switching repository types or branches'
			$overwrite = true;
			$mods = $loader->getModifiedFiles();
			if (strlen($mods) && !$storeLocally) {
				$this->log("The following files are locally modified");
				$this->log($mods);
				if (!$this->nonInteractive) {
					$overwrite = strtolower(trim($this->getInput("Overwrite local changes? [y/N]")));
					$overwrite = $overwrite == 'y';
				} 
			}

			// get the metadata and make sure it's not the same
			// TODO Doesn't handle switch from git to svn repositories
			if ($md && isset($md[$moduleName]) && isset($md[$moduleName]['url'])) {
				if (
					$md[$moduleName]['url'] != $url 
					|| $md[$moduleName]['store'] != $storeLocally
					|| $md[$moduleName]['piston'] != $usePiston
				) {
					if ($overwrite) {
					// delete the directory and reload the module
						$this->log("Deleting $moduleName and reloading");
						unset($md[$moduleName]);
						$this->writeMetadata($md);
						rrmdir($moduleName, true);
						// TODO Doesn't handle changes between svn/git/piston
						$loader->checkout($storeLocally);
						return;
					} else {
						throw new Exception("You have chosen not to overwrite changes, but also want to change your " .
							"SCM settings. Please resolve changes and try again");
					}
				}
			}
			
			// Update existing versioned copy
			$loader->update($overwrite);
		}

		// Write new metadata
		$metadata = array(
			'url' => $url,
			'store' => $storeLocally,
			'piston' => $usePiston,
			'branch' => str_replace($moduleName, '', $originalName),
		);
		$md[$moduleName] = $metadata;
		$this->writeMetadata($md);
		
		// Make sure to remove from the .gitignore file - don't need to do it EVERY 
		// run, but it's better than munging code up above
		if ($storeLocally && file_exists('.gitignore')) {
			$gitIgnore = file('.gitignore');
			$newIgnore = array();
			foreach ($gitIgnore as $line) {
				$line = trim($line);
				if (!$line || $line == $moduleName || $line == "$moduleName/") {
					continue;
				}
				$newIgnore[] = $line;
			}
			file_put_contents('.gitignore', implode("\n", $newIgnore));
		}
		
		if ($devBuild) $this->devBuild();
	}
	
	protected function loadMetadata() {
		$metadataFile = dirname(__FILE__) . DIRECTORY_SEPARATOR . 'phing-metadata';
		
		$md = array();
		if (file_exists($metadataFile)) {
			$md = unserialize(file_get_contents($metadataFile));
		}
		
		return $md;
	}
	
	protected function writeMetadata($md) {
		$metadataFile = dirname(__FILE__) . DIRECTORY_SEPARATOR . 'phing-metadata';
		file_put_contents($metadataFile, serialize($md));
	}


}

if (!function_exists('rrmdir')) {
	function rrmdir($dir) {
		if (is_dir($dir)) {
			$objects = scandir($dir);
			foreach ($objects as $object) {
				if ($object != "." && $object != "..") {
					if (filetype($dir . "/" . $object) == "dir")
						rrmdir($dir . "/" . $object); else
						unlink($dir . "/" . $object);
				}
			}
			reset($objects);
			rmdir($dir);
		}
	}
}

class LoadModulesTask_Loader {
	
	/**
	 * @var SilverStripeBuildTask
	 */
	protected $callingTask;
	
	/**
	 * @var string
	 */
	protected $url;
	
	/**
	 * @var string
	 */
	protected $name;
	
	/**
	 * @var string
	 */
	protected $branch;
	
	/**
	 * @var boolean
	 */
	protected $nonInteractive = false;
	
	/**
	 * @param SilverStripeBuildTask Phing crashes when extending the loader from SilverStripeBuildTask
	 * @param String
	 * @param String
	 * @param String
	 */
	function __construct($callingTask, $name, $url, $branch = null) {
		$this->callingTask = $callingTask;
		$this->name = $name;
		$this->url = $url;
		$this->branch = $branch;
	}
	
	/**
	 * Check out a new working copy.
	 * Call {@link storeLocally()} afterwards to remove versioning information
	 * from the working copy.
	 */
	function checkout($storeLocally = false) {
		// noop
	}
	
	/**
	 * Update an existing working copy
	 */
	function update($overwrite = true) {
		// noop
	}
	
	/**
	 * @return array
	 */
	function getModifiedFiles() {
		// noop
	}
	
}

class LoadModulesTask_GitLoader extends LoadModulesTask_Loader {
	
	function checkout($storeLocally = false) {
		$branch = $this->branch;
		$currentDir = getcwd();
		$this->callingTask->exec("git clone $this->url $this->name");
		
		if ($branch != 'master') {
			// check if we're also hooking onto a revision
			$commitId = null;
			if (strpos($this->branch, LoadModulesTask::MODULE_SEPARATOR) > 0) {
				$commitId = substr($branch, strpos($branch, LoadModulesTask::MODULE_SEPARATOR) + 1);
				$branch = substr($branch, 0, strpos($branch, LoadModulesTask::MODULE_SEPARATOR));
			}
			// need to make sure we've pulled from the correct branch also
			if ($branch != 'master') {
				$this->callingTask->exec("cd $this->name && git checkout -f -b $branch --track origin/$branch && cd \"$currentDir\"");
			}

			if ($commitId) {
				$this->callingTask->exec("cd $this->name && git checkout $commitId && cd \"$currentDir\"");
			}
		}
		
		if($storeLocally) rrmdir("$this->name/.git");
	}
	
	function getModifiedFiles() {
		$currentDir = getcwd();
		$statCmd = "git diff --name-status";
		return trim($this->callingTask->exec("cd $this->name && $statCmd && cd \"$currentDir\"", true));
	}
	
	/**
	 *
	 * @param boolean $overwrite 
	 */
	public function update($overwrite = true) {
		$branch = $this->branch;
		$currentDir = getcwd();

		$commitId = null;
		// Extract the branch and the commit to use for the update
		if(strpos($branch, LoadModulesTask::MODULE_SEPARATOR) > 0) {
			$commitId = substr($branch, strpos($branch, LoadModulesTask::MODULE_SEPARATOR) + 1);
			$branch = substr($branch, 0, strpos($branch, LoadModulesTask::MODULE_SEPARATOR));
		}

		// Finds the current checked out branch
		$cliBranches = trim($this->callingTask->exec("cd $this->name && git branch && cd \"$currentDir\"", true));
		$currentBranch = 'master';
		foreach(explode(PHP_EOL, $cliBranches) as $cliBranch) {
			if(strstr($cliBranch, '* ') !== false) {
				$currentBranch = str_replace('* ', '', $cliBranch);
				break;
			}
		}
		
		$overwriteOpt = $overwrite ? '-f' : '';

		// We are already on the target branch, don't checkout it again
		if($currentBranch == $branch) {
			$this->callingTask->exec("cd $this->name && git pull origin $branch && cd \"$currentDir\"");
		} else {
			$this->callingTask->exec("cd $this->name && git checkout $overwriteOpt $branch && git pull origin $branch && cd \"$currentDir\"");
		}
		
		if ($commitId) {
			$this->callingTask->exec("cd $this->name && git checkout $commitId && cd \"$currentDir\"");
		}
	}
	
}

class LoadModulesTask_SubversionLoader extends LoadModulesTask_Loader {
	
	function checkout($storeLocally = false) {
		$revision = '';
		if ($this->branch != 'master') {
			$revision = " --revision $this->branch ";
		}
		
		$cmd = ($storeLocally) ? 'export' : 'co';
		$this->callingTask->exec("svn $cmd $revision $this->url $this->name");
	}
	
	function update($overwrite = true) {
		$branch = $this->branch;
		$currentDir = getcwd();
		
		$revision = '';
		if ($branch != 'master') {
			$revision = " --revision $branch ";
		}

		echo $this->callingTask->exec("svn up $revision $this->name");
	}
	
	function getModifiedFiles() {
		$currentDir = getcwd();
		$statCmd = "svn stat";
		return trim($this->callingTask->exec("cd $this->module && $statCmd && cd \"$currentDir\"", true));
	}
	
}

class LoadModulesTask_PistonLoader extends LoadModulesTask_Loader {
	
	function __construct($callingTask, $name, $url, $branch = null) {
		parent::__construct($callingTask, $name, $url, $branch);
		
		if(strpos($branch, ':') !== FALSE) {
			throw new BuildException(sprintf('Git tags not supported by piston'));
		}
	}
	
	function update($overwrite = true) {
		$currentDir = getcwd();		
		$revision = ($this->branch != 'master') ? " --commit $this->branch " : '';
		$overwriteOpts = ($overwrite) ? '--force' : '';
		echo $this->callingTask->exec("piston update $overwriteOpts $revision $this->name");
		
		$this->callingTask->log(sprintf('Updated "$this->name" via piston, please don\'t forget to commit any changes'));
	}
	
	function checkout($storeLocally = false) {
		$git = strrpos($this->url, '.git') == (strlen($this->url) - 4);
		$revision = ($this->branch != 'master') ? " --commit $this->branch " : '';
		$type = ($git) ? 'git' : 'subversion';
		$this->callingTask->exec("piston import --repository-type $type $revision $this->url $this->name");
		
		$this->callingTask->log(sprintf('Created "$this->name" via piston, please don\'t forget to commit any changes'));
	}
	
	/**
	 * @todo Check base working copy if not dealing with flattened directory.
	 */
	function getModifiedFiles() {
		return '';
	}
}