common.cake

#load "poco.cake"

// Podfile basic structure
var PODFILE_BEGIN = new [] {
	"platform :ios, '{0}'",
	"install! 'cocoapods', :integrate_targets => false",
	"use_frameworks!",
};
var PODFILE_TARGET = new [] {
	"target 'XamarinGoogle' do",
};
var PODFILE_END = new [] {
	"end",
};

class XCodeBuildSettings
{
	public bool Archive { get; set; }
	public string ArchivePath { get; set; }
	public string Arch { get; set; }
	public Dictionary<string, string> BuildSettings { get; set; }
	public bool Clean { get; set; }
	public string Configuration { get; set; }
	public string Project { get; set; }
	public string Scheme { get; set; }
	public string Sdk { get; set; }
	public string Target { get; set; }
	public bool Verbose { get; set; }
}

string QuoteArgument (string value)
	=> "\"" + value.Replace ("\"", "\\\"") + "\"";

void ThrowIfProcessFailed (string tool, int exitCode)
{
	if (exitCode != 0)
		throw new Exception ($"{tool} failed with exit code {exitCode}.");
}

void CocoaPodRepoUpdate ()
{
	var args = new ProcessArgumentBuilder ();
	args.Append ("repo");
	args.Append ("update");

	ThrowIfProcessFailed ("pod repo update", StartProcess ("pod", new ProcessSettings { Arguments = args }));
}

void CocoaPodInstall (DirectoryPath projectDirectory)
{
	var args = new ProcessArgumentBuilder ();
	args.Append ("install");
	args.Append ("--project-directory=" + QuoteArgument (MakeAbsolute (projectDirectory).FullPath));

	ThrowIfProcessFailed ("pod install", StartProcess ("pod", new ProcessSettings { Arguments = args }));
}

void XCodeBuild (XCodeBuildSettings settings)
{
	var args = new ProcessArgumentBuilder ();

	if (settings.Verbose)
		args.Append ("-verbose");
	if (!string.IsNullOrWhiteSpace (settings.Project))
		args.Append ($"-project {QuoteArgument (settings.Project)}");
	if (!string.IsNullOrWhiteSpace (settings.Target))
		args.Append ($"-target {QuoteArgument (settings.Target)}");
	if (!string.IsNullOrWhiteSpace (settings.Scheme))
		args.Append ($"-scheme {QuoteArgument (settings.Scheme)}");
	if (!string.IsNullOrWhiteSpace (settings.Configuration))
		args.Append ($"-configuration {QuoteArgument (settings.Configuration)}");
	if (!string.IsNullOrWhiteSpace (settings.Arch))
		args.Append ($"-arch {QuoteArgument (settings.Arch)}");
	if (!string.IsNullOrWhiteSpace (settings.Sdk))
		args.Append ($"-sdk {QuoteArgument (settings.Sdk)}");
	if (!string.IsNullOrWhiteSpace (settings.ArchivePath))
		args.Append ($"-archivePath {QuoteArgument (MakeAbsolute ((DirectoryPath)settings.ArchivePath).FullPath)}");

	args.Append (settings.Archive ? "archive" : "build");

	if (settings.Clean)
		args.Append ("clean");

	if (settings.BuildSettings != null)
		foreach (var buildSetting in settings.BuildSettings)
			args.Append ($"{buildSetting.Key}={buildSetting.Value}");

	ThrowIfProcessFailed ("xcodebuild", StartProcess ("xcodebuild", new ProcessSettings { Arguments = args }));
}

void RunLipoCreate (DirectoryPath workingDirectory, string output, params FilePath[] inputs)
	=> RunLipoCreate (workingDirectory, (FilePath)output, inputs);

