package eu.melw.queues.aws;

import com.amazonaws.AmazonClientException;
import com.amazonaws.AmazonServiceException;
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.auth.AWSCredentialsProvider;
import com.amazonaws.services.sqs.AmazonSQS;
import com.amazonaws.services.sqs.model.*;
import eu.melw.queues.message.MessageValidator;
import eu.melw.queues.message.MessengerException;
import eu.melw.queues.message.PermitDeleteValidator;
import eu.melw.queues.support.*;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;

import java.util.Arrays;
import java.util.List;

import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.*;

@RunWith(MockitoJUnitRunner.class)
public class SQSServiceTest {
    @Mock
    private SendMessageResult sendMessageResult;
    @Mock
    private MessageValidator messageValidator;
    @Mock
    private Message message;
    @Mock
    private ReceiveMessageResult receiveMessageResult;
    @Mock
    private CreateQueueResult createQueueResult;
    @Mock
    private AmazonSQS sqsClient;


    TaskMessage taskMessage;
    TaskMessageMarshaller marshaller = DefaultTaskMessageMarshallerFactory.getInstance()
            .getMarshaller(DefaultTaskMessageMarshallerFactory.YAML);

    private SQSService sqs;
    @Rule
    public ExpectedException exception = ExpectedException.none();

    private static final String ANY_ENDPOINT = "endPoint";
    private static final String ANY_QUEUE_URL = "url";
    private static final String MESSAGE_ID = "message-id";
    private static final QueueProperties VALID_QUEUE_PROPERTIES =
            new QueueProperties(ANY_ENDPOINT,ANY_QUEUE_URL, DefaultTaskMessageMarshallerFactory.YAML);

    @Before
    public void setUp() {
        taskMessage = TaskMessage.create("test-message", "body");
        sqs = new SQSService(new FakeSQSClientFactory(),
                DefaultTaskMessageMarshallerFactory.getInstance(),
                new PermitDeleteValidator(),
                10,
                10);
    }

    @Test
    public void
    sendsMessageSuccessFully() throws Exception {
        SendMessageResult smr = mock(SendMessageResult.class);
        when(sendMessageResult.getMessageId()).thenReturn(MESSAGE_ID);
        when(sqsClient.sendMessage(any(SendMessageRequest.class))).thenReturn(sendMessageResult);

        TaskMessage tm = sqs.sendMessage(VALID_QUEUE_PROPERTIES,taskMessage);

        assertEquals(MESSAGE_ID, tm.getMessageId());
    }

    @Test(expected = MessengerException.class)
    public void
    throwsExceptionOnSendMessage() {
        when(sqsClient.sendMessage(any(SendMessageRequest.class)))
                .thenThrow(new AmazonServiceException("a"));

        sqs.sendMessage(VALID_QUEUE_PROPERTIES, taskMessage);
    }

    @Test
    public void
    receivesOneMessage() {
        when(message.getMessageId())
                .thenReturn(MESSAGE_ID);
        when(message.getBody())
                .thenReturn(marshaller.marshall(taskMessage));
        when(receiveMessageResult.getMessages())
                .thenReturn(Arrays.asList(message));

        when(sqsClient.receiveMessage(any(ReceiveMessageRequest.class)))
                .thenReturn(receiveMessageResult);

        QueueProperties qp = new QueueProperties(ANY_ENDPOINT,
                ANY_QUEUE_URL,
                DefaultTaskMessageMarshallerFactory.YAML);
        List<TaskMessage> messages = sqs.receiveMessages(qp);

        assertEquals(1, messages.size());
    }

    @Test
    public void
    createQueue() {
        when(createQueueResult.getQueueUrl())
                .thenReturn(ANY_QUEUE_URL);
        when(sqsClient.createQueue(any(CreateQueueRequest.class)))
            .thenReturn(createQueueResult);
        String target = sqs.createQueue("endPoint", "queueName");

        assertEquals(ANY_QUEUE_URL, target);
    }

    @Test(expected = QueueManagementException.class)
    public void createQueueThrowAmazonClientException() {
        when(sqsClient.createQueue(any(CreateQueueRequest.class)))
                .thenThrow(new AmazonClientException(""));

        String target = sqs.createQueue("endPoint", "queueName");

        assertEquals(ANY_QUEUE_URL, target);

    }

    static class FakeCredentialsSupplier implements AWSCredentialsProvider {

        @Override
        public AWSCredentials getCredentials() {
            return new AWSCredentials() {
                @Override
                public String getAWSAccessKeyId() {
                    return "access-key";
                }

                @Override
                public String getAWSSecretKey() {
                    return "secret-key";
                }
            };
        }

        @Override
        public void refresh() {
        }
    }

    class FakeSQSClientFactory implements SQSService.SQSClientFactory {

        @Override
        public AmazonSQS getClient(String endPoint) {
            return sqsClient;
        }
    }


}