// <file>
//     <copyright see="prj:///doc/copyright.txt"/>
//     <license see="prj:///doc/license.txt"/>
//     <owner name="Mike Krueger" email="mike@icsharpcode.net"/>
//     <version value="$version"/>
// </file>

using System;
using System.ComponentModel;
using System.Text;
using System.Xml;
using System.Diagnostics;

using ICSharpCode.SharpDevelop.Gui;
using ICSharpCode.SharpDevelop.Internal.Project;

namespace CPPBinding
{
	#region OPTIMIZATION
	public enum OptimizeLevel {
		Deactivated,      // /Od
		MinimizeSize,     // /O1
		MaximizeSpeed,    // /O2
		CompleteOptimize  // /Ox
	}
	
	public enum FloatingPointConsistency {
		Standard,
		Enhanced  // /Op
	}
	
	public enum InlineFunctionExpansion 
	{
		Standard,  // /Ob0
		Manual,    // /Ob1
		Automatic  // /Ob2
	}
	
	public enum SizeOrSpeedOptimization
	{
		Neither,
		Size,
		Speed
	}

	#endregion
	
	#region CODE GENERATION
	public enum Architecture {
		Mixed,      
		i386,       // /G3
		i486,       // /G4
		Pentium,    // /G5
		PentiumPRO, // /G6
		Pentium4    // /G7
	}
	
	public enum CallingConvention {
		__cdecl,    // default (/Gd)
		__fastcall, // /Gr
		__stdcall   // /Gz
	}

	public enum EnhancedInstructionSet {
		NotSpecified,
		SSE,          // /arch:SSE
		SSE2          // /arch:SSE2
	}
	
	public enum RunTimeObservation {
		Standard,
		Stack,                  // /RTCs
		UninitializedVariables, // /RTCu
		Both                    // /RTCs /RTCu
	}
	
	public enum ExceptionHandling {
		None,
		SynchronousExceptionHandling, // /GX
		AsynchronousExceptionHandling // /EHa
	}
	
	public enum StringPooling {
		Disabled,
		Enabled,
		EnabledReadOnlyPooling
	}

	#endregion

	#region DEBUGGING
	public enum DebugInformationFormat {
		Deactivated,
		C7,								   // /Z7
		OnlyLineNumbers,				   // /Zd
		ProgramDatabase,				   // /Zi
		ProgramDatabaseWithEditAndContinue // /ZI
	}
	
	#endregion

	#region PREPROCESSOR
	public enum PreProcessorRun {
		No,
		WithLineNumbers,    // /E
		WithoutLineNumbers  // /EP
	}
	#endregion
	
	#region LANGUAGE
	public enum StructMemberAlignment {
		Standard,
		Byte1,    // /Zp1
		Byte2,    // /Zp2
		Byte4,    // /Zp4
		Byte8,    // /Zp8
		Byte16,   // /Zp16
	}

	public enum LanguageExtensions {
		Enable, // /Ze
		Disable // /Za
	}
	
	#endregion
	
	#region LINKING
	public enum RunTimeLibrary {
		MultiThreaded,         // /MT
		MultiThreadedDebug,    // /MTd
		MultiThreadedDLL,      // /MD
		MultiThreadedDebugDLL, // /MDd
		SingleThreaded,        // /ML
		SingleThreadedDebug    // /MLd
	}
	
	public enum ConfigurationType {
		Exe, 
		Dll
	}
	
	#endregion

	#region PRECOMPILED HEADER	
	public enum PreCompiledHeader {
		DontUsePre,          // /Y-
		Create,              // /Yc
		CreateAutomatically, // /YX
		Use                  // /Yu
	}
	#endregion

	#region MISCELLANEOUS
	public enum CompileType {
		Standard,
		C,        // /TC
		CPP       // /TP
	}
	
	#endregion
	
	
	
	public enum AssemblyOutput {
		NoList,
		ListAssembly,
		ListAssemblyWithSource,
		ListAssemblyWithCode,
		ListAssemblyWithCodeAndSource,
	}
	
	public enum ShowLinkerStatus {
		Unselected,
		ShowAll,
		ShowSome
	}
	public enum IncrementalLinking {
		Standard,
		Yes,
		No
	}
	
	public enum DebuggableAssembly {
		DontEmitDebuggable,
		EnableDebugToRuntimeDisableOptimization,
		DisableDebugToRuntimEnableOptimization
	}
	
	public enum LinkerSubSystem {
		Unselected,
		Console,
		Windows
	}
	public enum ActivateBigAddresses {
		Standard,
		NoSupport,
		Supported
	}
	public enum TerminalServer {
		Standard,
		NotBound,
		Bound
	}
	
	/// <summary>
	/// This class handles project specific compiler parameters
	/// </summary>
	public class CPPCompilerParameters : AbstractProjectConfiguration
	{

		private static bool IsNotEmpty(string arg) 
		{
			return arg != null && arg.Length > 0;
		}
		
		private static void AppendOption(StringBuilder sb, String opt, String val) 
		{
			AppendOption(sb, opt, val, true);
		}
		
