using CPE.App.Web.Code;
using System;
using System.Collections.Specialized;
using System.Net;
using System.Text;
using System.Text.RegularExpressions;
using System.Web;
using System.Xml;

namespace CPE.App.Web.Connect {

	/// <summary>
	/// Handles a basic request to the Connect service.
	/// </summary>
	public class Request {

		// Private
		private XmlDocument _xmlResults;
		private NameValueCollection _parameters = new NameValueCollection();
		private Session _session = new Session();

		private static string CleanHost(string url) {
			if (!url.StartsWith("http"))
				url = "http://" + url;
			return url.ToLower();
		}

		/// <summary>
		/// The action to perform against the service.
		/// </summary>
		/// <example>common-info</example>
		public string Action { get; set; }

		/// <summary>
		/// The parameters to pass with the action for this request.
		/// </summary>
		public NameValueCollection Parameters {
			get {
				return _parameters;
			}
			set {
				_parameters = value;
			}
		}

		/// <summary>
		/// The Session settings to contact the service.
		/// </summary>
		public Session Session {
			get {
				return _session;
			}
			set {
				_session = value;
			}
		}

		/// <summary>
		/// Returns the raw XmlDocument that was returned from the service.
		/// </summary>
		public XmlDocument XmlResults { get { return _xmlResults; }}

		/// <summary>
		/// Returns the current status of the request.
		/// </summary>
		public Status Status {
			get {
				
				// Default
				Status status = Status.Unknown;

				// Has a response been received?
				if(HasResponse) {

					// Parse the response for the status
					string statusCode = _xmlResults.SelectSingleNode("//status").Attributes["code"].Value;
					
					switch(statusCode)  {
						case "ok": 
							status = Status.OK;
							break;
						case "invalid":
							status = Status.Invalid;
							break;
						case "no-access":
							status = Status.NoAccess;
							break;
						case "no-data":
							status = Status.NoData;
							break;
						case "too-much-data":
							status = Status.TooMuchData;
							break;
					}
				}

				return status;
			}
		}

		/// <summary>
		/// Returns whether a response has been received for this request.
		/// </summary>
		public bool HasResponse { get { return (_xmlResults != null); } }

		/// <summary>
		/// Returns the response headers for this request. Useful for retrieving the session key from a login request.
		/// </summary>
		public WebHeaderCollection ResponseHeaders { get; private set; }

		/// <summary>
		/// Initializes an empty request.
		/// </summary>
		public Request() { }

		/// <summary>
		/// Initializes a request.
		/// </summary>
		/// <param name="hostname">The hostname to connect to.</param>
		/// <param name="action">The action to perform.</param>
		public Request(string hostname, string action) {
			Session.Hostname = hostname;
			Action = action;
		}

		/// <summary>
		/// Initializes the request.
		/// </summary>
		/// <param name="session">The session object to connect with.</param>
		/// <param name="action">The action to perform.</param>
		public Request(Session session, string action) {
			Session = session;
			Action = action;
		}


		private string _url = null;
		public string Url
		{
			get
			{
				return _url;
			}
		}