void RunLipoCreate (DirectoryPath workingDirectory, FilePath output, params FilePath[] inputs)
{
	if (!IsRunningOnUnix ()) {
		Warning("{0} is not available on the current platform.", "lipo");
		return;
	}

	var args = new ProcessArgumentBuilder ();
	args.Append ("-create");
	args.Append ("-output");
	args.AppendQuoted (output.ToString ());

	foreach (var input in inputs)
		args.AppendQuoted (input.ToString ());

	ThrowIfProcessFailed ("lipo", StartProcess ("lipo", new ProcessSettings {
		Arguments = args,
		WorkingDirectory = workingDirectory
	}));
}

void FileWriteLines (FilePath path, string[] lines)
{
	System.IO.File.WriteAllLines (MakeAbsolute (path).FullPath, lines);
}

void ReplaceTextInFiles (string glob, string oldValue, string newValue)
{
	foreach (var file in GetFiles (glob)) {
		var path = MakeAbsolute (file).FullPath;
		var text = System.IO.File.ReadAllText (path);
		var updatedText = text.Replace (oldValue, newValue);

		if (!string.Equals (text, updatedText, StringComparison.Ordinal))
			System.IO.File.WriteAllText (path, updatedText);
	}
}

void CopyDirectoryWithSymlinks (DirectoryPath source, DirectoryPath destination)
{
	if (DirectoryExists (destination)) {
		var deleteDirectorySettings = new DeleteDirectorySettings {
			Recursive = true,
			Force = true
		};

		DeleteDirectory (destination, deleteDirectorySettings);
	}

	if (!IsRunningOnUnix ()) {
		CopyDirectory (source, destination);
		return;
	}

	var destinationParentPath = System.IO.Path.GetDirectoryName (destination.FullPath);

	if (!string.IsNullOrWhiteSpace (destinationParentPath))
		EnsureDirectoryExists (destinationParentPath);

	var args = new ProcessArgumentBuilder ();
	args.Append ("-a");
	args.AppendQuoted (source.FullPath);
	args.AppendQuoted (destination.FullPath);

	var exitCode = StartProcess ("cp", new ProcessSettings { Arguments = args });

	if (exitCode != 0)
		throw new Exception ($"Failed to copy directory '{source}' to '{destination}' preserving symlinks.");
}

void AddArtifactDependencies (List<Artifact> list, Artifact [] dependencies)
{
	if (dependencies == null)
		return;
	
	list.AddRange (dependencies);

	foreach (var dependency in dependencies)
		AddArtifactDependencies (list, dependency.Dependencies);
}

void UpdateVersionInCsproj (Artifact artifact) 
{
	var componentGroup = artifact.ComponentGroup.ToString ();
	var csprojPath = $"./source/{componentGroup}/{artifact.CsprojName}/{artifact.CsprojName}.csproj";
	XmlPoke(csprojPath, "/Project/PropertyGroup/FileVersion", artifact.NugetVersion);
	var currentPackageVersion = XmlPeek(csprojPath, "/Project/PropertyGroup/PackageVersion");
	if (!currentPackageVersion.Contains("-"))
		XmlPoke(csprojPath, "/Project/PropertyGroup/PackageVersion", artifact.NugetVersion);
}

void CreateAndInstallPodfile (Artifact artifact)
{
	if (artifact.PodSpecs?.Length == 0)
		return;
	
	var podfile = new List<string> ();
	var podfileBegin = new List<string> (PODFILE_BEGIN);
	
	var minimunSupportedVersion = GetMinimunSupportedVersion (artifact);
	podfileBegin [0] = string.Format (podfileBegin [0], minimunSupportedVersion);
	podfile.AddRange (podfileBegin);

	if (artifact.ExtraPodfileLines != null)
		podfile.AddRange (artifact.ExtraPodfileLines);

	podfile.AddRange (PODFILE_TARGET);
	podfile.AddRange (GetPodfileLines (artifact));

	if (artifact.Dependencies != null)
		foreach (var dependency in artifact.Dependencies)
			podfile.AddRange (GetPodfileLines (dependency));

	if (podfile.Count == PODFILE_BEGIN.Length + PODFILE_TARGET.Length + (artifact.ExtraPodfileLines?.Length ?? 0))
		return;

	podfile.AddRange (PODFILE_END);

	var podfilePath = $"./externals/build/{artifact.Id}";
	EnsureDirectoryExists (podfilePath);

	FileWriteLines ($"{podfilePath}/Podfile", podfile.ToArray ());
	CocoaPodInstall (podfilePath);
}