		private static void AppendOption(StringBuilder sb, String opt, String val, bool quote) 
		{
			
			sb.Append(opt);
			if (quote) 
				sb.Append('"');
			sb.Append(val);
			if (quote) 
				sb.Append('"');
			sb.Append("\n");
		}
		
		private static void AppendList(StringBuilder sb, String opt, String values)
		{
			AppendList(sb, opt, values, true);
		}
	
		private static void AppendList(StringBuilder sb, String opt, String values, bool quote)
		{
			foreach (string val in values.Split(';'))
			{
				AppendOption(sb, opt, val, quote);
			}
		}
		
		#region Misc Options
		[XmlNodeName("MiscOptions")]
		public class MiscCPPOptions 
		{
			[ConvertToRelativePath()]
			[XmlAttribute("OutputDirectory")]
			public string outputDirectory       = "";
			
			[ConvertToRelativePath()]
			[XmlAttribute("IntermediateDirectory")]
			public string intermediateDirectory = "";
			
			[XmlAttribute("ConfigurationType")]
			public ConfigurationType configurationType   = ConfigurationType.Exe;
			
			[XmlAttribute("UseManagedExtensions")]
			public bool useManagedExtensions = true;
			
			[XmlAttribute("additionalCompilerOptions")]
			public string additionalCompilerOptions = "";
		}
		#endregion
	
		#region General Options
		[XmlNodeName("GeneralCPPOptions")]
		public class GeneralCPPOptions
		{
			[XmlAttribute("additionalIncludeDirectories")]
			public string additionalIncludeDirectories = "";
			
			[XmlAttribute("additionalAssemblySearchPaths")]
			public string additionalAssemblySearchPaths = "";
			
			[XmlAttribute("debugInformationFormat")]
			public DebugInformationFormat debugInformationFormat = DebugInformationFormat.Deactivated;
			
			[XmlAttribute("noStartLogo")]
			public bool noStartLogo = true;
			
			[XmlAttribute("warningLevel")]
			public int warningLevel = 4;
			
			[XmlAttribute("search64BitPortabilityProblems")]
			public bool search64BitPortabilityProblems = false;
			
//			[XmlAttribute("treatWarningsAsErrors")]
//			public bool treatWarningsAsErrors = false;
			
			[DefaultValue("")]
			[LocalizedProperty("Additional include paths",
			                   Description = "Specifies one or more semi-colon delimited additonal paths to search for includes. (/I[path])")]
			public string AdditionalIncludeDirectories {
				get {
					return additionalIncludeDirectories;
				}
				set {
					additionalIncludeDirectories = value;
				}
			}
			
			[DefaultValue("")]
			[LocalizedProperty("Additional assembly search",
			                   Description = "Specifies one or more semi-colon delimited additonal paths to search for #using assemblies. (/AI[path])")]
			public string AdditionalAssemblySearchPaths {
				get {
					return additionalAssemblySearchPaths;
				}
				set {
					additionalAssemblySearchPaths = value;
				}
			}
			
			[LocalizedProperty("Debug information format",
			                   Description = "(/Z7, /Zd, /Zi. /ZI)")]
			public DebugInformationFormat DebugInformationFormat {
				get {
					return debugInformationFormat;
				}
				set {
					debugInformationFormat = value;
				}
			}
			
			[DefaultValue(true)]
			[LocalizedProperty("Surpress Startup Logo",
			                   Description = "Surpress the display of the startup logo and information messages. (/nologo)")]
			public bool NoStartLogo {
				get {
					return noStartLogo;
				}
				set {
					noStartLogo = value;
				}
			}
			
			[DefaultValue(4)]
			[LocalizedProperty("Warning level",
			                   Description = "(/W0 - /W4)")]
			public int WarningLevel {
				get {
					return warningLevel;
				}
				set {
					warningLevel = value;
				}
			}
			
			[DefaultValue(false)]
			[LocalizedProperty("Search for 64-Bit portability problems",
			                   Description = "(/Wp64)")]
			public bool Search64BitPortabilityProblems {
				get {
					return search64BitPortabilityProblems;
				}
				set {
					search64BitPortabilityProblems = value;
				}
			}
			
//			[DefaultValue(false)]
//			[LocalizedProperty("Treat warnings as errors",
//			                   Description = "(/WX)")]
//			public bool TreatWarningsAsErrors {
//				get {
//					return treatWarningsAsErrors;
//				}
//				set {
//					treatWarningsAsErrors = value;
//				}
//			}
			
			public string GetCommandLineParameters()
			{
				StringBuilder result = new StringBuilder();
				if (IsNotEmpty(AdditionalIncludeDirectories)) {
					AppendList(result, "/I", AdditionalIncludeDirectories, true);
				}
				if (IsNotEmpty(AdditionalAssemblySearchPaths)) {
					AppendList(result, "/AI", AdditionalAssemblySearchPaths, true);
				}
				switch (DebugInformationFormat) {
					case DebugInformationFormat.Deactivated:
						break;
					case DebugInformationFormat.C7:
						result.Append("/Z7\n");
						break;
					case DebugInformationFormat.OnlyLineNumbers:
						result.Append("/Zd\n");
						break;
					case DebugInformationFormat.ProgramDatabase:
						result.Append("/Zi\n");
						break;
					case DebugInformationFormat.ProgramDatabaseWithEditAndContinue:
						result.Append("/ZI\n");
						break;
					
				}
				if (NoStartLogo) {
					result.Append("/nologo\n");
				}
				AppendOption(result, "/W", WarningLevel.ToString());
				if (Search64BitPortabilityProblems) {
					result.Append("/Wp64\n");
				}
//				if (TreatWarningsAsErrors) {
//					result.Append("/WX\n");
//				}
				
				return result.ToString();
			}
		}
		#endregion
		
