// Sample program for creating an Application with the Script Deployment Type and persisting into the 
// Configuration Manager database.
// 
// This is example code and does not contain error handling for all cases, nor demonstrate relationships
// such as dependencies and supersedence, and also does not demonstrate creating requirement rules for a 
// Deployment Type.

namespace ApplicationCreator
{
	using System;
	using System.IO;
	using Microsoft.ConfigurationManagement.AdminConsole.AppManFoundation;
	using Microsoft.ConfigurationManagement.ApplicationManagement;
	using Microsoft.ConfigurationManagement.ManagementProvider;
	using Microsoft.ConfigurationManagement.ManagementProvider.WqlQueryEngine;

	class Program
	{
		static void Main(string[] args)
		{
			Initialize(Environment.MachineName);
			Application application = CreateApplication("app", "description", System.Globalization.CultureInfo.CurrentCulture.TwoLetterISOLanguageName);
			application.DeploymentTypes.Add(CreateScriptDt(application.Title, application.Description, "notepad.exe", "return 0;", null));

			Store(application);
	}

		private static AppManWrapper wrapper;
		private static ApplicationFactory factory;

		// Initializes the default authoring scope and establishes connection to the SMS Provider.
		// <param name="siteServerName">A string containing the name of the Configuration Manager site.</param>

		public static void Initialize(string siteServerName)
		{
			Validator.CheckForNull(siteServerName, "siteServerName");

			Log("Connecting to the SMS Provider on computer [{0}].", siteServerName);

			// Creates a connection to the SMS Provider.
			WqlConnectionManager connectionManager = new WqlConnectionManager();
			connectionManager.Connect(siteServerName);

			Log("Initializing the ApplicationFactory.");
			// Initialize application wrapper and factory for creating the SMS Provider application object.
			factory = new ApplicationFactory();
			wrapper = AppManWrapper.Create(connectionManager, factory) as AppManWrapper;

	}

		// Inserts the provided application to the provided connected Configuration Manager site.
		// <param name="application">An application object that will be inserted into the Configuration Manager site.</param>
		public static void Store(Application application)
		{
			Validator.CheckForNull(application, "application");
			Validator.CheckForNull(wrapper, "wrapper");

			Exception ex = null;

			try
			{
				// Set the application into the provider object.
				wrapper.InnerAppManObject = application;

				Log("Initializing the SMS_Application object with the model.");
				factory.PrepareResultObject(wrapper);

				Log("Saving application, Title: [{0}], Scope: [{1}].", application.Title, application.Scope);

				// Save to the database.
				wrapper.InnerResultObject.Put();
		}
			catch (SmsException exception)
			{
				ex = exception;
		}
			catch (Exception exception)
			{
				ex = exception;
		}

			if (ex != null)
			{
				Log("ERROR saving application [{0}].", ex.Message);
				Log(ex);
		}
			else
			{
				Log("Successfully saved application.");
		}
	}

		// Creates an Application object.
		// <param name="title">The title of the application that will be visible in the admin console and in the Software Center and Portal.</param>
		// <param name="description">The description for the application.</param>
		// <param name="language">The language of the resources supplied.</param>

		public static Application CreateApplication(string title, string description, string language)
		{
			Validator.CheckForNull(title, "title");
			Validator.CheckForNull(language, "language");

			Log("Creating application [{0}].", title);
			Application app = new Application { Title = title };
			app.DisplayInfo.DefaultLanguage = language; 
			app.DisplayInfo.Add(new AppDisplayInfo { Title = title, Description = description, Language = language });

			return app;
	}

		// Creates a Deployment Type with a Script Installer.
		// <param name="title">A string containing the title for the Deployment Type (required).</param>
		// <param name="description"> A string containing the description for the Deployment Type (optional).</param>
		// <param name="installCommandLine">A string containing the installation command line for the installer (required).</param>
		// <param name="detectionScript">A string containing the script for detection, this would most likely be separated out.
		// to a different method to support creating different detection method types such as Windows Installer, EHD, and script. Additionally, in the case
		// of script, the more likely scenario would be to load the script from a file, read the file, and then set the value.</param>
		// <param name="contentFolder">The folder that will contain the set of files that will represent the content for this Deployment Type. Validation
		// should verify that this is a UNC path, otherwise the Configuration Manager system will fail to create the content package correctly.</param>
		// <returns>A deployment type object.</returns>

		public static DeploymentType CreateScriptDt(string title, string description, string installCommandLine, string detectionScript, string contentFolder)
		{
			Validator.CheckForNull(installCommandLine, "installCommandLine");
			Validator.CheckForNull(title, "title");
			Validator.CheckForNull(detectionScript, "detectionScript");

			Log("Creating Script DeploymentType.");

			ScriptInstaller installer = new ScriptInstaller();
			installer.InstallCommandLine = installCommandLine;
			installer.DetectionScript = new Script { Text = detectionScript, Language = ScriptLanguage.JavaScript.ToString() };

			// Only add content if specified and exists.
			if (Directory.Exists(contentFolder) == true)
			{
				Content content = ContentImporter.CreateContentFromFolder(contentFolder);

				if (content != null)
				{
					installer.Contents.Add(content);
			}
		}

			DeploymentType dt = new DeploymentType(installer, ScriptInstaller.TechnologyId, NativeHostingTechnology.TechnologyId);
			dt.Title = title;
			return dt;
	}

		public static void Log(Exception exception)
		{
			Log("ERROR: [{0}] ", exception.Message);
			Log("Stack: [{0}]", exception.StackTrace);

			if (exception.InnerException != null)
			{
				Log(exception.InnerException);
		}
	}

		public static void Log(string message, params object[] args)
		{
			Console.WriteLine(message, args);
	}
}
}