string GetMinimunSupportedVersion (Artifact artifact)
{
	var version = artifact.MinimunSupportedVersion;

	if (artifact.Dependencies == null)
		return version;

	foreach (var dependency in artifact.Dependencies)
		if (string.Compare (version, dependency.MinimunSupportedVersion) == -1)
			version = dependency.MinimunSupportedVersion;

	return version;
}

List<string> GetPodfileLines (Artifact artifact)
{
	var podfileLines = new List<string> ();

	foreach (var podSpec in artifact.PodSpecs) {
		if (podSpec.FrameworkSource != FrameworkSource.Pods)
			continue;

		podfileLines.AddRange (podSpec.BuildPodLines ());
	}

	return podfileLines;
}

void BuildSdkOnPodfile (Artifact artifact)
{
	if (artifact.PodSpecs?.Length == 0)
		return;

	var baseArch = Platform.iOSArmV7;	
	// from iOS 11 only 64-bit builds are supported
	var platforms = Version.TryParse(GetMinimunSupportedVersion(artifact), out var iosVer) && iosVer.Major > 10
		? new [] { Platform.iOSArm64, Platform.iOSSimulator64 }
		: new [] { baseArch, Platform.iOSArm64, Platform.iOSSimulator64, Platform.iOSSimulator };
	var podsProject = "./Pods/Pods.xcodeproj";
	var workingDirectory = (DirectoryPath)$"./externals/{artifact.Id}";

	var podSpecsToBuild = new List<PodSpec> ();

	foreach (var podSpec in artifact.PodSpecs)
	{
		if (podSpec.FrameworkSource != FrameworkSource.Pods)
			continue;

		var framework = $"{podSpec.FrameworkName}.framework";
		var frameworkPaths = GetDirectories($"{workingDirectory}/Pods/**/{framework}");
		
		if (frameworkPaths?.Count <= 0) {
			if (!podSpec.CanBeBuild)
				continue;

			podSpecsToBuild.Add (podSpec);
			// BuildXcodeFatFramework (podsProject, podSpec.TargetName, platforms, libraryTitle: podSpec.FrameworkName, workingDirectory: workingDirectory);
			// CopyDirectory ($"{workingDirectory}/{framework}", $"./externals/{framework}");
		} else {
			foreach (var path in frameworkPaths)
				CopyDirectoryWithSymlinks (path, $"./externals/{framework}");
		}
	}

	BuildXcodeFatFramework (podsProject, podSpecsToBuild.ToArray (), platforms, workingDirectory: workingDirectory);

	foreach (var podSpec in podSpecsToBuild) {
		var framework = $"{podSpec.FrameworkName}.framework";
		CopyDirectoryWithSymlinks ($"{workingDirectory}/{framework}", $"./externals/{framework}");
	}
}

