/*

   This Source Code Form is subject to the terms of the Mozilla Public

   License, v. 2.0. If a copy of the MPL was not distributed with this

   file, You can obtain one at http://mozilla.org/MPL/2.0/.

   Copyright (C) 2009-2010 Michael Möller <mmoeller@openhardwaremonitor.org>

 */

 using Microsoft.Win32;

 using SharpDisplayManager.TaskScheduler;

 using System;

 using System.IO;

 using System.Runtime.InteropServices;

 using System.Security;

 using System.Security.Principal;

 using System.Windows.Forms;

 using System.Deployment.Application;

 namespace SharpDisplayManager

 {

 	public class StartupManager

 	{

 		private TaskSchedulerClass scheduler;

 		private bool startup;

 		private bool isAvailable;

 		private const string REGISTRY_RUN =

 		  @"Software\Microsoft\Windows\CurrentVersion\Run";

 		private bool IsAdministrator()

 		{

 			try

 			{

 				WindowsIdentity identity = WindowsIdentity.GetCurrent();

 				WindowsPrincipal principal = new WindowsPrincipal(identity);

 				return principal.IsInRole(WindowsBuiltInRole.Administrator);

 			}

 			catch

 			{

 				return false;

 			}

 		}

 		public StartupManager()

 		{

 			int p = (int)System.Environment.OSVersion.Platform;

 			if ((p == 4) || (p == 128))

 			{

 				scheduler = null;

 				isAvailable = false;

 				return;

 			}

 			if (IsAdministrator())

 			{

 				try

 				{

 					scheduler = new TaskSchedulerClass();

 					scheduler.Connect(null, null, null, null);

 				}

 				catch

 				{

 					scheduler = null;

 				}

 				if (scheduler != null)

 				{

 					try

 					{

 						// check if the task scheduler is running

 						IRunningTaskCollection collection = scheduler.GetRunningTasks(0);

 						ITaskFolder folder = scheduler.GetFolder("\\Sharp Display Manager");

 						IRegisteredTask task = folder.GetTask("Startup");

 						startup = (task != null) &&

 						  (task.Definition.Triggers.Count > 0) &&

 						  (task.Definition.Triggers[1].Type ==

 							TASK_TRIGGER_TYPE2.TASK_TRIGGER_LOGON) &&

 						  (task.Definition.Actions.Count > 0) &&

 						  (task.Definition.Actions[1].Type ==

 							TASK_ACTION_TYPE.TASK_ACTION_EXEC) &&

 						  (task.Definition.Actions[1] as IExecAction != null) &&

 						  ((task.Definition.Actions[1] as IExecAction).Path ==

 							Application.ExecutablePath);

 					}

 					catch (IOException)

 					{

 						startup = false;

 					}

 					catch (UnauthorizedAccessException)

 					{

 						scheduler = null;

 					}

 					catch (COMException)

 					{

 						scheduler = null;

 					}

 				}

 			}

 			else

 			{

 				scheduler = null;

 			}

 			if (scheduler == null)

 			{

 				try

 				{

 					using (RegistryKey key =

 					  Registry.CurrentUser.OpenSubKey(REGISTRY_RUN))

 					{

 						startup = false;

 						if (key != null)

 						{

 							string value = (string)key.GetValue("SharpDisplayManager");

 							if (value != null)

 								startup = value == LaunchCommand;

 						}

 					}

 					isAvailable = true;

 				}

 				catch (SecurityException)

 				{

 					isAvailable = false;

 				}

 			}

 			else

 			{

 				isAvailable = true;

 			}

 		}

 		private void CreateSchedulerTask()

 		{

 			ITaskDefinition definition = scheduler.NewTask(0);

 			definition.RegistrationInfo.Description =

 			  "This task starts the Sharp Display Manager on Windows startup.";

 			definition.Principal.RunLevel =

 			  TASK_RUNLEVEL.TASK_RUNLEVEL_HIGHEST;

 			definition.Settings.DisallowStartIfOnBatteries = false;

 			definition.Settings.StopIfGoingOnBatteries = false;

 			definition.Settings.ExecutionTimeLimit = "PT0S";

 			ILogonTrigger trigger = (ILogonTrigger)definition.Triggers.Create(

 			  TASK_TRIGGER_TYPE2.TASK_TRIGGER_LOGON);

 			IExecAction action = (IExecAction)definition.Actions.Create(

 			  TASK_ACTION_TYPE.TASK_ACTION_EXEC);

 			action.Path = Application.ExecutablePath;

 			action.WorkingDirectory =

 			  Path.GetDirectoryName(Application.ExecutablePath);

 			ITaskFolder root = scheduler.GetFolder("\\");

 			ITaskFolder folder;

 			try

 			{

 				folder = root.GetFolder("Sharp Display Manager");

 			}

 			catch (IOException)

 			{

 				folder = root.CreateFolder("Sharp Display Manager", "");

 			}

 			folder.RegisterTaskDefinition("Startup", definition,

 			  (int)TASK_CREATION.TASK_CREATE_OR_UPDATE, null, null,

 			  TASK_LOGON_TYPE.TASK_LOGON_INTERACTIVE_TOKEN, "");

 		}

 		private void DeleteSchedulerTask()

 		{

 			ITaskFolder root = scheduler.GetFolder("\\");

 			try

 			{

 				ITaskFolder folder = root.GetFolder("Sharp Display Manager");

 				folder.DeleteTask("Startup", 0);

 			}

 			catch (IOException) { }

 			try

 			{

 				root.DeleteFolder("Sharp Display Manager", 0);

 			}

 			catch (IOException) { }

 		}

 		string LaunchCommand

 		{

 			get

 			{	

 				//Executable path won't launch ClickOnce Application with deployment enabled.

 				//return Application.ExecutablePath;

 				//Instead we need to launch the application using the .appref-ms shortcut.

 				//That shortcut is located at <programs>\<publisher>\<suite>\<product>.appref-ms

 				return string.Concat(Environment.GetFolderPath(Environment.SpecialFolder.Programs), "\\", "Slions", "\\", "Sharp Display Manager" , "\\" ,"Sharp Display Manager", ".appref-ms");

 			}

 		}

 		private void CreateRegistryRun()

 		{

 			RegistryKey key = Registry.CurrentUser.CreateSubKey(REGISTRY_RUN);

 			//Rather than the executable name we pass in the ClickOnce shortcut to make sure we launch with deployment support

 			key.SetValue("SharpDisplayManager", LaunchCommand);

 		}

 		private void DeleteRegistryRun()

 		{

 			RegistryKey key = Registry.CurrentUser.CreateSubKey(REGISTRY_RUN);

 			key.DeleteValue("SharpDisplayManager");

 		}

 		public bool IsAvailable

 		{

 			get { return isAvailable; }

 		}

 		public bool Startup

 		{

 			get

 			{

 				return startup;

 			}

 			set

 			{

 				if (startup != value)

 				{

 					if (isAvailable)

 					{

 						if (scheduler != null)

 						{

 							if (value)

 								CreateSchedulerTask();

 							else

 								DeleteSchedulerTask();

 							startup = value;

 						}

 						else

 						{

 							try

 							{

 								if (value)

 									CreateRegistryRun();

 								else

 									DeleteRegistryRun();

 								startup = value;

 							}

 							catch (UnauthorizedAccessException)

 							{

 								throw new InvalidOperationException();

 							}

 						}

 					}

 					else

 					{

 						throw new InvalidOperationException();

 					}

 				}

 			}

 		}

 	}

 }