~monodevelop-bzr/monodevelop-bzr/trunk

// Copyright (C) 2007 by Jelmer Vernooij <jelmer@samba.org>
//		
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//	
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//   
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

using System;
using System.IO;
using System.Collections.Generic;
using System.Collections;
using System.Threading;

using MonoDevelop.Core;
using MonoDevelop.VersionControl;

namespace MonoDevelop.VersionControl.Bazaar
{
	public class BazaarRepository : UrlBasedRepository
	{
		private Dictionary<string,string> tempfiles;
		private Dictionary<FilePath,VersionInfo> statusCache;
		
		public BazaarRepository ()
		{
			Init ();
		}
		
		public BazaarRepository (BazaarVersionControl vcs, string url) : base (vcs)
		{
			Init ();
			Url = url;
		}

		private void Init ()
		{
			Method = BazaarVersionControl.protocols[0];
			tempfiles = new Dictionary<string,string> ();
			statusCache = new Dictionary<FilePath, VersionInfo> ();
		}// Init

		/// <summary>
		/// Remove temp files
		/// </summary>
		~BazaarRepository ()
		{
			foreach (string tmpfile in tempfiles.Values) {
				if (File.Exists (tmpfile)){ File.Delete (tmpfile); }
			}
		}// finalizer
		
		public override bool HasChildRepositories { 
			get { return true; /* TODO */ }
		}
		
		public BazaarVersionControl Bazaar {
			get { return (BazaarVersionControl) VersionControlSystem; }
		}

		public override IEnumerable<Repository> ChildRepositories {
			get {
				List<Repository> repos = new List<Repository> ();

				// System.Console.WriteLine ("Getting children for {0}", Url);
				
				foreach (string directory in Bazaar.List (Url, true, ListKind.Directory)) {
					int lastSep = directory.LastIndexOf ("/");
					if (0 < lastSep && Url.EndsWith (directory.Substring (0, lastSep))) {
						repos.Add (new BazaarRepository (Bazaar, directory));
					}// if the directory is a direct child of Url
				}// for each directory

				// foreach (Repository repo in repos){ System.Console.WriteLine ("Child repo {0}", ((UrlBasedRepository)repo).Url); }

				return repos;
			}// get
		}// ChildRepositories

		/// <value>
		/// The path where .bzr is located
		/// </value>
		public string LocalBasePath {
			get {
				return localBasePath;
			}// get
			set {
				localBasePath = value;
			}// set
		}// LocalBasePath
		private string localBasePath;

		/// <remarks>
		/// Since bzr doesn't store a text-base like svn,
		/// we're catting the baseline text to a temp file
		/// </remarks>
		public override string GetPathToBaseText (FilePath localFilePath)
		{
			string localFile = localFilePath.FullPath;

			try {
				string   tmpfile = tempfiles.ContainsKey (localFile)? tempfiles[localFile]: Path.GetTempFileName ();
				File.WriteAllText (tmpfile, Bazaar.GetTextAtRevision (localFile, new BazaarRevision (this, BazaarRevision.HEAD)));
				tempfiles[localFile] = tmpfile;
				return tmpfile;
			} catch { }

			return localFile;
		}

		public override Revision[] GetHistory (FilePath localFilePath, Revision since)
		{
			if (null == LocalBasePath) {
				// System.Console.WriteLine ("Getting local base path for {0}", localFile);
				LocalBasePath = GetLocalBasePath (localFilePath.FullPath);
				// System.Console.WriteLine ("Got base path {0}", LocalBasePath);
			}
			return Bazaar.GetHistory (this, localFilePath.FullPath, since);
		}
		
		public override VersionInfo GetVersionInfo (FilePath localPath, bool getRemoteStatus)
		{
			return statusCache[localPath] = Bazaar.GetVersionInfo (this, localPath.FullPath, getRemoteStatus);
		}
		
		/// <summary>
		/// Prefer cached version info for non-essential operations (menu display)
		/// </summary>
		private VersionInfo GetCachedVersionInfo (FilePath localPath, bool getRemoteStatus)
		{
			VersionInfo status = null;
			if (statusCache.ContainsKey (localPath)) {
				status = statusCache[localPath];
			} else {
				status = GetVersionInfo (localPath, getRemoteStatus);
			}
			return status;
		}

		public override VersionInfo[] GetDirectoryVersionInfo (FilePath localDirectory, bool getRemoteStatus, bool recursive)
		{
			VersionInfo[] versions = Bazaar.GetDirectoryVersionInfo (this, localDirectory.FullPath, getRemoteStatus, recursive);
			if (null != versions) {
				foreach (VersionInfo version in versions) {
					statusCache[version.LocalPath] = version;
				}
			}
			return versions;
		}
		
		// Deprecated
		public override Repository Publish (string serverPath, FilePath localPath, FilePath[] files, string message, IProgressMonitor monitor)
		{
			serverPath = string.Format ("{0}{1}{2}", Url, Url.EndsWith ("/")? string.Empty: "/", serverPath);
			// System.Console.WriteLine ("Got publish {0} {1}", serverPath, localPath);
			Bazaar.StoreCredentials (serverPath);
			Bazaar.Push (serverPath, localPath.FullPath, false, false, false, monitor);
			return new BazaarRepository (Bazaar, serverPath);
		}
		
