using UnityEditor;
using UnityEngine;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using Perforce.P4;

namespace P4Connect
{
	// This Editor window allows the user to set and store
	// Perforce connection settings that will be used to
	// Check out files on Save / Move / Delete / etc...
	// The connection parameters are saved as Editor Preferences
	// which means they go the registry.
	public class Config : EditorWindow
	{
		// Event triggered when the configuration changes
		public delegate void OnPrefsChanged();
		public static event OnPrefsChanged PrefsChanged;

		// The actual connection settings

		// Give access to the Server URI
		public static string ServerURI { get; set; }

		// Give access to the User Name
		public static string Username { get; set; }

		// Give access to the Password
		public static string Password { get; set; }

		// Give access to the Workspace Name
		public static string Workspace { get; set; }

		// Give access to the DLL Location
		public static string DLLLocation { get; set; }

        // Look for p4config files to setup configuration?
        public static bool UseP4Config { get; set; }

		// Give access to whether we integrate with UnityVS
		public static bool UnityVSSupport { get; set; }

		// Give access to whether the integration is turned on or not
		public static bool PerforceEnabled { get; set; }

		// Give access to whether we check out solution files
		public static bool IncludeSolutionFiles { get; set; }

		// Give access to whether we check out project files
		public static bool IncludeProjectFiles { get; set; }

		// Give access to whether we print out paths or just filenames
		public static bool ShowPaths { get; set; }

		// Give access to whether we automatically check out on edit
		public static bool AskBeforeCheckout { get; set; }

		// Give access to whether we want to display Icons in the Project view
		public static bool DisplayStatusIcons { get; set; }

		// Whether to override P4Host
		public static bool OverrideHostname { get; set; }

		// The host name, if different than the local machine
		public static string Hostname { get; set; }

		// Whether to override P4Charset
		public static bool OverrideCharset { get; set; }

		// The host name, if different than the local machine
		public static string Charset { get; set; }

		// The location of the Diff tool
		public static string DiffToolPathname { get; set; }

		// Whether or not to display timing info for debugging
		public static bool DisplayP4Timings { get; set; }

		// Whether to display the commands sent to P4
		public static bool DisplayP4Commands { get; set; }

		// Whether or not to check the status of files before showing the contextual menu
		public static bool CheckStatusForMenus { get; set; }

		// Whether or not to warn when adding files with special characters
		public static bool WarnOnSpecialCharacters { get; set; }

		// Whether or not to check the status of files before showing the contextual menu
		public static int CheckStatusForMenusMaxItems { get; set; }

		// How many files to submit at once
		public static int OperationBatchCount { get; set; }

		// How long to keep connections open
		public static int ConnectionTimeOut { get; set; }

		// The location of the project root in relation to the workspace root
		public static string ProjectRoot { get; set; }

		// Helper property to indicate that P4 can be used
		public static bool ValidConfiguration
		{
			get { return PerforceEnabled && _CurrentState == ConfigurationState.SettingsValid; }
		}

		public const string P4BridgeDLLName = "P4Bridge.dll";
		public const string P4BridgeDYLIBName = "libP4Bridge.dylib";

		public const int MaxPendingItems = 200;

		// These are the names under which the connection settings are stored in the registry
		public const string ServerURIPrefName = "ServerURI";
		public const string UserNamePrefName = "UserName";
		public const string PasswordPrefName = "Password";
		public const string WorkspacePrefName = "Workspace";
        public const string P4ConfigPrefName = "UseP4Config";
		public const string DLLLocationPrefName = "DLLLocation";
		public const string ConfigurationStateName = "ConfigurationState";
		public const string PerforceEnabledPrefName = "Enabled";
		public const string UnityVSSupportPrefName = "UnityVSSupport";
		public const string IncludeProjectFilesPrefName = "IncludeProjectFiles";
		public const string IncludeSolutionFilesPrefName = "IncludeSolutionFiles";
		public const string ShowPathsPrefName = "ShowPaths";
		public const string AskBeforeCheckoutPrefName = "AskBeforeCheckout";
		public const string DisplayStatusIconsPrefName = "DisplayStatusIcons";
		public const string HostnamePrefName = "Hostname";
		public const string DiffToolPathnamePrefName = "DiffToolPathname";
		public const string DisplayP4TimingsPrefName = "DisplayTimings";
		public const string DisplayP4CommandsPrefName = "DisplayCommands";
		public const string CheckStatusForMenusPrefName = "CheckStatusForMenus";
		public const string CheckStatusForMenusMaxItemsPrefName = "CheckStatusForMenusMaxItems";
		public const string OperationBatchCountPrefName = "OperationBatchCount";
		public const string ConnectionTimeOutPrefName = "ConnectionTimeOut";
		public const string OverrideHostnamePrefName = "OverrideHostname";
		public const string WarnOnSpecialCharactersPrefName = "WarnOnSpecialCharacters";