void BuildSdkOnPodfileV2 (Artifact artifact)
{
	if (artifact.PodSpecs?.Length == 0)
		return;

	var platforms = new [] { 
		PlatformV2.Create (Sdk.iPhoneOS),
		PlatformV2.Create (Sdk.iPhoneSimulator),
		PlatformV2.Create (Sdk.macCatalyst)
	};
	var podsProject = "./Pods/Pods.xcodeproj";
	var workingDirectory = (DirectoryPath)$"./externals/build/{artifact.Id}";

	var podSpecsToBuild = new List<PodSpec> ();

	foreach (var podSpec in artifact.PodSpecs)
	{
		if (podSpec.FrameworkSource != FrameworkSource.Pods)
			continue;

		var frameworkName = $"{podSpec.FrameworkName}.framework";
		var frameworkPaths = GetDirectories($"{workingDirectory}/Pods/**/{frameworkName}");

		var xcframeworkName = $"{podSpec.FrameworkName}.xcframework";
		var xcframeworkPaths = GetDirectories($"{workingDirectory}/Pods/**/{xcframeworkName}");
		
		if (frameworkPaths?.Count <= 0 && xcframeworkPaths?.Count <= 0) {
			if (!podSpec.CanBeBuild)
				continue;

			podSpecsToBuild.Add (podSpec);
		} else {
			foreach (var path in frameworkPaths)
				CopyDirectoryWithSymlinks (path, $"./externals/{frameworkName}");

			foreach (var path in xcframeworkPaths)
				CopyDirectoryWithSymlinks (path, $"./externals/{xcframeworkName}");
		}
	}

	// Podspecs may declare deployment targets older than current Xcode accepts (for example iOS 10).
	// Build every pod target for the package's own minimum OS, which is what consumers require anyway.
	var buildSettings = new Dictionary<string, string> {
		["IPHONEOS_DEPLOYMENT_TARGET"] = GetMinimunSupportedVersion (artifact)
	};

	BuildXcodeXcframework (podsProject, podSpecsToBuild.ToArray (), platforms, workingDirectory: workingDirectory, buildSettings: buildSettings);

	foreach (var podSpec in podSpecsToBuild) {
		var xcframeworkName = $"{podSpec.FrameworkName}.xcframework";
		CopyDirectoryWithSymlinks ($"{workingDirectory}/{xcframeworkName}", $"./externals/{xcframeworkName}");
	}
}

void CleanVisualStudioSolution ()
{
	MSBuild(SOLUTION_PATH, c => {
		c.Configuration = "Release";
		c.Restore = true;
		c.MaxCpuCount = 0;
		c.Targets.Add("Clean");
	});

	var deleteDirectorySettings = new DeleteDirectorySettings {
		Recursive = true,
		Force = true
	};

	var bins = GetDirectories("./**/bin");
	DeleteDirectories (bins, deleteDirectorySettings);

	var objs = GetDirectories("./**/obj");
	DeleteDirectories (objs, deleteDirectorySettings);
}

void RestoreVisualStudioSolution ()
{
	MSBuild(SOLUTION_PATH, c => {
		c.Restore = true;
		c.MaxCpuCount = 0;
		c.Targets.Clear();
		c.Targets.Add("Restore");
	});
	NuGetRestore (SOLUTION_PATH);
}

void BuildXcodeFatLibrary (FilePath xcodeProject, string target, Platform [] platforms, string libraryTitle = null, string librarySuffix = null, DirectoryPath workingDirectory = null)
{
	if (!IsRunningOnUnix())
	{
		Warning("{0} is not available on the current platform.", "xcodebuild");
		return;
	}

	libraryTitle = libraryTitle ?? target;
	workingDirectory = workingDirectory ?? Directory("./externals/");
	var libraryFile = (FilePath)(librarySuffix != null ? $"{libraryTitle}.{librarySuffix}" : $"{libraryTitle}");
	var archsFiles = new List<FilePath> ();

	var buildArch = new Action<string, string, FilePath>((sdk, arch, dest) => {
		if (FileExists(dest))
			return;

		XCodeBuild(new XCodeBuildSettings
		{
			Project = workingDirectory.CombineWithFilePath(xcodeProject).ToString(),
			Target = target,
			Sdk = sdk,
			Arch = arch,
			Configuration = "Release",
			Verbose = true
		});

		var outputPath = workingDirectory.Combine("build").Combine($"Release-{sdk}").Combine (target).CombineWithFilePath($"lib{libraryTitle}.a");
		CopyFile(outputPath, dest);
	});

	foreach (var platform in platforms) {
		var archFile = $"{libraryTitle}-{platform.Arch}";
		archsFiles.Add (archFile);
		buildArch (platform.Sdk, platform.Arch, workingDirectory.CombineWithFilePath (archFile));
	}
	
	RunLipoCreate (workingDirectory, libraryTitle, archsFiles.ToArray ());
}

