/// <summary>
        /// Create a new application
        /// </summary>
        /// <param name="friendlyName">The friendly name to name the application</param>
        /// <param name="options">Optional parameters to use when purchasing number</param>
        /// <param name="callback">Method to call upon successful completion</param>
        public virtual void AddApplication(string friendlyName, ApplicationOptions options, Action<Application> callback)
        {
            var request = new RestRequest(Method.POST);
            request.Resource = "Accounts/{AccountSid}/Applications.json";
            
            Require.Argument("FriendlyName", friendlyName);
            Validate.IsValidLength(friendlyName, 64);
            request.AddParameter("FriendlyName", friendlyName);

            // some check for null. in those cases an empty string is a valid value (to remove a URL assignment)
            if (options != null)
            {
                if (options.VoiceUrl != null) request.AddParameter("VoiceUrl", options.VoiceUrl);
                if (options.VoiceMethod.HasValue()) request.AddParameter("VoiceMethod", options.VoiceMethod.ToString());
                if (options.VoiceFallbackUrl != null) request.AddParameter("VoiceFallbackUrl", options.VoiceFallbackUrl);
                if (options.VoiceFallbackMethod.HasValue()) request.AddParameter("VoiceFallbackMethod", options.VoiceFallbackMethod.ToString());
                if (options.VoiceCallerIdLookup.HasValue) request.AddParameter("VoiceCallerIdLookup", options.VoiceCallerIdLookup.Value);
                if (options.StatusCallback.HasValue()) request.AddParameter("StatusCallback", options.StatusCallback);
                if (options.StatusCallbackMethod.HasValue()) request.AddParameter("StatusCallbackMethod", options.StatusCallbackMethod.ToString());
                if (options.SmsUrl != null) request.AddParameter("SmsUrl", options.SmsUrl);
                if (options.SmsMethod.HasValue()) request.AddParameter("SmsMethod", options.SmsMethod.ToString());
                if (options.SmsFallbackUrl != null) request.AddParameter("SmsFallbackUrl", options.SmsFallbackUrl);
                if (options.SmsFallbackMethod.HasValue()) request.AddParameter("SmsFallbackMethod", options.SmsFallbackMethod.ToString());
            }

            ExecuteAsync<Application>(request, (response) => { callback(response); });
        }

        public virtual async Task<VoiceCountryResult> ListVoiceCountriesAsync()
        {
            var request = new RestRequest(Method.GET);
            request.Resource = "Voice/Countries";

            return await Execute<VoiceCountryResult>(request);
        }

		/// <summary>
		/// Returns the Sandbox resource associated with the account identified by {YourAccountSid}. 
		/// Twilio accounts upgraded prior to February 2010 may not have a Sandbox resource, and in this case you will receive a 404 (Not Found) response.
		/// Makes a GET request to the Sandbox Instance resource.
		/// </summary>
        public virtual Sandbox GetSandbox()
		{
			var request = new RestRequest();
			request.Resource = "Accounts/{AccountSid}/Sandbox.json";

			return Execute<Sandbox>(request);
		}

 /// <summary>
 /// Returns a filtered list of Messages. The list includes paging information.
 /// Makes a GET request to the Messages List resource.
 /// </summary>
 /// <param name="options">The list filters for the request</param>
 public virtual async Task<MessageResult> ListMessagesAsync(MessageListRequest options) 
 {
     var request = new RestRequest();
     request.Resource = "Accounts/{AccountSid}/Messages.json";
     AddMessageListOptions(options, request);
     return await Execute<MessageResult>(request);
 }

        public virtual void ListVoiceCountries(Action<VoiceCountryResult> callback)
        {
            var request = new RestRequest(Method.GET);
            request.Resource = "Voice/Countries";

            ExecuteAsync<VoiceCountryResult>(request, (response) => callback(response));
        }

		/// <summary>
		/// List all subaccounts created for the authenticated account. Makes a GET request to the Account List resource.
		/// </summary>
        public virtual AccountResult ListSubAccounts()
		{
			var request = new RestRequest();
			request.Resource = "Accounts.json";

			return Execute<AccountResult>(request);
		}

        public virtual PhoneNumberCountryResult ListPhoneNumberCountries()
        {
            var request = new RestRequest(Method.GET);
            request.Resource = "PhoneNumbers/Countries";

            return Execute<PhoneNumberCountryResult>(request);
        }

 /// <summary>
 /// Retrieve the account details for the currently authenticated account. Makes a GET request to an Account Instance resource.
 /// </summary>
 public virtual async Task<Account> GetAccountAsync()
 {
     var request = new RestRequest();
     request.Resource = "Accounts/{AccountSid}.json";
     
     return await Execute<Account>(request);
 }

        public virtual async Task<PhoneNumberCountryResult> ListPhoneNumberCountriesAsync()
        {
            var request = new RestRequest(Method.GET);
            request.Resource = "PhoneNumbers/Countries";

            return await Execute<PhoneNumberCountryResult>(request);
        }

        private static void AddCallOptions(CallOptions options, RestRequest request)
        {
            request.AddParameter("From", options.From);
            request.AddParameter("To", options.To);

            if (options.ApplicationSid.HasValue())
            {
                request.AddParameter("ApplicationSid", options.ApplicationSid);
            }
            else
            {
                request.AddParameter("Url", options.Url);
            }

            if (options.StatusCallback.HasValue()) request.AddParameter("StatusCallback", options.StatusCallback);
            if (options.StatusCallbackMethod.HasValue()) request.AddParameter("StatusCallbackMethod", options.StatusCallbackMethod);
            if (options.FallbackUrl.HasValue()) request.AddParameter("FallbackUrl", options.FallbackUrl);
            if (options.FallbackMethod.HasValue()) request.AddParameter("FallbackMethod", options.FallbackMethod);
            if (options.Method.HasValue()) request.AddParameter("Method", options.Method);
            if (options.SendDigits.HasValue()) request.AddParameter("SendDigits", options.SendDigits);
            if (options.IfMachine.HasValue()) request.AddParameter("IfMachine", options.IfMachine);
            if (options.Timeout.HasValue) request.AddParameter("Timeout", options.Timeout.Value);
            if (options.Record) request.AddParameter("Record", "true");
            if (options.SipAuthUsername.HasValue()) request.AddParameter("SipAuthUsername", options.SipAuthUsername);
            if (options.SipAuthPassword.HasValue()) request.AddParameter("SipAuthPassword", options.SipAuthPassword);
        }

        /// <summary>
        /// Returns the Sandbox resource associated with the account identified by {YourAccountSid}. Twilio accounts upgraded prior to February 2010 may not have a Sandbox resource, and in this case you will receive a 404 (Not Found) response.
        /// </summary>
        /// <param name="callback">Method to call upon successful completion</param>
        public virtual void GetSandbox(Action<Sandbox> callback)
        {
            var request = new RestRequest();
            request.Resource = "Accounts/{AccountSid}/Sandbox.json";

            ExecuteAsync<Sandbox>(request, callback);
        }

        /// <summary>
        /// Return a list of all Queue resources
        /// </summary>
        /// <param name="callback">Method to call upon successful completion</param>
        /// <returns></returns>
        public virtual void ListQueues(Action<QueueResult> callback)
        {
            var request = new RestRequest();
            request.Resource = "Accounts/{AccountSid}/Queues.json";

            ExecuteAsync<QueueResult>(request, (response) => callback(response) );
        }

        /// <summary>
        /// Return a list of all Queue resources
        /// </summary>
        /// <returns></returns>
        public virtual QueueResult ListQueues()
        {
            var request = new RestRequest();
            request.Resource = "Accounts/{AccountSid}/Queues.json";

            return Execute<QueueResult>(request);
        }

        /// <summary>
        /// Returns the Sandbox resource associated with the account identified by {YourAccountSid}. 
        /// Twilio accounts upgraded prior to February 2010 may not have a Sandbox resource, and in this case you will receive a 404 (Not Found) response.
        /// Makes a GET request to the Sandbox Instance resource.
        /// </summary>
        public virtual async Task<Sandbox> GetSandboxAsync()
        {
            var request = new RestRequest();
            request.Resource = "Accounts/{AccountSid}/Sandbox.json";

            return await Execute<Sandbox>(request);
        }

 /// <summary>
 /// Retrieve the account details for the currently authenticated account
 /// </summary>
 /// <param name="callback">Method to call upon successful completion</param>
 public virtual void GetAccount(Action<Account> callback)
 {
     var request = new RestRequest();
     request.Resource = "Accounts/{AccountSid}.json";
     
     ExecuteAsync<Account>(request, (response) => { callback(response); });
 }

        /// <summary>
        /// Returns a paged list of phone calls made to and from the account.
        /// Makes a GET request to the Calls List resource.
        /// </summary>
        public virtual async Task<CallResult> ListCallsAsync()
        {
            var request = new RestRequest();
            request.Resource = "Accounts/{AccountSid}/Calls.json";

            return await Execute<CallResult>(request);
        }

        /// <summary>
        /// List all subaccounts created for the authenticated account
        /// </summary>
        /// <param name="callback">Method to call upon successful completion</param>
        public virtual void ListSubAccounts(Action<AccountResult> callback)
        {
            var request = new RestRequest();
            request.Resource = "Accounts.json";

            ExecuteAsync<AccountResult>(request, (response) => { callback(response); });
        }

        /// <summary>
        /// List all subaccounts created for the authenticated account. Makes a GET request to the Account List resource.
        /// </summary>
        public virtual async Task<AccountResult> ListSubAccountsAsync()
        {
            var request = new RestRequest();
            request.Resource = "Accounts.json";

            return await Execute<AccountResult>(request);
        }

        public void When_Request_Method_Is_POST_Then_Request_Body_Contains_Encoded_Parameters()
        {
            string body = "Foo=12345&Bar=abcde";
            var sourcebytes = Encoding.UTF8.GetBytes(body);

            client = new RestClient();
            client.BaseUrl = BASE_URL;

            var request = new RestRequest();
            request.Method = "POST";
            request.AddParameter("Foo", "12345");
            request.AddParameter("Bar", "abcde");

            var wrapper = new HttpWebRequestWrapper();
            wrapper.Request = new FakeHttpWebRequest();
            var webrequest = (FakeHttpWebRequest)wrapper.ConfigureRequest(client, request);

            var stream = webrequest.GetRequestStream();
            stream.Position = 0;
            byte[] actualbytes = stream.ReadAsBytes();

            Assert.AreEqual(sourcebytes.Length, webrequest.ContentLength);
            Assert.AreEqual(sourcebytes.Length, actualbytes.Length);
            CollectionAssert.AreEquivalent(sourcebytes, actualbytes);            
        }

		/// <summary>
		/// Retrieve the account details for the currently authenticated account. Makes a GET request to an Account Instance resource.
		/// </summary>
        public virtual Account GetAccount()
		{
			var request = new RestRequest();
			request.Resource = "Accounts/{AccountSid}.json";
			
			return Execute<Account>(request);
		}