		// Used to create controls
		static GUIContent _RevertSettings = new GUIContent("Revert", "Revert settings to previously saved value");
		static GUIContent _SaveSettings = new GUIContent("Save", "Saves the current settings");
		static GUILayoutOption _ButtonWidth = GUILayout.MaxWidth(50.0f);
		static GUILayoutOption _RevertSaveButtonWidth = GUILayout.MaxWidth(80.0f);
		static GUILayoutOption _LabelWidth = GUILayout.MaxWidth(300.0f);

        public static string p4configFile;

		// The current state of the configuration, whether it is valid to be used
		enum ConfigurationState
		{
			Unknown = 0,
			MetaFilesInvalid,
			MetaFilesValid,
            P4ConfigValid,
			ServerInvalid,
			ServerValid,
			UsernamePassInvalid,
			UsernamePassValid,
			WorkspaceInvalid,
			WorkspaceValid,
			ProjectRootInvalid,
			ProjectRootValid,
			SettingsValid,
		}

		// The current state of the configuration, whether it is valid to be used
		static ConfigurationState _CurrentState = ConfigurationState.Unknown;

		// Toggles the extra options
		int _FrameIndex = 0;
		bool _SettingsChanged = false;
		bool _Repaint = false;

		/// <summary>
		/// Set some default configuration values
		/// </summary>
		static Config()
		{
			// Set some default values
			ServerURI = "YourServer:1666";
			Username = "YourUsername";
			Password = "";
			Workspace = "Username_Workspace_Machine";
            UseP4Config = true;
			DLLLocation = "P4Connect/Editor/";
            UseP4Config = true;
			UnityVSSupport = false;
			PerforceEnabled = true;
			IncludeProjectFiles = true;
			IncludeSolutionFiles = true;
			ShowPaths = false;
			AskBeforeCheckout = false;
			DisplayStatusIcons = true;
			Hostname = "";
			Charset = "";
			DiffToolPathname = "";
			DisplayP4Timings = false;
			DisplayP4Commands = false;
			CheckStatusForMenus = true;
			CheckStatusForMenusMaxItems = 10;
			ConnectionTimeOut = 30;
			ProjectRoot = "";
			WarnOnSpecialCharacters = true;
		}

		// Add menu item to show the configuration panel
		[MenuItem("Edit/Perforce Settings", false, 300)]
		public static void ShowWindow()
		{
			// Show existing window instance. If one doesn't exist, make one.
			Config window = EditorWindow.GetWindow<Config>("P4 Settings");
			window.name = "P4 Settings";
			window.title = "P4 Settings";
			window.minSize = new UnityEngine.Vector2(500.0f, 500.0f);
		}

		/// <summary>
		/// Static Constructor, reads connection settings from Prefs at least once
		/// </summary>
		public static void Initialize()
		{
			ReadPrefs();

			CachedSerializationMode = EditorSettings.serializationMode;
		}

		/// <summary>
		/// Forces the config to be invalid, usually after an error
		/// </summary>
		public static void NeedToCheckSettings()
		{
			_CurrentState = ConfigurationState.Unknown;
			Debug.LogWarning("P4Connect - Perforce integration is enabled but inactive. Go to Edit->Perforce Settings to update your settings");
		}

		/// <summary>
		/// Checks the that settings are valid
		/// </summary>
		public static void CheckSettings()
		{
			if (PerforceEnabled)
			{
				// We only display a message when something changes
				ConfigurationState prevState = _CurrentState;
				_CurrentState = ConfigurationState.Unknown;

				// Check the config
				UpdateConfigState();

				// And notify user
				if (_CurrentState != prevState)
				{
					Icons.UpdateDisplay();
					if (_CurrentState != ConfigurationState.SettingsValid)
					{
						Debug.LogWarning("P4Connect - Perforce integration is enabled but inactive. Go to Edit->Perforce Settings to update your settings");
					}
					else if (prevState != ConfigurationState.SettingsValid)
					{
						Debug.Log("P4Connect - Perforce Integration is Active");
					}
				}

				if (_CurrentState == ConfigurationState.SettingsValid)
				{
					SetProjectRootDirectory();
				}
			}
		}

		public static void SetProjectRootDirectory()
		{
			if (Config.ValidConfiguration)
			{
				Engine.PerformConnectionOperation(con =>
					{
						var spec = FileSpec.LocalSpec(System.IO.Path.Combine(Main.RootPath, "..."));
						var mappings = con.P4Client.GetClientFileMappings(spec);
						if (mappings != null && mappings.Count > 0)
						{
							string clientProjectRoot = mappings[0].ClientPath.Path;
							int projectRootOffset = clientProjectRoot.ToLowerInvariant().IndexOf(Config.Workspace.ToLowerInvariant());
							if (projectRootOffset != -1)
							{
								ProjectRoot = clientProjectRoot.Substring(projectRootOffset + Config.Workspace.Length);
								ProjectRoot = ProjectRoot.TrimStart(System.IO.Path.DirectorySeparatorChar, '/');
								if (ProjectRoot.EndsWith("..."))
									ProjectRoot = ProjectRoot.Substring(0, ProjectRoot.Length - 3);
								ProjectRoot = ProjectRoot.TrimEnd(System.IO.Path.DirectorySeparatorChar, '/');
								ProjectRoot = ProjectRoot.Replace('/', System.IO.Path.DirectorySeparatorChar);
							}
							else
							{
								Debug.LogError("P4Connect - Your Project does not appear to be under your workspace root.");
							}
						}
					});
			}
		}