void BuildXcodeFatFramework (FilePath xcodeProject, string target, Platform [] platforms, string libraryTitle = null, string librarySuffix = null, DirectoryPath workingDirectory = null)
{
	if (!IsRunningOnUnix ()) {
		Warning("{0} is not available on the current platform.", "xcodebuild");
		return;
	}

	libraryTitle = libraryTitle ?? target;
	workingDirectory = workingDirectory ?? Directory("./externals/");
	var libraryFile = (FilePath)(librarySuffix != null ? $"{libraryTitle}.{librarySuffix}" : $"{libraryTitle}");
	var fatFramework = (DirectoryPath)$"{libraryTitle}.framework";
	var fatFrameworkPath = workingDirectory.Combine (fatFramework);
	var archsPaths = new List<FilePath> ();

	var buildArch = new Action<string, string, DirectoryPath> ((sdk, arch, dest) => {
		if (DirectoryExists (dest))
			return;

		XCodeBuild (new XCodeBuildSettings {
			Project = workingDirectory.CombineWithFilePath (xcodeProject).ToString (),
			Target = target,
			Sdk = sdk,
			Arch = arch,
			Configuration = "Release",
			Verbose = true
		});

		var outputPath = workingDirectory.Combine ("build").Combine ($"Release-{sdk}").Combine (target).Combine (fatFramework);
		CopyDirectoryWithSymlinks (outputPath, dest);
	});

	foreach (var platform in platforms) {
		var archPath = (DirectoryPath)$"{libraryTitle}-{platform.Arch}.framework";
		archsPaths.Add (archPath.CombineWithFilePath (libraryTitle));
		buildArch (platform.Sdk, platform.Arch, workingDirectory.Combine (archPath));

		if (!DirectoryExists (fatFrameworkPath))
			CopyDirectoryWithSymlinks (workingDirectory.Combine (archPath), fatFrameworkPath);
	}
	
	RunLipoCreate (workingDirectory, fatFramework.CombineWithFilePath (libraryFile), archsPaths.ToArray ());

	if (libraryTitle != target && FileExists (fatFrameworkPath.CombineWithFilePath (target)))
		DeleteFile (fatFrameworkPath.CombineWithFilePath (target));
}