		#region Optimize Options
		[XmlNodeName("OptimizeCPPOptions")]
		public class OptimizeCPPOptions
		{
			[XmlAttribute("optimizeLevel")]
			public OptimizeLevel optimizeLevel = OptimizeLevel.Deactivated;
			
			[XmlAttribute("useGlobalOptimize")]
			public bool useGlobalOptimize = false;
			
			[XmlAttribute("inlineFunctionExtension")]
			public InlineFunctionExpansion inlineFunctionExpansion = InlineFunctionExpansion.Standard;
			
			[XmlAttribute("activateSysInternalFunctions")]
			public bool activateSysInternalFunctions = false;
			
			[XmlAttribute("floatingPointConsistency")]
			public FloatingPointConsistency floatingPointConsistency = FloatingPointConsistency.Standard;
			
			[XmlAttribute("sizeOrSpeedOptimization")]
			public SizeOrSpeedOptimization sizeOrSpeedOptimization = SizeOrSpeedOptimization.Neither;
			
			[XmlAttribute("surpressFramePointer")]
			public bool surpressFramePointer = false;
			
			[XmlAttribute("enableFiberSaveOptimize")]
			public bool enableFiberSaveOptimize = false;
			
			[XmlAttribute("architecture")]
			public Architecture architecture = Architecture.Mixed;
			
			[XmlAttribute("optimizeForWindowsExecutable")]
			public bool optimizeForWindowsExecutable = false;
			
			[LocalizedProperty("Optimize Level",
			                   Description = "/Od,/O1,/O2,/Ox")]
			public OptimizeLevel OptimizeLevel {
				get {
					return optimizeLevel;
				}
				set {
					optimizeLevel = value;
				}
			}
			
			[DefaultValue(false)]
			[LocalizedProperty("Use Global Optimization",
			                   Description = "/Og")]
			public bool UseGlobalOptimize {
				get {
					return useGlobalOptimize;
				}
				set {
					useGlobalOptimize = value;
				}
			}
			[LocalizedProperty("Inline Functions Expansion",
			                   Description = "/Ob1,/Ob2")]
			public InlineFunctionExpansion InlineFunctionExpansion {
				get {
					return inlineFunctionExpansion;
				}
				set {
					inlineFunctionExpansion = value;
				}
			}
//			[DefaultValue(false)]
//			[LocalizedProperty("",
//			                   Description = "")]
//			public bool ActivateSysInternalFunctions {
//				get {
//					return activateSysInternalFunctions;
//				}
//				set {
//					activateSysInternalFunctions = value;
//				}
//			}
			[LocalizedProperty("Floating Point Consistency",
			                   Description = "/Op")]
			public FloatingPointConsistency FloatingPointConsistency {
				get {
					return floatingPointConsistency;
				}
				set {
					floatingPointConsistency = value;
				}
			}
			[LocalizedProperty("Size Or Speed Optimization",
			                   Description = "/Ot,/Os")]
			public SizeOrSpeedOptimization SizeOrSpeedOptimization {
				get {
					return sizeOrSpeedOptimization;
				}
				set {
					sizeOrSpeedOptimization = value;
				}
			}
			[DefaultValue(false)]
			[LocalizedProperty("Suppress Frame Pointer",
			                   Description = "/Oy")]
			public bool SurpressFramePointer {
				get {
					return surpressFramePointer;
				}
				set {
					surpressFramePointer = value;
				}
			}
			[DefaultValue(false)]
			[LocalizedProperty("Fiber Safety Support",
			                   Description = "/GT")]
			public bool EnableFiberSaveOptimize {
				get {
					return enableFiberSaveOptimize;
				}
				set {
					enableFiberSaveOptimize = value;
				}
			}
			[LocalizedProperty("Optimize for Processor",
			                   Description = "/G3,/G4,/G5,/G6,/G7")]
			public Architecture Architecture {
				get {
					return architecture;
				}
				set {
					architecture = value;
				}
			}
			[DefaultValue(false)]
			[LocalizedProperty("Optimizes for Windows Application",
			                   Description = "/GA")]
			public bool OptimizeForWindowsExecutable {
				get {
					return optimizeForWindowsExecutable;
				}
				set {
					optimizeForWindowsExecutable = value;
				}
			}
			public string GetCommandLineParameters()
			{
				StringBuilder result = new StringBuilder();
				switch (OptimizeLevel) {
					case OptimizeLevel.CompleteOptimize:
						result.Append("/Ox\n");
						break;