		/// <summary>
		/// Updates the current configuration state after checking all the settings
		/// </summary>
		public static void UpdateConfigState()
		{
			switch (_CurrentState)
			{
				case ConfigurationState.Unknown:
					// The unknown state starts by checking the meta files
					goto case ConfigurationState.MetaFilesInvalid;
				case ConfigurationState.MetaFilesInvalid:
					if (P4Connect.VerifySettings.CheckMetaFiles())
					{
						// Meta files are valid, move on
						_CurrentState = ConfigurationState.MetaFilesValid;
						goto case ConfigurationState.MetaFilesValid;
					}
					else
					{
						// Stay in this state
						_CurrentState = ConfigurationState.MetaFilesInvalid;
						break;
					}
                case ConfigurationState.MetaFilesValid:
                    goto case ConfigurationState.P4ConfigValid;
                case ConfigurationState.P4ConfigValid:
                    {
                        if (UseP4Config)
                        {
                            p4configFile = FindP4ConfigFile();
                            if (p4configFile != null)
                                LoadP4ConfigFile(p4configFile);
                        }
                        // in either case, move on
                        _CurrentState = ConfigurationState.ServerInvalid;
                        goto case ConfigurationState.ServerInvalid;
                    }
				case ConfigurationState.ServerInvalid:
					if (P4Connect.VerifySettings.CheckServerURI())
					{
						// Server is valid, move on
						_CurrentState = ConfigurationState.ServerValid;
						goto case ConfigurationState.ServerValid;
					}
					else
					{
						// Stay here
						_CurrentState = ConfigurationState.ServerInvalid;
						break;
					}
				case ConfigurationState.ServerValid:
					goto case ConfigurationState.UsernamePassInvalid;
				case ConfigurationState.UsernamePassInvalid:
					if (P4Connect.VerifySettings.CheckUsernamePassword())
					{
						// Username / Password is valid, move on
						_CurrentState = ConfigurationState.UsernamePassValid;
						goto case ConfigurationState.UsernamePassValid;
					}
					else
					{
						// Stay here
						_CurrentState = ConfigurationState.UsernamePassInvalid;
						break;
					}
				case ConfigurationState.UsernamePassValid:
					goto case ConfigurationState.WorkspaceInvalid;
				case ConfigurationState.WorkspaceInvalid:
					if (P4Connect.VerifySettings.CheckWorkspace())
					{
						// Workspace is valid
						_CurrentState = ConfigurationState.WorkspaceValid;
						goto case ConfigurationState.WorkspaceValid;
					}
					else
					{
						// Stay here
						_CurrentState = ConfigurationState.WorkspaceInvalid;
						break;
					}
				case ConfigurationState.WorkspaceValid:
					goto case ConfigurationState.ProjectRootInvalid;
				case ConfigurationState.ProjectRootInvalid:
					if (P4Connect.VerifySettings.CheckProjectRoot())
					{
						// Root is valid
						_CurrentState = ConfigurationState.ProjectRootValid;
						goto case ConfigurationState.ProjectRootValid;
					}
					else
					{
						// Stay here
						_CurrentState = ConfigurationState.ProjectRootInvalid;
						break;
					}
				case ConfigurationState.ProjectRootValid:
					_CurrentState = ConfigurationState.SettingsValid;
					goto case ConfigurationState.SettingsValid;
				case ConfigurationState.SettingsValid:
					break;
			}

			// Clean up the connection
			PerforceConnection.ForceCloseConnection();
		}