		public virtual void Push (string pushLocation, FilePath localPath, bool remember, bool overwrite, bool omitHistory, IProgressMonitor monitor) {
			Bazaar.StoreCredentials (pushLocation);
			Bazaar.Push (pushLocation, localPath.FullPath, remember, overwrite, omitHistory, monitor);
		}// Push

		public virtual void Pull (string pullLocation, FilePath localPath, bool remember, bool overwrite, IProgressMonitor monitor) {
			Bazaar.StoreCredentials (pullLocation);
			Bazaar.Pull (pullLocation, localPath.FullPath, remember, overwrite, monitor);
		}// Pull

		public virtual void Merge (string mergeLocation, FilePath localPath, bool remember, bool overwrite, IProgressMonitor monitor) {
			Bazaar.StoreCredentials (mergeLocation);
			Bazaar.Merge (mergeLocation, localPath.FullPath, remember, overwrite, new BazaarRevision (this, BazaarRevision.NONE), new BazaarRevision (this, BazaarRevision.NONE), monitor);
		}// Merge
		
		public override void Update (FilePath[] localPaths, bool recurse, IProgressMonitor monitor)
		{
			foreach (FilePath localPath in localPaths)
				Bazaar.Update (localPath.FullPath, recurse, monitor);
		}

		public override void Commit (ChangeSet changeSet, IProgressMonitor monitor)
		{
			Bazaar.Commit (changeSet, monitor);
		}

		public override void Checkout (FilePath targetLocalPath, Revision rev, bool recurse, IProgressMonitor monitor)
		{
			Bazaar.StoreCredentials (Url);
			BazaarRevision brev = (null == rev)? new BazaarRevision (this, BazaarRevision.HEAD): (BazaarRevision)rev;
			Bazaar.Checkout (Url, targetLocalPath.FullPath, brev, recurse, monitor);
		}

		public override void Revert (FilePath[] localPaths, bool recurse, IProgressMonitor monitor)
		{
			foreach (FilePath localPath in localPaths)
				Bazaar.Revert (localPath.FullPath, recurse, monitor, new BazaarRevision (this, BazaarRevision.HEAD));
		}
		
		public override void Add (FilePath[] localPaths, bool recurse, IProgressMonitor monitor)
		{
			foreach (FilePath localPath in localPaths)
				Bazaar.Add (localPath.FullPath, recurse, monitor);
		}

		public override string GetTextAtRevision (FilePath repositoryPath, Revision revision)
		{
			// System.Console.WriteLine ("Got GetTextAtRevision for {0}", repositoryPath);
			BazaarRevision brev = (null == revision)? new BazaarRevision (this, BazaarRevision.HEAD): (BazaarRevision)revision;
			return Bazaar.GetTextAtRevision (repositoryPath.FullPath, brev);
		}

		public override void RevertToRevision (FilePath localPath, Revision revision, IProgressMonitor monitor)
		{
			BazaarRevision brev = (null == revision)? new BazaarRevision (this, BazaarRevision.HEAD): (BazaarRevision)revision;
			Bazaar.Revert (localPath.FullPath, true, monitor, brev);
		}

		public override void RevertRevision (FilePath localPath, Revision revision, IProgressMonitor monitor)
		{
			BazaarRevision brev = (BazaarRevision)revision;
			string localPathStr = localPath.FullPath;
			Bazaar.Merge (localPathStr, localPathStr, false, false, brev, (BazaarRevision)(brev.GetPrevious ()), monitor);
		}

		public override bool IsVersioned (FilePath localPath)
		{
			if (string.IsNullOrEmpty (GetLocalBasePath (localPath.FullPath))) {
				return false;
			} 
			
			VersionInfo info = GetCachedVersionInfo (localPath, false);
			return (null != info && info.IsVersioned);
		}

		public override bool IsModified (FilePath localFile)
		{
			if (string.IsNullOrEmpty (GetLocalBasePath (localFile.FullPath))) {
				return false;
			}
			
			VersionInfo info = GetCachedVersionInfo (localFile, false);
			return (null != info && info.IsVersioned && info.HasLocalChanges);
		}

		public virtual bool IsConflicted (FilePath localFile)
		{
			if (string.IsNullOrEmpty (GetLocalBasePath (localFile.FullPath))) {
				return false;
			}
			
			VersionInfo info = GetCachedVersionInfo (localFile, false);
			return (null != info && info.IsVersioned && (0 != (info.Status & VersionStatus.Conflicted)));
		}

		public override bool CanRevert (FilePath localPath)
		{
			return IsModified (localPath) || IsConflicted (localPath);
		}

		public override bool CanCommit (FilePath localPath)
		{
			bool rv = IsModified (localPath);
			return rv;
		}

		public override bool CanAdd (FilePath localPath)
		{
			return !IsVersioned (localPath);
		}

