/*
 * Copyright 2012 Nodeable Inc
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */

package com.streamreduce.core.service;

import com.google.common.collect.Sets;
import com.streamreduce.AbstractServiceTestCase;
import com.streamreduce.core.model.Connection;
import com.streamreduce.core.model.ConnectionCredentials;
import com.streamreduce.core.model.OutboundConfiguration;
import com.streamreduce.core.model.OutboundDataType;
import com.streamreduce.core.service.exception.InvalidCredentialsException;
import com.streamreduce.test.service.S3TestUtils;
import com.streamreduce.test.service.TestUtils;
import com.streamreduce.util.AWSClient;
import com.streamreduce.util.InvalidOutboundConfigurationException;
import org.jclouds.blobstore.domain.StorageMetadata;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;

import java.util.HashSet;
import java.util.Set;

import static org.junit.Assert.assertTrue;

public class ConnectionServiceValidateS3OutboundConfigITCase extends AbstractServiceTestCase {

    @Autowired
    ConnectionService connectionService;

    Connection awsConnection;
    S3TestUtils s3TestUtils;
    final String bucketName = "com.streamreduce.duplicated.bucket.test";

    @Before
    public void setUp() throws Exception {
        super.setUp();
        awsConnection = TestUtils.createCloudConnection();
        s3TestUtils = new S3TestUtils(awsConnection.getCredentials());
        s3TestUtils.removeBuckets(bucketName);
    }

    @After
    public void tearDown() throws Exception {
        super.tearDown();

    }

    @Test
    public void testCreateConnection_s3BucketIsCreatedProactivelyForS3OutboundConfig() throws Exception {
        //Test that when a Connection is created with an OutboundConfiguration with s3 as the protocol, that the
        //bucket is created or previously exists, and can be written to by

        //Just to make sure the test doesn't error out because of a duplicate bucket existing
        String actualBucketName = bucketName + String.valueOf(System.currentTimeMillis());

        awsConnection.setOutboundConfigurations(Sets.newHashSet(
                new OutboundConfiguration.Builder()
                        .protocol("s3")
                        .credentials(awsConnection.getCredentials())
                        .dataTypes(OutboundDataType.PROCESSED)
                        .namespace(actualBucketName)
                        .build()
                )
        );
        awsConnection.setAccount(testAccount);
        awsConnection.setUser(testUser);

        connectionService.createConnection(awsConnection);

        AWSClient awsClient = new AWSClient(awsConnection);
        Set<? extends StorageMetadata> buckets = awsClient.getS3Buckets();
        Set<String> bucketNames = new HashSet<>();
        for (StorageMetadata bucket : buckets) {
            bucketNames.add(bucket.getName());
        }
        assertTrue(bucketNames.contains(actualBucketName));
    }

    @Test(expected = InvalidOutboundConfigurationException.class)
    public void testCreateConnection_failsValidationIfS3OutboundBucketExists() throws Exception {
        //Test that exercises that a connection will not be created if an OutboundConfiguration that has the same
        //bucket name with a set of AWS credentials not in the same AWS account
        createPreExistingBucket();

        //AWS creds for jason@nodeable.com, but Dave gets billed so feel free to use these for fun and profit
        String anotherAccessKey = "AKIAJYE3KRM4KGQ43OKQ";
        String anotherSecretKey = "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";

        //Reuse the same connection but do enough to make it look like a new, non-duplicate connection
        awsConnection.setId(null);
        awsConnection.setUser(testUser);
        awsConnection.setAccount(testUser.getAccount());
        awsConnection.setCredentials(new ConnectionCredentials(anotherAccessKey, anotherSecretKey));
        awsConnection.setOutboundConfigurations(Sets.newHashSet(new OutboundConfiguration.Builder()
                .protocol("s3")
                .dataTypes(OutboundDataType.PROCESSED)
                .namespace(bucketName)
                .credentials(new ConnectionCredentials(anotherAccessKey, anotherSecretKey))
                .build()));

        //Saving this connection should fail because the outboundConfiguration is invalid
        connectionService.createConnection(awsConnection);
    }




    @Test(expected = InvalidOutboundConfigurationException.class)
    public void testUpdateConnection_failsValidationIfS3OutboundBucketExists() throws Exception {
        createPreExistingBucket();

        awsConnection.setAccount(testAccount);
        awsConnection.setUser(testUser);
        Connection createdConnection = connectionService.createConnection(awsConnection);

        //AWS creds for jason@nodeable.com, but Dave gets billed so feel free to use these for fun and profit
        String anotherAccessKey = "AKIAJYE3KRM4KGQ43OKQ";
        String anotherSecretKey = "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";
        createdConnection.addOutboundConfiguration(new OutboundConfiguration.Builder()
                .protocol("s3")
                .dataTypes(OutboundDataType.PROCESSED)
                .namespace(bucketName)
                .credentials(new ConnectionCredentials(anotherAccessKey, anotherSecretKey))
                .build());
        connectionService.updateConnection(createdConnection);
    }

    private void createPreExistingBucket() throws InvalidCredentialsException {
        OutboundConfiguration preexistingOutboundConfig = new OutboundConfiguration.Builder()
                .protocol("s3")
                .credentials(awsConnection.getCredentials())
                .dataTypes(OutboundDataType.PROCESSED)
                .namespace(bucketName)
                .build();

        //Do something that makes the bucket appear
        AWSClient awsClient = new AWSClient(preexistingOutboundConfig);
        awsClient.createBucket(preexistingOutboundConfig);
    }
}