		/// <summary>
		/// Called by Unity when the windows needs to be updated 
		/// </summary>
		void OnGUI()
		{
			// This will store whether the user requested to check the settings
			bool checkSettings = false;

			// Add a global checkbox to turn perforce integration on/off
			bool newPerforceEnabled = EditorGUILayout.BeginToggleGroup("Enable Perforce Integration", PerforceEnabled);
			if (newPerforceEnabled != PerforceEnabled)
			{
				PerforceEnabled = newPerforceEnabled;

                PendingChanges.UpdateDisplay();
                Icons.UpdateDisplay();
				_SettingsChanged = true;
			}

			if (PerforceEnabled)
			{
				float textWidth = 250.0f;
				float secondtextWidth = 200.0f;

				int maxFrameCount = 2; // seems to be the right number of repaints needed to display something
				if (_FrameIndex < maxFrameCount)
				{
					EditorGUILayout.HelpBox("Please Wait! Checking Perforce Settings. This can take up to 20 seconds...", MessageType.Info);

					if (Event.current.type == EventType.Repaint)
					{
						++_FrameIndex;
						_Repaint = true;
					}

					if (_FrameIndex == maxFrameCount)
					{
						// Force update the config state at least once
						ConfigurationState oldState = _CurrentState;
						_CurrentState = ConfigurationState.Unknown;
						UpdateConfigState();
						if (_CurrentState != oldState)
						{
							_SettingsChanged = true;
						}
					}
				}
				else
				{
					GUILayout.Label("Connection Settings", EditorStyles.boldLabel);
					if (_CurrentState >= ConfigurationState.MetaFilesValid)
					{
                        EditorGUILayout.BeginHorizontal();
                        {
                            EditorGUILayout.BeginVertical();
                            // The edit field for the server
                            bool newUseP4Config = EditorGUILayout.Toggle("\tUse P4Config", UseP4Config);
                            if (newUseP4Config != UseP4Config)
                            {
                                if (newUseP4Config == true)
                                {
                                    p4configFile = FindP4ConfigFile();
                                    if (p4configFile != null)
                                        LoadP4ConfigFile(p4configFile);
                                }
                                UseP4Config = newUseP4Config;
                                _CurrentState = ConfigurationState.P4ConfigValid;
                                _SettingsChanged = true;
                            }
                            EditorGUILayout.EndVertical();

                            EditorGUI.BeginDisabledGroup(UseP4Config);
                            {
                                if (string.IsNullOrEmpty(p4configFile))
                                {
                                    GUILayout.Label("Not Found");
                                }
                                else
                                {
                                    GUILayout.Label(Path.GetFullPath(p4configFile));  // Show the name of the config file
                                }
                            }
                            EditorGUI.EndDisabledGroup();
                        }
                        EditorGUILayout.EndHorizontal();
						// Don't let the user change any of the remaining settings unless the DLL is valid
						EditorGUILayout.BeginHorizontal();
						{
							EditorGUILayout.BeginVertical();
							// The edit field for the server
							string newServerURI = EditorGUILayout.TextField("\tServer URI", ServerURI);
							if (newServerURI != ServerURI)
							{
								ServerURI = newServerURI;
								_CurrentState = ConfigurationState.MetaFilesValid;
								_SettingsChanged = true;
							}
							EditorGUILayout.EndVertical();
							// The button to verify it
							bool serverValid = _CurrentState >= ConfigurationState.ServerValid;
							EditorGUI.BeginDisabledGroup(serverValid);
							{
								if (GUILayout.Button(serverValid ? "Valid!" : "Verify", EditorStyles.miniButton, _ButtonWidth))
								{
									checkSettings = true;
								}
							}
							EditorGUI.EndDisabledGroup();
						}
						EditorGUILayout.EndHorizontal();

						if (_CurrentState == ConfigurationState.ServerInvalid)
						{
							EditorGUILayout.HelpBox("Invalid Server URI", MessageType.Error);
						}

						EditorGUI.BeginDisabledGroup(_CurrentState < ConfigurationState.ServerValid);
						{
							EditorGUILayout.BeginHorizontal();
							{
								EditorGUILayout.BeginVertical();
								// The edit field for the username
								string newUsername = EditorGUILayout.TextField("\tUsername", Username);
								if (newUsername != Username)
								{
									Username = newUsername;
									_CurrentState = ConfigurationState.ServerValid;
									_SettingsChanged = true;
								}

								// The edit field for the password
								string newPassword = EditorGUILayout.PasswordField("\tPassword", Password);
								if (newPassword != Password)
								{
									Password = newPassword;
									_CurrentState = ConfigurationState.ServerValid;
									_SettingsChanged = true;
								}
								EditorGUILayout.EndVertical();
								// And the button to verify it
								bool passwordValid = _CurrentState >= ConfigurationState.UsernamePassValid;
								EditorGUI.BeginDisabledGroup(passwordValid);
								{
									if (GUILayout.Button(passwordValid ? "Valid!" : "Verify", EditorStyles.miniButton, _ButtonWidth))
									{
										checkSettings = true;
									}
								}
								EditorGUI.EndDisabledGroup();
							}
							EditorGUILayout.EndHorizontal();

							if (_CurrentState == ConfigurationState.UsernamePassInvalid)
							{
								EditorGUILayout.HelpBox("Invalid Username / Password", MessageType.Error);
							}

							EditorGUI.BeginDisabledGroup(_CurrentState < ConfigurationState.UsernamePassValid);
							{
								EditorGUILayout.BeginHorizontal();
								{
									// The edit field for the workspace
									string newWorkspace = EditorGUILayout.TextField("\tWorkspace", Workspace);
									if (newWorkspace != Workspace)
									{
										Workspace = newWorkspace;
										_CurrentState = ConfigurationState.UsernamePassValid;
										_SettingsChanged = true;
									}

									// And the check button
									bool workspaceValid = _CurrentState >= ConfigurationState.ProjectRootValid;
									EditorGUI.BeginDisabledGroup(workspaceValid);
									{
										if (GUILayout.Button(workspaceValid ? "Valid!" : "Verify", EditorStyles.miniButton, _ButtonWidth))
										{
											checkSettings = true;
										}
									}
									EditorGUI.EndDisabledGroup();
								}
								EditorGUILayout.EndHorizontal();

								if (_CurrentState == ConfigurationState.WorkspaceInvalid)
								{
									EditorGUILayout.HelpBox("Invalid Workspace", MessageType.Error);
								}

								if (_CurrentState == ConfigurationState.ProjectRootInvalid)
								{
									// The project isn't under the workspace root
									string perforcePath = "//" + Workspace + "/...";
									string rootPath = P4Connect.Main.RootPath;
									EditorGUILayout.HelpBox("Invalid Workspace. The client path:\n" +
										"\t" + perforcePath + "\n" +
										"maps to this folder:\n" +
										"\t" + VerifySettings.LastWorkspaceMapping + "\n" +
										"which is not a parent directory of the project's root:\n" +
										"\t" + rootPath, MessageType.Error);
								}
							}
							EditorGUI.EndDisabledGroup();
						}
						EditorGUI.EndDisabledGroup();

						GUILayout.Label("Interface", EditorStyles.boldLabel);
						EditorGUILayout.BeginHorizontal();
						GUILayout.Label("\tDisplay Status Icons", GUILayout.Width(textWidth));
						bool newDisplayIcons = EditorGUILayout.Toggle(DisplayStatusIcons, GUILayout.Width(16.0f));
						if (newDisplayIcons != DisplayStatusIcons)
						{
							DisplayStatusIcons = newDisplayIcons;
							_SettingsChanged = true;
							Icons.UpdateDisplay();
							PendingChanges.UpdateDisplay();
						}
						EditorGUILayout.EndHorizontal();
						EditorGUILayout.BeginHorizontal();
						GUILayout.Label("\tShow File Paths in Console", GUILayout.Width(textWidth));
						bool newShowPaths = EditorGUILayout.Toggle(ShowPaths, GUILayout.Width(16.0f));
						if (newShowPaths != ShowPaths)
						{
							ShowPaths = newShowPaths;
							_SettingsChanged = true;
						}
						EditorGUILayout.EndHorizontal();
						EditorGUILayout.BeginHorizontal();
						string newDiffToolPathname = EditorGUILayout.TextField("\tDiff Tool Executable", DiffToolPathname);
						if (newDiffToolPathname != DiffToolPathname)
						{
							DiffToolPathname = newDiffToolPathname;
							_SettingsChanged = true;
						}
						if (GUILayout.Button("Browse...", EditorStyles.miniButton, GUILayout.Width(80.0f)))
						{
							GUI.FocusControl("");
							DiffToolPathname = EditorUtility.OpenFilePanel("Choose Diff Tool Executable", System.Environment.GetFolderPath(System.Environment.SpecialFolder.ProgramFiles), "");
							_SettingsChanged = true;
						}
						EditorGUILayout.EndHorizontal();

						GUILayout.Label("Behaviour", EditorStyles.boldLabel);
						EditorGUILayout.BeginHorizontal();
						GUILayout.Label("\tAsk before checkout on edit", GUILayout.Width(textWidth));
						bool newAskBeforeCheckout = EditorGUILayout.Toggle(AskBeforeCheckout, GUILayout.Width(16.0f));
						if (newAskBeforeCheckout != AskBeforeCheckout)
						{
							AskBeforeCheckout = newAskBeforeCheckout;
							_SettingsChanged = true;
						}
						EditorGUILayout.EndHorizontal();
						EditorGUILayout.BeginHorizontal();
						GUILayout.Label("\tShow warning when adding files with reserved characters (@#*%)", GUILayout.Width(textWidth));
						bool newWarnOnSpecialChar = EditorGUILayout.Toggle(WarnOnSpecialCharacters, GUILayout.Width(16.0f));
						if (newWarnOnSpecialChar != WarnOnSpecialCharacters)
						{
							WarnOnSpecialCharacters = newWarnOnSpecialChar;
							_SettingsChanged = true;
						}
						EditorGUILayout.EndHorizontal();
						EditorGUILayout.BeginHorizontal();
						GUILayout.Label("\tInclude Solution Files", GUILayout.Width(textWidth));
						bool newIncludeSolutionFiles = EditorGUILayout.Toggle(IncludeSolutionFiles, GUILayout.Width(16.0f));
						if (newIncludeSolutionFiles != IncludeSolutionFiles)
						{
							IncludeSolutionFiles = newIncludeSolutionFiles;
							_SettingsChanged = true;
						}
						EditorGUILayout.EndHorizontal();
						EditorGUILayout.BeginHorizontal();
						GUILayout.Label("\tInclude Projects Files", GUILayout.Width(textWidth));
						bool newIncludeProjectFiles = EditorGUILayout.Toggle(IncludeProjectFiles, GUILayout.Width(16.0f));
						if (newIncludeProjectFiles != IncludeProjectFiles)
						{
							IncludeProjectFiles = newIncludeProjectFiles;
							_SettingsChanged = true;
						}
						EditorGUILayout.EndHorizontal();
						EditorGUILayout.BeginHorizontal();
						GUILayout.Label("\tIntegrate with UnityVS", GUILayout.Width(textWidth));
						bool newUnityVSSupport = EditorGUILayout.Toggle(UnityVSSupport, GUILayout.Width(16.0f));
						if (newUnityVSSupport != UnityVSSupport)
						{
							UnityVSSupport = newUnityVSSupport;
							_SettingsChanged = true;
						}
						EditorGUILayout.EndHorizontal();

						GUILayout.Label("Advanced", EditorStyles.boldLabel);
						EditorGUILayout.BeginHorizontal();
						GUILayout.Label("\tOverride P4HOST variable", GUILayout.Width(textWidth));
						bool newOverrideP4Host = EditorGUILayout.Toggle(OverrideHostname, GUILayout.Width(16.0f));
						if (newOverrideP4Host != OverrideHostname)
						{
							OverrideHostname = newOverrideP4Host;
							_CurrentState = ConfigurationState.MetaFilesValid;
							_SettingsChanged = true;
						}
						EditorGUI.BeginDisabledGroup(!OverrideHostname);
						GUILayout.Label("Hostname", GUILayout.Width(secondtextWidth));
						string newHost = EditorGUILayout.TextField(Hostname, GUILayout.Width(120.0f));
						if (newHost != Hostname)
						{
							Hostname = newHost;
							_CurrentState = ConfigurationState.MetaFilesValid;
							_SettingsChanged = true;
						}
						EditorGUI.EndDisabledGroup();
						EditorGUILayout.EndHorizontal();
						EditorGUILayout.BeginHorizontal();
						GUILayout.Label("\tOverride P4CHARSET variable", GUILayout.Width(textWidth));
						bool newOverrideCharset = EditorGUILayout.Toggle(OverrideCharset, GUILayout.Width(16.0f));
						if (newOverrideCharset != OverrideCharset)
						{
							OverrideCharset = newOverrideCharset;
							_CurrentState = ConfigurationState.ServerValid;
							_SettingsChanged = true;
						}
						EditorGUI.BeginDisabledGroup(!OverrideCharset);
						GUILayout.Label("Charset", GUILayout.Width(secondtextWidth));
						string newCharset = EditorGUILayout.TextField(Charset, GUILayout.Width(120.0f));
						if (newCharset != Charset)
						{
							Charset = newCharset;
							_CurrentState = ConfigurationState.ServerValid;
							_SettingsChanged = true;
						}
						EditorGUI.EndDisabledGroup();
						EditorGUILayout.EndHorizontal();
						EditorGUILayout.BeginHorizontal();
						GUILayout.Label("\tGray out invalid menu options", GUILayout.Width(textWidth));
						bool newCheckStatus = EditorGUILayout.Toggle(CheckStatusForMenus, GUILayout.Width(16.0f));
						if (newCheckStatus != CheckStatusForMenus)
						{
							CheckStatusForMenus = newCheckStatus;
							_SettingsChanged = true;
						}
						EditorGUI.BeginDisabledGroup(!CheckStatusForMenus);
						GUILayout.Label("Don't check if more than", GUILayout.Width(secondtextWidth));
						int newCheckStatusCount = EditorGUILayout.IntField(CheckStatusForMenusMaxItems, GUILayout.Width(40.0f));
						if (newCheckStatusCount != CheckStatusForMenusMaxItems)
						{
							CheckStatusForMenusMaxItems = newCheckStatusCount;
							_SettingsChanged = true;
						}
						GUILayout.Label("files selected");
						GUILayout.FlexibleSpace();
						EditorGUI.EndDisabledGroup();
						EditorGUILayout.EndHorizontal();
						EditorGUILayout.BeginHorizontal();
						GUILayout.Label("\tClose Perforce connection after", GUILayout.Width(textWidth));
						int newTimeOut = EditorGUILayout.IntField(ConnectionTimeOut, GUILayout.Width(40.0f));
						if (newTimeOut != ConnectionTimeOut)
						{
							ConnectionTimeOut = newTimeOut;
							_SettingsChanged = true;
						}
						GUILayout.Label("seconds");
						GUILayout.FlexibleSpace();
						EditorGUILayout.EndHorizontal();
						EditorGUILayout.BeginHorizontal();
						GUILayout.Label("\tDisplay P4 Timings", GUILayout.Width(textWidth));
						bool newDisplayTimings = EditorGUILayout.Toggle(DisplayP4Timings, GUILayout.Width(16.0f));
						if (newDisplayTimings != DisplayP4Timings)
						{
							DisplayP4Timings = newDisplayTimings;
							_SettingsChanged = true;
						}
						EditorGUILayout.EndHorizontal();
						EditorGUILayout.BeginHorizontal();
						GUILayout.Label("\tEcho P4 Commands", GUILayout.Width(textWidth));
						bool newDisplayCommands = EditorGUILayout.Toggle(DisplayP4Commands, GUILayout.Width(16.0f));
						if (newDisplayCommands != DisplayP4Commands)
						{
							DisplayP4Commands = newDisplayCommands;
							_SettingsChanged = true;
						}
						EditorGUILayout.EndHorizontal();
					}
					else
					{
						EditorGUILayout.HelpBox("You must set the Editor Version Control to \"Meta Files\" under Edit->Project Settings->Editor", MessageType.Info);
						if (VerifySettings.CheckMetaFiles())
						{
							_SettingsChanged = true;
							checkSettings = true;
						}
					}
				}

				if (checkSettings)
				{
					ConfigurationState prevState = _CurrentState;
					_CurrentState = ConfigurationState.Unknown;

					// Check the config
					CheckSettings();

					// And notify user
					if (_CurrentState != prevState)
					{
						Icons.UpdateDisplay();
						PendingChanges.UpdateDisplay();
					}
				}
			}
			EditorGUILayout.EndToggleGroup();

			// Info message
			GUILayout.FlexibleSpace();

			if (PerforceEnabled && _CurrentState != ConfigurationState.SettingsValid)
			{
				EditorGUILayout.HelpBox("Perforce Integration is inactive. Please Verify your Settings!", MessageType.Warning);
			}
			else if (_SettingsChanged)
			{
				if (PerforceEnabled)
				{
					EditorGUILayout.HelpBox("Perforce Integration is active.", MessageType.Info);
				}
				else
				{
					EditorGUILayout.HelpBox("Perforce Integration is turned off.", MessageType.Info);
				}

				WritePrefs();
			}

			EditorGUILayout.BeginHorizontal();
			GUILayout.FlexibleSpace();
			GUILayout.Label("P4Connect", EditorStyles.miniLabel);
			if (GUILayout.Button("Visit Website", EditorStyles.miniButton))
			{
				System.Diagnostics.Process.Start("http://www.perforce.com/perforce/doc.current/manuals/p4connectguide/index.html");
			}
			EditorGUILayout.EndHorizontal();
		}

