/// <summary>Run the NAnt task</summary>
 protected override void ExecuteTask()
 {
     var urlIsSet = !String.IsNullOrEmpty(QueueUrl);
     // Ensure the queue exists
     if (!DoesQueueExist())
         CreateQueue();
     // Ensure the queue URL was set
     if (!urlIsSet) {
         Project.Log(Level.Info, "Please set the queue URL: 'url=\"{0}\"'", QueueUrl);
         return;
     }
     Project.Log(Level.Info, "Sending message to queue...");
     using (Client) {
         try {
             var request = new SendMessageRequest {
                 QueueUrl = QueueUrl,
                 MessageBody = Message
             };
             Client.SendMessage(request);
         } catch (AmazonS3Exception ex) {
             ShowError(ex);
         }
     }
     Project.Log(Level.Info, "Successfully sent message to Amazon SQS!");
 }

 public void RequestToBody()
 {
     var entity = new GetChangedEmployeesRequest() { LastChangeDate = fixedDate, ResponseQueueUrl = fixedQueueName };
     var message = new SendMessageRequest();
     message.RequestToBody(entity);
     Assert.AreEqual(fixedBody, message.MessageBody);
 }

 private async Task AssignTaskToPeasant() {
     var sendMsgRequest = new SendMessageRequest();
     sendMsgRequest.QueueUrl = queueURL;
     var msgData = RetrievePeasantTask();
     sendMsgRequest.MessageBody = JsonConvert.SerializeObject(msgData);
     await sqsClient.SendMessageAsync(sendMsgRequest);
 }

        protected override void EndProcessing()
        {
            AmazonSQS client = base.GetClient();

            foreach (string message in this.Messages)
            {
                try
                {
                    SendMessageRequest request = new SendMessageRequest();
                    request.QueueUrl = this.QueueUrl;
                    request.MessageBody = message;

                    SendMessageResponse response = client.SendMessage(request);
                    WriteObject(response.SendMessageResult);
                }
                catch (Exception ex)
                {
                    ErrorRecord record = new ErrorRecord(ex, null, ErrorCategory.InvalidOperation, message);
                    WriteError(record);
                }
            }


            base.EndProcessing();
        }

 public void ToBody_Flush()
 {
     var entity = new FlushDataStoreRequest() { StoreIdentifier="Sixeyed-CloudServiceBus-ResponseData", ResponseQueueUrl = fixedQueueName };
     var message = new SendMessageRequest();
     message.RequestToBody(entity);
     var expected = @"{""ResponseQueueName"":""b1a84e89-e5b9-4720-9235-dcf9605a59c3"",""ServiceRequestName"":""FlushDataStoreRequest"",""StoreIdentifier"":""Sixeyed-CloudServiceBus-ResponseData""}";
     Assert.AreEqual(expected, message.MessageBody);
 }

        public bool Send(SendMessageRequest request)
        {
            if (request == null)
                return false;

            var response = SqsClient.SendMessage(request);
            return response != null;
        }

 public static string Send(string queue_url, string msg)
 {
     AmazonSQS sqs = AWSClientFactory.CreateAmazonSQSClient();
     SendMessageRequest msgreq = new SendMessageRequest();
     msgreq.QueueUrl = queue_url;
     msgreq.MessageBody = msg;
     SendMessageResponse msgres = sqs.SendMessage(msgreq);
     SendMessageResult msgrst = msgres.SendMessageResult;
     return msgrst.ToString();
 }

        public string Search(string term)
        {
            var sqs = AWSClientFactory.CreateAmazonSQSClient();
            var sendMessageRequest = new SendMessageRequest();
            sendMessageRequest.QueueUrl = "https://sqs.us-west-2.amazonaws.com/x"; //URL from initial queue creation
            sendMessageRequest.MessageBody = term.ToLower().Trim();
            var sentMsg = sqs.SendMessage(sendMessageRequest);

            return sentMsg.SendMessageResult.MessageId;
        }

 private void AddToQueue(string data)
 {
     var sendMessageRequest = new SendMessageRequest
     {
         QueueUrl = QueueUrl,
         MessageBody = data
     };
     var response = _sqsClient.SendMessage(sendMessageRequest);
     Console.WriteLine("Response status code: " + response.HttpStatusCode);
 }

        private void btnSend_Click(object sender, EventArgs e)
        {
            var message = SerializeEmail();
            var request = new SendMessageRequest(
                queueUrl: _awsConfig.QueueUrl,
                messageBody: message);

            var client = _awsConfig.CreateSQSClient();
            var response = client.SendMessage(request);

            MessageBox.Show("Sent message. Id: " + response.MessageId);
        }

        public void Enqueue(string data)
        {
            if (_queueUrl == null) {
                Create_queue();
            }

            var sendMessageRequest = new SendMessageRequest {
                QueueUrl = _queueUrl,
                MessageBody = data
            };
            _sqs.SendMessage(sendMessageRequest);
        }

        /// <summary>
        /// Sends the events.
        /// </summary>
        /// <param name="events">The events that need to be send.</param>
        /// <remarks>
        /// <para>
        /// The subclass must override this method to process the buffered events.
        /// </para>
        /// </remarks>
        protected override void SendBuffer(LoggingEvent[] events)
        {
            Parallel.ForEach(events, l =>
                {
                    SendMessageRequest request =
                        new SendMessageRequest()
                            .WithMessageBody(Utility.GetXmlString(l))
                            .WithQueueUrl(QueueUrl);

                    Client.SendMessage(request);
                });
        }

        public virtual AddQueueResponse Add(InstrumentMarketDataRequest request)
        {
            this.CheckRequestForValidity(request);

            var client = this.GetClient();
            var messageBody = this.GetMessageBody(request);
            var sendMessageRequest = new SendMessageRequest
                                         {
                                             MessageBody = messageBody,
                                         };
            var response = client.SendMessage(sendMessageRequest);
            return this.Convert(response);
        }

        static void Main(string[] args)
        {
            Console.Title = "CloudServiceBus: Client";

            AmazonSQS sqs = AwsFacade.GetSqsClient();
            var requestQueueUrl = ConfigurationManager.AppSettings["QueueUrl"];

            //create a queue for responses:
            var queueName = Guid.NewGuid().ToString();
            var createQueueRequest = new CreateQueueRequest();
            createQueueRequest.QueueName = queueName;
            var createQueueResponse = sqs.CreateQueue(createQueueRequest);
            var responseQueueUrl = createQueueResponse.CreateQueueResult.QueueUrl;

            var listener = new MessageListener();
            ThreadPool.QueueUserWorkItem(new WaitCallback(listener.StartListening), responseQueueUrl);

            Console.WriteLine("*");
            Console.WriteLine("Sending messages on URL: {0}", requestQueueUrl);
            Console.WriteLine("Receiving responses on URL: {0}", responseQueueUrl);
            Console.WriteLine("*");

            var messageBody = Console.ReadLine();
            while (messageBody != "x")
            {
                var parts = messageBody.Split(' ');
                if (parts[0] == "get")
                {
                    var duration = int.Parse(parts[1]);
                    var serviceRequest = new GetChangedEmployeesRequest();
                    serviceRequest.LastChangeDate = DateTime.Now.AddDays(duration).Date;
                    serviceRequest.ResponseQueueUrl = responseQueueUrl;
                    var request = new SendMessageRequest();
                    request.QueueUrl = requestQueueUrl;
                    request.RequestToBody(serviceRequest);
                    SendMessage(request, sqs, serviceRequest);
                }
                if (parts[0] == "flush")
                {
                    var serviceRequest = new FlushDataStoreRequest();
                    serviceRequest.StoreIdentifier = "Sixeyed-CloudServiceBus-ResponseData";
                    var request = new SendMessageRequest();
                    request.QueueUrl = requestQueueUrl;
                    request.RequestToBody(serviceRequest);
                    SendMessage(request, sqs, serviceRequest);
                }

                messageBody = Console.ReadLine();
            }
        }

        public static void SendMessage(string typeName,Func<object> messageComposer)
        {
           
            Task.Factory.StartNew(() => {
                EnsureQueue();
                Logger.Debug("starting sync message...");
                SendMessageRequest sendMessageRequest = new SendMessageRequest();
                sendMessageRequest.QueueUrl = queueUrl;
                sendMessageRequest.MessageBody = JsonConvert.SerializeObject(new { type = typeName, data = messageComposer() });

                sqs.SendMessage(sendMessageRequest);
                Logger.Debug("completed one message sync");
            });
           
        }

        private void button1_Click(object sender, EventArgs e)
        {
            CreateQueueRequest sqsRequest = new CreateQueueRequest();
            sqsRequest.QueueName = "MYFirstQueue";
            CreateQueueResponse createQueueResponse = sqs.CreateQueue(sqsRequest);
            myQueueUrl = createQueueResponse.CreateQueueResult.QueueUrl;

            //Confirming the queue exists
            ListQueuesRequest listQueuesRequest = new ListQueuesRequest();
            ListQueuesResponse listQueuesResponse = sqs.ListQueues(listQueuesRequest);

            SendMessageRequest sendMessageRequest = new SendMessageRequest();
            sendMessageRequest.QueueUrl = myQueueUrl;
            sendMessageRequest.MessageBody = txtPushMsg.Text;
            sqs.SendMessage(sendMessageRequest);
        }

        protected override bool Execute(AmazonSQS client)
        {
            var request = new SendMessageRequest { MessageBody = MessageBody, QueueUrl = QueueUrl };

            SendMessageResponse response = client.SendMessage(request);

            if (response.IsSetSendMessageResult())
            {
                MessageId = response.SendMessageResult.MessageId;

                Logger.LogMessage(MessageImportance.Normal, "Sent message {0} to Queue {1}", MessageId, QueueUrl);
                return true;
            }

            Logger.LogMessage(MessageImportance.High, "Message failed to send to to Queue {0}", QueueUrl);
            return false;
        }

      public void Add(string message)
      {
         try
         {
            SendMessageRequest request = new SendMessageRequest
            {
               MessageBody = message,
               QueueName = Name
            };

            SendMessageResponse response = _client.SendMessage(request);
         }
         catch (AmazonSQSException e)
         {
            throw new MessageQueueException(string.Format("Failed to add message to '{0}'.", Name), e);
         }
      }

	    private void SendMessage(string message, SendOptions sendOptions)
	    {
            var delayDeliveryBy = TimeSpan.MaxValue;
            if (sendOptions.DelayDeliveryWith.HasValue)
                delayDeliveryBy = sendOptions.DelayDeliveryWith.Value;
            else
            {
                if (sendOptions.DeliverAt.HasValue)
                {
                    delayDeliveryBy = sendOptions.DeliverAt.Value - DateTime.UtcNow;
                }
            }

			var sendMessageRequest = new SendMessageRequest(QueueUrlCache.GetQueueUrl(sendOptions.Destination), message);
	        
            // There should be no need to check if the delay time is greater than the maximum allowed
            // by SQS (15 minutes); the call to AWS will fail with an appropriate exception if the limit is exceeded.
            if ( delayDeliveryBy != TimeSpan.MaxValue)
                sendMessageRequest.DelaySeconds = Math.Max(0, (int)delayDeliveryBy.TotalSeconds);

	        SqsClient.SendMessage(sendMessageRequest);
	    }

    public static void SQSSendMessage()
    {
      #region SQSSendMessage
      var client = new AmazonSQSClient();

      var request = new SendMessageRequest
      {
        DelaySeconds = (int)TimeSpan.FromSeconds(5).TotalSeconds,
        MessageAttributes = new Dictionary<string, MessageAttributeValue>
        {
          {
            "MyNameAttribute", new MessageAttributeValue 
              { DataType = "String", StringValue = "John Doe" }
          },
          {
            "MyAddressAttribute", new MessageAttributeValue 
              { DataType = "String", StringValue = "123 Main St." }
          },
          {
            "MyRegionAttribute", new MessageAttributeValue 
              { DataType = "String", StringValue = "Any Town, United States" }
          }
        },
        MessageBody = "John Doe customer information.",
        QueueUrl = "https://sqs.us-east-1.amazonaws.com/80398EXAMPLE/MyTestQueue"
      };

      var response = client.SendMessage(request);

      Console.WriteLine("For message ID '" + response.MessageId + "':");
      Console.WriteLine("  MD5 of message attributes: " +
        response.MD5OfMessageAttributes);
      Console.WriteLine("  MD5 of message body: " + response.MD5OfMessageBody);
      #endregion

      Console.ReadLine();
    }