		/// <summary>
		/// Sends the request to the service and retrieves the results.
		/// </summary>
		/// <returns>Returns true if the request came back or false if an exception was thrown.</returns>
		public virtual bool Execute() {

			try {

				// Example URL: http://connectpro41408666.acrobat.com/api/xml?action=common-info	

				// Build URL
				var host = CleanHost(Session.Hostname);
				var url = new StringBuilder(string.Format("{0}/api/xml?action={1}", host, Action));

				// Is a session key set?
				if(Session.SessionKey != null)
					Parameters.Add("session", Session.SessionKey);

				// Add parameters to querystring
				for(int i = 0; i < Parameters.Count; i++) {
					for(int x = 0; x < Parameters.GetValues(i).Length; x++) {
						url.AppendFormat("&{0}={1}", HttpUtility.UrlEncode(Parameters.Keys[i]), HttpUtility.UrlEncode(Parameters.GetValues(i)[x]));
					}
				}

				// Ignore SSL validation errors
				//ServicePointManager.ServerCertificateValidationCallback = IgnoreInvalidSSL;

				// Retrieve XML
				string xml = null;

				using(var request = new WebClient() { UseDefaultCredentials = true, Encoding = Encoding.UTF8 }) {

					// Is a proxy required?
					if(Session.Proxy != null)
						request.Proxy = new WebProxy(Session.Proxy, true) { UseDefaultCredentials = true };

					//Extensions.LogServiceCall("[Request][Execute]", String.Format("url = {0}", url.ToString()));

					try
					{
						// System.IO.File.AppendAllText("adobeconnect_log.txt", url.ToString() + Environment.NewLine);
					}
					catch
					{
					}

					// Download
					try
					{
						xml = request.DownloadString(url.ToString());
						ResponseHeaders = request.ResponseHeaders;
					}
					catch(Exception ex)
					{
						//var log = new ExceptionLogController();
						//log.AddLog(ex, ExceptionLogController.ExceptionLogType.GENERAL_EXCEPTION);
						//log.AddLog(new Exception(url.ToString()), ExceptionLogController.ExceptionLogType.GENERAL_EXCEPTION);
						Extensions.LogServiceError("[Request][Execute]", ex);
						goto theend;
					}
				}

				// Load XML
				_xmlResults = new XmlDocument();
				_xmlResults.LoadXml(xml);
				_url = url.ToString();
				
				return true;			
			}
			catch
			{
				
			}
			theend:
			_xmlResults = null;
			ResponseHeaders = null;
			return false;
		}

		/// <summary>
		/// Overrides the default vertifcation for SSL certificates so that they will always be accepted.
		/// </summary>
		private static bool IgnoreInvalidSsl(object sender, System.Security.Cryptography.X509Certificates.X509Certificate cert, System.Security.Cryptography.X509Certificates.X509Chain chain, System.Net.Security.SslPolicyErrors errors) {
			return true;
		}

		/// <summary>
		/// Returns the session key that is returned in the ResponseHeaders from Connect.
		/// </summary>
		/// <returns>The session key, if found. Returns an empty string if not found.</returns>
		public string ExtractSessionKey() {

			// Default to returning an empty string if the key isn't found
			string session = string.Empty;

			// Does the cookie header exist?
			if(ResponseHeaders != null && ResponseHeaders["Set-Cookie"] != null) {

				// Example session cookie
				// BREEZESESSION=Sbreez9u75m9zfau4pi8m8;HttpOnly;domain=.acrobat.com;path=/

				// Capture session key
				var regex = new Regex(@"BREEZESESSION=(?<session>\w*);");
				Match match = regex.Match(ResponseHeaders["Set-Cookie"]);

				if(match.Success)
					session = match.Groups["session"].Value;
			}

			return session;
		}
	}

	/// <summary>
	/// Specifies the status of the request.
	/// </summary>
	public enum Status {
		Unknown,
		OK,
		Invalid,
		NoAccess,
		NoData,
		TooMuchData
	}

	public static class ScoTypes
	{
		public enum Types
		{
			Archive,
			Attachment,
			Authorware,
			Captivate,
			Content,
			Course,
			Curriculum,
			Event,
			ExternalEvent,
			Flv,
			Folder,
			Image,
			Link,
			Meeting,
			Presentation,
			Producer,
			Session,
			Swf,
			Tree,
			Unknown
		}

		public static Types TryParse(string type)
		{
			try
			{
				switch (type)
				{
					case "archive":
						return Types.Archive;
					case "attachment":
						return Types.Attachment;
					case "authorware":
						return Types.Authorware;
					case "captivate":
						return Types.Captivate;
					case "content":
						return Types.Content;
					case "course":
						return Types.Course;
					case "curriculum":
						return Types.Curriculum;
					case "event":
						return Types.Event;
					case "external-event":
						return Types.ExternalEvent;
					case "flv":
						return Types.Flv;
					case "folder":
						return Types.Folder;
					case "image":
						return Types.Image;
					case "link":
						return Types.Link;
					case "meeting":
						return Types.Meeting;
					case "presentation":
						return Types.Presentation;
					case "producer":
						return Types.Producer;
					case "session":
						return Types.Session;
					case "swf":
						return Types.Swf;
					case "tree":
						return Types.Tree;
					default:
						return Types.Content;
				}
			}
			catch (Exception)
			{
				
			}
			return Types.Unknown;
		}
	}
	
}