		void OnInspectorUpdate()
		{
			if (_Repaint)
			{
				_Repaint = false;
				Repaint();
			}
		}

		// Utility method to read connection prefs from the registry
		public static void ReadPrefs()
		{
			// Check if the keys exist, and if so, read the values out
			// Otherwise, leave the default values
			if (HasPref(ServerURIPrefName))
				ServerURI = GetPrefString(ServerURIPrefName);
			if (HasPref(UserNamePrefName))
				Username = GetPrefString(UserNamePrefName);
			if (HasPref(PasswordPrefName))
				Password = Secure.DecryptString(GetPrefString(PasswordPrefName));
			if (HasPref(WorkspacePrefName))
				Workspace = GetPrefString(WorkspacePrefName);
            if (HasPref(P4ConfigPrefName))
				UseP4Config = GetPrefBool(P4ConfigPrefName);
			if (HasPref(DLLLocationPrefName))
				DLLLocation = GetPrefString(DLLLocationPrefName);
			if (HasPref(ConfigurationStateName))
			{
				_CurrentState = (ConfigurationState)GetPrefInt(ConfigurationStateName);
				if (_CurrentState > ConfigurationState.SettingsValid)
				{
					_CurrentState = ConfigurationState.Unknown;
				}
			}
			if (HasPref(PerforceEnabledPrefName))
				PerforceEnabled = GetPrefBool(PerforceEnabledPrefName);
			if (HasPref(UnityVSSupportPrefName))
				UnityVSSupport = GetPrefBool(UnityVSSupportPrefName);
			if (HasPref(IncludeProjectFilesPrefName))
				IncludeProjectFiles = GetPrefBool(IncludeProjectFilesPrefName);
			if (HasPref(IncludeSolutionFilesPrefName))
				IncludeSolutionFiles = GetPrefBool(IncludeSolutionFilesPrefName);
			if (HasPref(ShowPathsPrefName))
				ShowPaths = GetPrefBool(ShowPathsPrefName);
			if (HasPref(AskBeforeCheckoutPrefName))
				AskBeforeCheckout = GetPrefBool(AskBeforeCheckoutPrefName);
			if (HasPref(DisplayStatusIconsPrefName))
				DisplayStatusIcons = GetPrefBool(DisplayStatusIconsPrefName);
			if (HasPref(HostnamePrefName))
				Hostname = GetPrefString(HostnamePrefName);
			if (HasPref(DiffToolPathnamePrefName))
				DiffToolPathname = GetPrefString(DiffToolPathnamePrefName);
			if (HasPref(DisplayP4TimingsPrefName))
				DisplayP4Timings = GetPrefBool(DisplayP4TimingsPrefName);
			if (HasPref(DisplayP4CommandsPrefName))
				DisplayP4Commands = GetPrefBool(DisplayP4CommandsPrefName);
			if (HasPref(CheckStatusForMenusPrefName))
				CheckStatusForMenus = GetPrefBool(CheckStatusForMenusPrefName);
			if (HasPref(CheckStatusForMenusMaxItemsPrefName))
				CheckStatusForMenusMaxItems = GetPrefInt(CheckStatusForMenusMaxItemsPrefName);
			if (HasPref(OperationBatchCountPrefName))
				OperationBatchCount = GetPrefInt(OperationBatchCountPrefName);
			if (HasPref(ConnectionTimeOutPrefName))
				ConnectionTimeOut = GetPrefInt(ConnectionTimeOutPrefName);
			if (HasPref(OverrideHostnamePrefName))
				OverrideHostname = GetPrefBool(OverrideHostnamePrefName);
			if (HasPref(WarnOnSpecialCharactersPrefName))
				WarnOnSpecialCharacters = GetPrefBool(WarnOnSpecialCharactersPrefName);
			
			// Notify users that prefs changed
			if (PrefsChanged != null)
				PrefsChanged();
		}