		public virtual bool CanResolve (FilePath localPath)
		{
			return IsConflicted (localPath);
		}

		public virtual bool CanPull (FilePath localPath)
		{
			return Directory.Exists (localPath.FullPath) && CanUpdate (localPath);
		}// CanPull

		public virtual bool CanMerge (FilePath localPath)
		{
			return Directory.Exists (localPath.FullPath) && CanUpdate (localPath);
		}// CanMerge
		
		public virtual bool CanBind (FilePath localPath)
		{
			return Directory.Exists (localPath.FullPath) && !IsBound (localPath);
		}// CanBind
		
		public virtual bool CanUnbind (FilePath localPath)
		{
			return Directory.Exists (localPath.FullPath) && IsBound (localPath);
		}// CanUnbind
		
		public virtual bool CanUncommit (FilePath localPath)
		{
			return Directory.Exists (localPath.FullPath) && IsVersioned (localPath);
		}// CanUncommit
		
		public override bool CanGetAnnotations (MonoDevelop.Core.FilePath localPath)
		{
		    return IsVersioned (localPath);
		}// CanGetAnnotations

		/// <summary>
		/// Finds the bzr branch root for a path
		/// </summary>
		/// <param name="localPath">
		/// A <see cref="System.String"/>: A path somewhere in a bzr branch
		/// </param>
		/// <returns>
		/// A <see cref="System.String"/>: The path to the branch root,
		/// or string.Empty
		/// </returns>
		public static string GetLocalBasePath (string localPath) {
			if (null == localPath){ return string.Empty; }
			if (Directory.Exists (Path.Combine (localPath, ".bzr"))){ return localPath; }

			return GetLocalBasePath (Path.GetDirectoryName (localPath));
		}// GetLocalBasePath

		public override DiffInfo[] PathDiff (FilePath baseLocalPath, FilePath[] localPaths, bool remoteDiff)
		{
			string[] localFiles = new string[null == localPaths? 0: localPaths.Length];
			for(int i=0; i<localFiles.Length; ++i){ 
				localFiles[i] = localPaths[i].ToRelative (baseLocalPath.FullPath);
			}
			
			return Bazaar.Diff (baseLocalPath.FullPath, localFiles);
		}// PathDiff

		public override void DeleteFiles (FilePath[] localPaths, bool force, IProgressMonitor monitor)
		{
			foreach (FilePath localPath in localPaths)
				Bazaar.Remove (localPath.FullPath, force, monitor);
		}// DeleteFiles

		public override void DeleteDirectories (FilePath[] localPaths, bool force, IProgressMonitor monitor)
		{
			foreach (FilePath localPath in localPaths)
				Bazaar.Remove (localPath.FullPath, force, monitor);
		}// DeleteDirectories

		public virtual void Resolve (FilePath[] localPaths, bool recurse, IProgressMonitor monitor)
		{
			foreach (FilePath localPath in localPaths)
				Bazaar.Resolve (localPath.FullPath, recurse, monitor);
		}// Resolve

		public virtual Dictionary<string, BranchType> GetKnownBranches (FilePath localPath)
		{
			return Bazaar.GetKnownBranches (localPath.FullPath);
		}// GetKnownBranches
		
		public virtual void Ignore (FilePath localPath)
		{
			Bazaar.Ignore (localPath.FullPath);
		}// Ignore
		
		public virtual bool IsBound (FilePath localPath)
		{
			return Bazaar.IsBound (localPath.FullPath);
		}// IsBound
		
		public virtual string GetBoundBranch (FilePath localPath)
		{
			return Bazaar.GetBoundBranch (localPath.FullPath);
		}// GetBoundBranch
		
		public virtual void Bind (string branchUrl, FilePath localPath, IProgressMonitor monitor)
		{
			Bazaar.Bind (branchUrl, localPath.FullPath, monitor);
		}// Bind
		
		public virtual void Unbind (FilePath localPath, IProgressMonitor monitor)
		{
			Bazaar.Unbind (localPath.FullPath, monitor);
		}// Unbind
		
		public virtual void Uncommit (FilePath localPath, IProgressMonitor monitor)
		{
			Bazaar.Uncommit (localPath.FullPath, monitor);
		}// Uncommit
		
		public override string[] GetAnnotations (FilePath localPath)
		{
			return Bazaar.GetAnnotations (localPath.FullPath);
		}// GetAnnotations
		
		/// <summary>
		/// Export a (portion of a) local tree.
		/// </summary>
		/// <param name="localPath">
		/// A <see cref="FilePath"/>: The path to be exported.
		/// </param>
		/// <param name="exportPath">
		/// A <see cref="FilePath"/>: The output path.
		/// </param>
		/// <param name="monitor">
		/// A <see cref="IProgressMonitor"/>
		/// </param>
		public virtual void Export (FilePath localPath, FilePath exportLocation, IProgressMonitor monitor)
		{
			Bazaar.Export (localPath.FullPath, exportLocation.FullPath, monitor);
		}// Export
		
		public virtual bool CanRebase ()
		{
			return Bazaar.CanRebase ();
		}// CanRebase
	}// BazaarRepository
}