public static async Task<PackageManager> Create(Repository repo, IAbsoluteDirectoryPath workDir,
     bool createWhenNotExisting = false,
     string remote = null) {
     var pm = new PackageManager(repo, workDir, createWhenNotExisting, remote);
     await repo.RefreshRemotes().ConfigureAwait(false);
     return pm;
 }

 static IEnumerable<IAbsoluteDirectoryPath> ExistingMods(IAbsoluteDirectoryPath[] paths, params string[] mods) {
     return paths.Any()
         ? mods.Select(
             x => paths.Select(path => path.GetChildDirectoryWithName(x)).FirstOrDefault(p => p.Exists))
             .Where(x => x != null)
         : Enumerable.Empty<IAbsoluteDirectoryPath>();
 }

 private static IAbsoluteFilePath GetNetEntryFilePath(IAbsoluteDirectoryPath netEntryPath, string asName) {
     var en = netEntryPath ?? AppContext.BaseDirectory.ToAbsoluteDirectoryPath();
     var dll = en.GetChildFileWithName(asName + ".dll");
     var netEntryFilePath = dll.Exists ? dll : en.GetChildFileWithName(asName + ".exe");
         //_entryAssembly.Location.ToAbsoluteFilePath();
     return netEntryFilePath;
 }

        public Repository OpenRepositoryWithRetry(IAbsoluteDirectoryPath path, bool createWhenNotExisting = false,
            Action failAction = null) {
            if (createWhenNotExisting && !path.Exists)
                return new Repository(path, createWhenNotExisting);

            using (var autoResetEvent = new AutoResetEvent(false))
            using (var fileSystemWatcher =
                new FileSystemWatcher(path.ToString(), "*.lock") {
                    EnableRaisingEvents = true
                }) {
                var lockFile = path.GetChildFileWithName(Repository.LockFile);
                var fp = Path.GetFullPath(lockFile.ToString());
                fileSystemWatcher.Deleted +=
                    (o, e) => {
                        if (Path.GetFullPath(e.FullPath) == fp)
                            autoResetEvent.Set();
                    };

                while (true) {
                    using (var timer = UnlockTimer(lockFile, autoResetEvent)) {
                        try {
                            return new Repository(path, createWhenNotExisting);
                        } catch (RepositoryLockException) {
                            if (failAction != null)
                                failAction();
                            timer.Start();
                            autoResetEvent.WaitOne();
                            lock (timer)
                                timer.Stop();
                            autoResetEvent.Reset();
                        }
                    }
                }
            }
        }

        public ContentPaths(IAbsoluteDirectoryPath path, IAbsoluteDirectoryPath repositoryPath) {
            Contract.Requires<ArgumentNullException>(path != null);
            Contract.Requires<ArgumentNullException>(repositoryPath != null);

            Path = path;
            RepositoryPath = repositoryPath;
        }

        public Package Import(Repository repo, IAbsoluteDirectoryPath workDir, IAbsoluteFilePath packageFilePath) {
            var metaData = Package.Load(packageFilePath);
            var package = new Package(workDir, metaData, repo);
            package.Commit(metaData.GetVersionInfo());

            return package;
        }

        const int WM_USER = 0x0400; //http://msdn.microsoft.com/en-us/library/windows/desktop/ms644931(v=vs.85).aspx

        public async Task UpgradeOrInstall(IAbsoluteDirectoryPath destination, Settings settings,
            params IAbsoluteFilePath[] files) {
            var theShell = GetTheShell(destination, files);
            if (theShell.Exists)
                await Uninstall(destination, settings, files).ConfigureAwait(false);
            await Install(destination, settings, files).ConfigureAwait(false);
        }

 public static async Task<BundleManager> Create(Repository repo, IAbsoluteDirectoryPath workDir,
     bool createWhenNotExisting = false,
     string remote = null) {
     var packageManager =
         await PackageManager.Create(repo, workDir, createWhenNotExisting, remote).ConfigureAwait(false);
     return new BundleManager(packageManager);
 }

 public IEnumerable<string> Enumerate(IAbsoluteDirectoryPath path) {
     Contract.Requires<ArgumentNullException>(path != null);
     return Tools.FileUtil.GetFiles(path, "*.bisign")
         .Select(GetSignatureFromFileName).Where(x => !string.IsNullOrWhiteSpace(x))
         .Select(x => x.ToLower())
         .Distinct();
 }

        public string ProcessUserconfig(IAbsoluteDirectoryPath modPath, IAbsoluteDirectoryPath gamePath,
            string exisitingChecksum, bool force = true) {
            Contract.Requires<ArgumentNullException>(modPath != null);
            Contract.Requires<ArgumentNullException>(gamePath != null);

            var backupAndClean = force;

            var path = GetUserconfigPath(modPath);
            if (!File.Exists(path) && !Directory.Exists(path))
                return null;

            this.Logger().Info("Found userconfig to process at " + path);

            var checksum = GetConfigChecksum(path);

            if (checksum != exisitingChecksum)
                backupAndClean = true;

            var uconfig = gamePath.GetChildDirectoryWithName("userconfig");
            var uconfigPath = uconfig.GetChildDirectoryWithName(Mod.GetRepoName(modPath.DirectoryName));

            if (backupAndClean)
                new UserconfigBackupAndClean().ProcessBackupAndCleanInstall(path, gamePath, uconfig, uconfigPath);
            else
                new UserconfigUpdater().ProcessMissingFiles(path, gamePath, uconfig, uconfigPath);

            return checksum;
        }

 public ContentEngineContent(Guid networkId, Guid id, bool isInstalled, IAbsoluteDirectoryPath path, Guid gameId) {
     NetworkId = networkId;
     Id = id;
     IsInstalled = isInstalled;
     PathInternal = path;
     GameId = gameId;
 }

			public VariablePathResolvingStatus TryResolve(IEnumerable<KeyValuePair<string, string>> variables,
				out IAbsoluteDirectoryPath resolvedPath, out IReadOnlyList<string> unresolvedVariables)
			{
				Argument.IsNotNull(nameof(variables), variables);

				string path;

				if (!TryResolve(variables, out path, out unresolvedVariables))
				{
					resolvedPath = null;

					return VariablePathResolvingStatus.UnresolvedVariable;
				}

				if (!path.IsValidAbsoluteDirectoryPath())
				{
					resolvedPath = null;

					return VariablePathResolvingStatus.CannotConvertToAbsolutePath;
				}

				resolvedPath = path.ToAbsoluteDirectoryPath();

				return VariablePathResolvingStatus.Success;
			}

        async Task<bool> TryCheckUac(IAbsoluteDirectoryPath mp, IAbsoluteFilePath path) {
            Exception ex;
            try {
                mp.MakeSurePathExists();
                if (path.Exists)
                    File.Delete(path.ToString());
                using (File.CreateText(path.ToString())) {}
                File.Delete(path.ToString());
                return false;
            } catch (UnauthorizedAccessException e) {
                ex = e;
            } catch (Exception e) {
                this.Logger().FormattedWarnException(e);
                return false;
            }

            var report = await UserErrorHandler.HandleUserError(new UserErrorModel("Restart the application elevated?",
                             $"The application failed to write to the path, probably indicating permission issues\nWould you like to restart the application Elevated?\n\n {mp}",
                             RecoveryCommands.YesNoCommands, null, ex)) == RecoveryOptionResultModel.RetryOperation;

            if (!report)
                return false;
            RestartWithUacInclEnvironmentCommandLine();
            return true;
        }

        public PackageManager(Repository repo, IAbsoluteDirectoryPath workDir, bool createWhenNotExisting = false,
            string remote = null) {
            Contract.Requires<ArgumentNullException>(repo != null);
            Contract.Requires<ArgumentNullException>(workDir != null);
            WorkDir = workDir;
            Repo = repo;
            StatusRepo = new StatusRepo();
            Settings = new PackageManagerSettings();

            Repository.Factory.HandlePathRequirements(WorkDir, Repo);

            if (!WorkDir.Exists) {
                if (!createWhenNotExisting)
                    throw new Exception("Workdir doesnt exist");
                WorkDir.MakeSurePathExists();
            }

            if (!string.IsNullOrWhiteSpace(remote)) {
                var config =
                    Repository.DeserializeJson<RepositoryConfigDto>(
                        FetchString(Tools.Transfer.JoinUri(new Uri(remote), "config.json")));
                if (config.Uuid == Guid.Empty)
                    throw new Exception("Invalid remote, does not contain an UUID");
                Repo.AddRemote(config.Uuid, remote);
                Repo.Save();
            }

            Repository.Log("Opening repository at: {0}. Working directory at: {1}", Repo.RootPath, WorkDir);
            _remote = remote;
        }

 void HandleUserconfig(IAbsoluteDirectoryPath dir) {
     var userConfigPath = dir.GetChildDirectoryWithName("userconfig");
     if (!userConfigPath.Exists)
         return;
     System.Console.WriteLine("Found userconfig in {0}, processing", dir);
     HandleUserConfigPath(dir, userConfigPath);
 }

        async Task CheckoutBundles(IAbsoluteDirectoryPath path, Repository repo, string[] packages) {
            var pm = await BundleManager.Create(repo, path).ConfigureAwait(false);
            ConfirmOperationMode(pm.Repo, 2);

            var scope = BundleScope.All;
            if (!string.IsNullOrWhiteSpace(Scope)) {
                if (!Enum.TryParse(Scope, true, out scope))
                    throw new ConsoleHelpAsException("Invalid scope: " + Scope);
            }

            System.Console.WriteLine("Querying Bundles: {0}. Scope: {1}, IncludeOptional: {2}. Additional: {3}",
                String.Join(", ", packages), scope, IncludeOptional, Additional);

            Package[] packs;
            using (new ConsoleProgress(pm.PackageManager.StatusRepo)) {
                packs = await pm.Checkout(new Bundle("selected") {
                    Dependencies =
                        packages.Select(x => new Dependency(x))
                            .ToDictionary(x => x.Name, x => x.GetConstraints()),
                    Required =
                        Additional == null
                            ? new Dictionary<string, string>()
                            : Additional.Split(',')
                                .Select(x => new Dependency(x))
                                .ToDictionary(x => x.Name, x => x.GetConstraints())
                }, IncludeOptional, scope, UseVersionedPackageFolders).ConfigureAwait(false);
            }

            System.Console.WriteLine("\nSuccesfully checked out {0} packages",
                string.Join(", ", packs.Count()));
        }

        bool IsRightVersion(IAbsoluteDirectoryPath rsyncDir, KeyValuePair<string, SixRepoModDto> mod) {
            var versionFile = rsyncDir.GetChildFileWithName(Repository.VersionFileName);
            if (!versionFile.Exists)
                return false;

            var repoInfo = TryReadRepoFile(versionFile);
            return (repoInfo != null) && (repoInfo.Guid == mod.Value.Guid) && (repoInfo.Version == mod.Value.Version);
        }

 void ProcessDirectory(ProcessDirectoryOrFileParams spec, IAbsoluteDirectoryPath directory) {
     if (spec.OnlyWhenMissing) {
         ProcessDirectoryOnlyMissing(spec, directory);
         return;
     }
     var biKeyPair = GetKey(spec, directory);
     _biSigner.SignFolder(directory, biKeyPair.PrivateFile, spec.RepackIfFailed);
 }

        public static string GetRelativeDirectory(this IAbsoluteDirectoryPath path,
            IAbsoluteDirectoryPath possibleRoot) {
            if (path.Equals(possibleRoot) || !path.CanGetRelativePathFrom(possibleRoot) ||
                !path.IsRootedIn(possibleRoot))
                return path.ToString();

            return path.GetRelativePathFrom(possibleRoot).Join();
        }

 public HandleKeyParams(IAbsoluteDirectoryPath keyPath, string prefix, bool copyKey,
     IAbsoluteDirectoryPath directory, IAbsoluteFilePath key) {
     KeyPath = keyPath;
     Prefix = prefix;
     CopyKey = copyKey;
     Directory = directory;
     Key = key;
 }