		// Utility method to write our the connection prefs to the registry
		public static void WritePrefs()
		{
			SetPrefString(ServerURIPrefName, ServerURI);
			SetPrefString(UserNamePrefName, Username);
			SetPrefString(PasswordPrefName, Secure.EncryptString(Password));
			SetPrefString(WorkspacePrefName, Workspace);
            SetPrefBool(P4ConfigPrefName, UseP4Config);
			SetPrefString(DLLLocationPrefName, DLLLocation);
			SetPrefInt(ConfigurationStateName, (int)_CurrentState);
			SetPrefBool(PerforceEnabledPrefName, PerforceEnabled);
			SetPrefBool(UnityVSSupportPrefName, UnityVSSupport);
			SetPrefBool(IncludeProjectFilesPrefName, IncludeProjectFiles);
			SetPrefBool(IncludeSolutionFilesPrefName, IncludeSolutionFiles);
			SetPrefBool(ShowPathsPrefName, ShowPaths);
			SetPrefBool(AskBeforeCheckoutPrefName, AskBeforeCheckout);
			SetPrefBool(DisplayStatusIconsPrefName, DisplayStatusIcons);
			SetPrefString(HostnamePrefName, Hostname);
			SetPrefString(DiffToolPathnamePrefName, DiffToolPathname);
			SetPrefBool(DisplayP4TimingsPrefName, DisplayP4Timings);
			SetPrefBool(DisplayP4CommandsPrefName, DisplayP4Commands);
			SetPrefBool(CheckStatusForMenusPrefName, CheckStatusForMenus);
			SetPrefInt(CheckStatusForMenusMaxItemsPrefName, CheckStatusForMenusMaxItems);
			SetPrefInt(OperationBatchCountPrefName, OperationBatchCount);
			SetPrefInt(ConnectionTimeOutPrefName, ConnectionTimeOut);
			SetPrefBool(OverrideHostnamePrefName, OverrideHostname);
			SetPrefBool(WarnOnSpecialCharactersPrefName, WarnOnSpecialCharacters);

			// Notify users that prefs changed
			if (PrefsChanged != null)
				PrefsChanged();
		}

