package org.gcube.contentmanagement.blobstorage.transport.plugin;

import java.io.File;
import java.nio.file.Paths;
import java.util.Objects;

import org.gcube.contentmanagement.blobstorage.transport.backend.RemoteBackendException;

import software.amazon.awssdk.core.sync.RequestBody;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.s3.model.DeleteObjectResponse;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.model.CreateBucketConfiguration;
import software.amazon.awssdk.services.s3.model.CreateBucketRequest;
import software.amazon.awssdk.services.s3.model.DeleteBucketRequest;
import software.amazon.awssdk.services.s3.model.DeleteObjectRequest;
import software.amazon.awssdk.services.s3.model.GetObjectRequest;
import software.amazon.awssdk.services.s3.model.GetObjectResponse;
import software.amazon.awssdk.services.s3.model.ListBucketsRequest;
import software.amazon.awssdk.services.s3.model.ListBucketsResponse;
import software.amazon.awssdk.services.s3.model.ListObjectsV2Request;
import software.amazon.awssdk.services.s3.model.ListObjectsV2Response;
import software.amazon.awssdk.services.s3.model.PutObjectRequest;
import software.amazon.awssdk.services.s3.model.PutObjectResponse;
import software.amazon.awssdk.services.s3.model.S3Object;

public class BucketOperator {
	
    private static BucketOperator single_instance; 
    private static S3Client client;
    
    private BucketOperator(S3Client client) {
    	if(Objects.isNull(client))
    		throw new RemoteBackendException("S3Client not initialized properly");
    	this.client=client;
    }
    
    public static BucketOperator getInstance(S3Client client) {
    	if(Objects.isNull(single_instance))
    		single_instance=new BucketOperator(client);
    	return single_instance;
    }
    
    /**
    * Creates a bucket in the given region with the name specified.
    * @param s3
    * @param bucketName
    * @param region
    */
    public static void createBucket(S3Client s3, String bucketName, Region region) {
    	CreateBucketRequest createBucketRequest = CreateBucketRequest.builder()
    			.bucket(bucketName).createBucketConfiguration(
    	CreateBucketConfiguration.builder().locationConstraint(region.id()).build())
    			.build();
    	System.out.println(s3.createBucket(createBucketRequest).toString());
    }
    
    /**
    * Lists the buckets in your account.
    * @param s3
    */
    public static void listBuckets(S3Client s3) {
    	ListBucketsRequest req = ListBucketsRequest.builder().build();
    	ListBucketsResponse res = s3.listBuckets(req);
    	res.buckets().stream().forEach(x->System.out.println(x.name()));
    }

    /**
     * Before you can delete an Amazon S3 bucket, you must ensure that the bucket
     * is empty or the service will return an error. If you have a versioned
     * bucket, you must also delete any versioned objects that are in the bucket.
     * 
     * @param s3

     * @param bucketName
     * @param region
     */


    public static void deleteBucketWithContents(final S3Client s3, final String bucketName, final Region region) {
     
      ListObjectsV2Request request = ListObjectsV2Request.builder().bucket(bucketName).build();
      ListObjectsV2Response response;
      do {
    	  response = s3.listObjectsV2(request);
    	  for(S3Object s3Obj : response.contents()) {
    		  s3.deleteObject(DeleteObjectRequest.builder()
    				  .bucket(bucketName).key(s3Obj.key()).build());
    	  }
    	  request = ListObjectsV2Request.builder().bucket(bucketName)  .continuationToken(response.continuationToken()).build();
     }while(response.isTruncated());
     


      //Now the bucket is empty, delete the bucket
      deleteEmptyBucket(s3, bucketName);
    }
     
    /**
     * Deletes the bucket specified, given the bucket is empty. 
     * @param s3
     * @param bucketName
     */
     public static void deleteEmptyBucket(final S3Client s3, final String bucketName) {
     
     DeleteBucketRequest req = DeleteBucketRequest.builder().bucket(bucketName).build();
     	System.out.println(s3.deleteBucket(req).toString());
     }
     
     /**
      * 
      * @param bucket
      * @param key
      * @param localPath
      * @return
      */
     public static GetObjectResponse getObject(String bucket, String key, String localPath) {
    	 GetObjectRequest getObjectRequest = GetObjectRequest.builder()
    		        .bucket(bucket)
    		        .key(key)
    		        .build();

    		return client.getObject(getObjectRequest, Paths.get(localPath));
    		
     }
     
     /**
      * 
      * @param bucket
      * @param key
      * @param file
      * @return
      */
     public static PutObjectResponse putObject(String bucket, String key, File file) {
    	 PutObjectRequest objectRequest = PutObjectRequest.builder()
    		        .bucket(bucket)
    		        .key(key)
    		        .build();
//    		client.putObject(objectRequest, RequestBody.fromByteBuffer(getRandomByteBuffer(10_000)));
    		return client.putObject(objectRequest, RequestBody.fromFile(file));
    		
     }
     
     
     /**
      * 
      * @param bucket
      * @param key
      * @return
      */
     public static String deleteObject(String bucket, String key) {
    	 DeleteObjectRequest deleteObjectRequest = DeleteObjectRequest.builder()
    		        .bucket(bucket)
    		        .key(key)
    		        .build();
    		DeleteObjectResponse response=client.deleteObject(deleteObjectRequest);
    		return response.toString();
     }
     

}