void BuildXcodeFatFramework (FilePath xcodeProject, PodSpec [] podSpecs, Platform [] platforms, DirectoryPath workingDirectory = null, Dictionary<string, string> buildSettings = null)
{
	if (!IsRunningOnUnix ()) {
		Warning("{0} is not available on the current platform.", "xcodebuild");
		return;
	}
	
	workingDirectory = workingDirectory ?? Directory("./externals/");
	buildSettings = buildSettings ?? new Dictionary<string, string> ();
	if (!buildSettings.ContainsKey("CODE_SIGNING_ALLOWED"))
		buildSettings["CODE_SIGNING_ALLOWED"] = "NO";
	if (!buildSettings.ContainsKey("CODE_SIGNING_REQUIRED"))
		buildSettings["CODE_SIGNING_REQUIRED"] = "NO";
	if (!buildSettings.ContainsKey("CODE_SIGN_IDENTITY"))
		buildSettings["CODE_SIGN_IDENTITY"] = "";
	if (!buildSettings.ContainsKey("EXPANDED_CODE_SIGN_IDENTITY"))
		buildSettings["EXPANDED_CODE_SIGN_IDENTITY"] = "";

	foreach (var podSpec in podSpecs) {
		var target = podSpec.TargetName;
		var libraryTitle = podSpec.FrameworkName;
		var fatFramework = (DirectoryPath)$"{libraryTitle}.framework";
		
		foreach (var platform in platforms) {
			var sdk = platform.Sdk;
			var arch = platform.Arch;

			var platformFramework = (DirectoryPath)$"{libraryTitle}-{arch}.framework";
			var platformFrameworkPath = workingDirectory.Combine (platformFramework);

			if (DirectoryExists (platformFrameworkPath))
				continue;

			var buildSettingsCopy = new Dictionary<string, string> (buildSettings);

			if (!buildSettingsCopy.ContainsKey ("SYMROOT"))
				buildSettingsCopy ["SYMROOT"] = MakeAbsolute (workingDirectory.Combine ($"build-{arch}")).FullPath;

			var buildPath = Directory (buildSettingsCopy ["SYMROOT"]).Path;

			XCodeBuild (new XCodeBuildSettings {
				Project = workingDirectory.CombineWithFilePath (xcodeProject).ToString (),
				Target = target,
				Sdk = sdk,
				Arch = arch,
				Configuration = "Release",
				Verbose = true,
				BuildSettings = buildSettingsCopy
			});

			var releasePath = buildPath.Combine ($"Release-{sdk}");

			foreach (var p in podSpecs) {
				var outputPath = releasePath.Combine (p.TargetName);
				var lt = p.FrameworkName;
				var ff = (DirectoryPath)$"{lt}.framework";
				var frameworkOutputPath = outputPath.Combine (ff);

				if (!DirectoryExists (frameworkOutputPath))
					continue;
				
				var fatFrameworkPath = workingDirectory.Combine (ff);

				if (!DirectoryExists (fatFrameworkPath))
					CopyDirectoryWithSymlinks (frameworkOutputPath, fatFrameworkPath);

				var pf = (DirectoryPath)$"{lt}-{arch}.framework";
				var pfp = workingDirectory.Combine (pf);

				CopyDirectoryWithSymlinks (frameworkOutputPath, pfp);
			}
		}

		var archPaths = new List<FilePath> ();
		var frameworkPaths = GetFiles ($"{workingDirectory}/{libraryTitle}-*/{libraryTitle}");

		foreach (var path in frameworkPaths)
			archPaths.Add (path);

		RunLipoCreate (workingDirectory, fatFramework.CombineWithFilePath (libraryTitle), archPaths.ToArray ());
	}
}