		static string GetFullPrefName(string aPrefName)
		{
			return "P4Connect_" + Main.ProjectName + "_" + aPrefName;
		}

		static bool HasPref(string aPrefName)
		{
			return EditorPrefs.HasKey(GetFullPrefName(aPrefName));
		}

		static void SetPrefString(string aPrefName, string aPref)
		{
			EditorPrefs.SetString(GetFullPrefName(aPrefName), aPref);
		}

		static void SetPrefInt(string aPrefName, int aPref)
		{
			EditorPrefs.SetInt(GetFullPrefName(aPrefName), aPref);
		}

		static void SetPrefBool(string aPrefName, bool aPref)
		{
			EditorPrefs.SetBool(GetFullPrefName(aPrefName), aPref);
		}

		static string GetPrefString(string aPrefName)
		{
			return EditorPrefs.GetString(GetFullPrefName(aPrefName));
		}

		static int GetPrefInt(string aPrefName)
		{
			return EditorPrefs.GetInt(GetFullPrefName(aPrefName));
		}

		static bool GetPrefBool(string aPrefName)
		{
			return EditorPrefs.GetBool(GetFullPrefName(aPrefName));
		}

		public static SerializationMode CachedSerializationMode
		{
			get; private set;
		}

        public static string FindP4ConfigFile()
        {
            string directoryName;
           
            string p4config = Environment.GetEnvironmentVariable("P4CONFIG");

            if (p4config != null)
            {
                string path = Application.dataPath;
                while (path != null)
                {
                    directoryName = Path.GetDirectoryName(path);
                    string[] files = System.IO.Directory.GetFiles(directoryName, p4config);
                    if (files.Count() > 0)
                    {
                        return files[0];
                    }
                    path = directoryName;
                }
            }
           
            return null;
        }
        
        public static void LoadP4ConfigFile(string path)
        {
            string line;
            char[] equalsChars = { '=' };

            System.IO.StreamReader file = new System.IO.StreamReader(path);
            while ((line = file.ReadLine()) != null)
            {
                string[] segments = line.Split(equalsChars);
                if (segments.Length >= 2)
                {
                    string key = segments[0];
                    string val = segments[1];
                    // Debug.Log("Key: " + key);
                    // Debug.Log("Value: " + val);
                    switch (segments[0])
                    {
                        case "P4PORT":
                            {
                                ServerURI = val;
                            }
                            break;
                        case "P4USER":
                            {
                                Username = val;
                            }
                            break;
                        case "P4CLIENT":
                            {
                                Workspace = val;
                            }
                            break;
                        case "P4PASSWD":
                            {
                                Password = val;
                            }
                            break;
                    }
                }
            }
            file.Close();
        }
	}
}