void BuildXcodeXcframework (FilePath xcodeProject, PodSpec [] podSpecs, PlatformV2 [] platforms, DirectoryPath workingDirectory = null, Dictionary<string, string> buildSettings = null)
{
	if (!IsRunningOnUnix ()) {
		Warning("{0} is not available on the current platform.", "xcodebuild");
		return;
	}
	
	Information ("Building the following frameworks:");
	Information (string.Join (",\n", podSpecs.Select (ps => ps.FrameworkName).ToArray ()));

	workingDirectory = workingDirectory ?? Directory ("./externals/");
	buildSettings = buildSettings ?? new Dictionary<string, string> ();
	if (!buildSettings.ContainsKey("CODE_SIGNING_ALLOWED"))
		buildSettings["CODE_SIGNING_ALLOWED"] = "NO";
	if (!buildSettings.ContainsKey("CODE_SIGNING_REQUIRED"))
		buildSettings["CODE_SIGNING_REQUIRED"] = "NO";
	if (!buildSettings.ContainsKey("CODE_SIGN_IDENTITY"))
		buildSettings["CODE_SIGN_IDENTITY"] = "";
	if (!buildSettings.ContainsKey("EXPANDED_CODE_SIGN_IDENTITY"))
		buildSettings["EXPANDED_CODE_SIGN_IDENTITY"] = "";

	foreach (var podSpec in podSpecs) {
		Information ($"Building the following framework: {podSpec.FrameworkName}...");

		var target = podSpec.TargetName;
		var buildDirectory = workingDirectory.Combine (podSpec.FrameworkName);
		var xcframeworkPath = workingDirectory.Combine ($"{podSpec.FrameworkName}.xcframework");
		var xcodeBuildArgs = new ProcessArgumentBuilder();
		xcodeBuildArgs.Append ("-create-xcframework");
		xcodeBuildArgs.Append($"-output {xcframeworkPath}");
		
		foreach (var platform in platforms) {
			Information ($"Building {podSpec.FrameworkName} framework with {platform.Sdk} platform SDK...");

			var sdk = string.Equals (platform.Sdk, Sdk.macCatalyst) ? Sdk.macOS : platform.Sdk;
			var archs = platform.Archs;
			var archiveDirectory = buildDirectory.Combine ($"{platform.Sdk}.xcarchive");
			var archiveFrameworksDirectory = archiveDirectory.Combine ("Products/Library/Frameworks");
			xcodeBuildArgs.Append ($"-framework {archiveFrameworksDirectory}/{podSpec.FrameworkName}.framework");

			if (DirectoryExists (archiveDirectory))
				continue;

			var buildSettingsCopy = new Dictionary<string, string> (buildSettings);
			buildSettingsCopy ["SKIP_INSTALL"] = "NO";
			buildSettingsCopy ["BUILD_LIBRARY_FOR_DISTRIBUTION"] = "YES";

			if (string.Equals (platform.Sdk, Sdk.macCatalyst))
				buildSettingsCopy ["SUPPORTS_MACCATALYST"] = "YES";

			var xcodeBuildSettings = new XCodeBuildSettings {
				Project = workingDirectory.CombineWithFilePath (xcodeProject).ToString (),
				Scheme = target,
				Archive = true,
				ArchivePath = archiveDirectory.ToString (),
				Sdk = sdk.Value,
				Verbose = true,
				BuildSettings = buildSettingsCopy
			};

			if (archs != null)
				xcodeBuildSettings.Arch = string.Join (',', archs.Select (a => a.Value).ToArray ());

			XCodeBuild (xcodeBuildSettings);

			Information ($"Done building {podSpec.FrameworkName} framework with {platform.Sdk} platform SDK...");

			var builtFrameworkDirectories = GetDirectories (archiveFrameworksDirectory.Combine ("*.framework").ToString ());
			
			Information ($"Copying the following built frameworks to its respective archives:");
			Information (string.Join (",\n", builtFrameworkDirectories.Select (b => b.ToString ()).ToArray ()));

			foreach (var directory in builtFrameworkDirectories) {
				var builtFrameworkName = directory.GetDirectoryName ().Replace (".framework", "");

				if (string.Equals (builtFrameworkName, podSpec.FrameworkName))
					continue;

				DirectoryPath destinationDirectory = Directory (archiveFrameworksDirectory.ToString ().Replace ($"{podSpec.FrameworkName}", $"{builtFrameworkName}"));
				destinationDirectory = destinationDirectory.Combine ($"{builtFrameworkName}.framework");

				Information ($"Copying {directory} to {destinationDirectory}");

					CopyDirectoryWithSymlinks (directory, destinationDirectory);
			}
		}

		Information ($"Building {podSpec.FrameworkName} xcframework...");

		// xcodebuild -create-xcframework fails when its output path already exists,
		// so drop the xcframework left behind by any previous run.
		if (DirectoryExists (xcframeworkPath))
			DeleteDirectory (xcframeworkPath, new DeleteDirectorySettings { Recursive = true, Force = true });

		ThrowIfProcessFailed ("xcodebuild -create-xcframework", StartProcess ("xcodebuild", new ProcessSettings { Arguments = xcodeBuildArgs }));
	}
}

bool TargetExistsInXcodeProject (FilePath xcodeProject, string target, DirectoryPath workingDirectory = null)
{
	workingDirectory = workingDirectory ?? Directory ("./externals/");

	var processSettings = new ProcessSettings { 
		Arguments = $"-project {workingDirectory.CombineWithFilePath (xcodeProject)} -list",
		RedirectStandardOutput = true
	};

	using(var process = StartAndReturnProcess("xcodebuild", processSettings))
	{
		process.WaitForExit();

		foreach (var line in process.GetStandardOutput ())
			if (line.Contains (target))
				return true;

		return false;
	}
}