type S3Client struct {
	client s3iface.S3API
}
type S3API interface {
	PutObject(input *s3.PutObjectInput) (*s3.PutObjectOutput, error)
	GetObjectRequest(*s3.GetObjectInput) (*request.Request, *s3.GetObjectOutput)
}
type Request interface {
	Presign(expire time.Duration) (string, error)
}
func NewS3Client() S3Client {
	awsConfig := awstools.AWS{Config: &aws.Config{Region: aws.String("us-west-2")}}
	awsSession, _ := awsConfig.Get()
	return S3Client{
		client: s3.New(awsSession),
	}
}
func (s *S3Client) GetPreSignedUrl(bucket string, objectKey string) (string, error) {
	req, _ := s.client.GetObjectRequest(&s3.GetObjectInput{
		Bucket: aws.String(bucket),
		Key:    aws.String(objectKey),
	})
	urlStr, err := req.Presign(30 * 24 * time.Hour)
	if err != nil {
		return "", err
	}
	return urlStr, nil
}

type MockRequestImpl struct {
	request.Request
}
func (m *MockRequestImpl) Presign(input time.Duration) (string, error) {
	return preSignFunc(input)
}
type MockS3Client struct {
	s3iface.S3API
}
func init() {
	s = S3Client{
		client: &MockS3Client{},
	}
}
func (m *MockS3Client) GetObjectRequest(input *s3.GetObjectInput) (*request.Request, *s3.GetObjectOutput) {
	return getObjectFunc(input)
}
func TestS3Service_GetPreSignedUrl(t *testing.T) {
	t.Run("should not throw error", func(t *testing.T) {
		getObjectFunc = func(input *s3.GetObjectInput) (*request.Request, *s3.GetObjectOutput) {
			m := MockRequestImpl{}.Request
			return &m, &s3.GetObjectOutput{}
		}
		preSignFunc = func(expire time.Duration) (string, error) {
			return "preSigned", nil
		}
		url, err := s.GetPreSignedUrl("bucket", "objectKey")
		assert.Equal(t, "preSigned", url)
		assert.NoError(t, err)
	})
}

// client.go
type (
	// AWSClient is the main client that wraps our AWS s3 client
	AWSClient struct {
		s3Client            s3iface.S3API
		objectRequestClient ObjectRequester
	}
	// AWSClientConfig is the configuration for our client
	AWSClientConfig struct {
		Endpoint string `mapstructure:"endpoint"`
	}
	// ObjectRequester is our custom implementation of the S3 API
	ObjectRequester interface {
		getObjectRequest(bucket, key, filename string) Presignable
	}
	// ObjectRequestClient is the concrete version of the above, and will use the normal S3 API
	ObjectRequestClient struct {
		s3Client s3iface.S3API
	}
	// Presignable is an interface that will allow us to use both request.Request, as well as whatever other struct
	// we want that implements Presign.
	Presignable interface {
		Presign(time time.Duration) (string, error)
	}
)

// client.go
// NewS3Client creates a client allowing interaction with an s3 bucket.
func NewS3Client(c AWSClientConfig) *AWSClient {
	cfg := aws.NewConfig().WithRegion("us-east-1")
	if c.Endpoint != "" {
		cfg = &aws.Config{
			Region:           cfg.Region,
			Endpoint:         aws.String(c.Endpoint),
			S3ForcePathStyle: aws.Bool(true),
		}
	}
	s := s3.New(session.Must(session.NewSession(cfg)))
	return &AWSClient{s3Client: s, objectRequestClient: &ObjectRequestClient{s3Client: s}}
}

// client.go
// GetPresignedUrl creates a presigned url to an s3 object.
func (s *AWSClient) GetPresignedUrl(bucket, key, filename string) (string, error) {
	r := s.objectRequestClient.getObjectRequest(bucket, key, filename)
	return r.Presign(15 * time.Minute)
}
// getObjectRequest encapsulates GetObjectRequest so that it can be adapted for testing.
// Returning an interface here looks dumb, but it lets us return an object that is not
// *request.Request in the mock of this function so that we can call something.Presign()
// without a connection to AWS.
func (s *ObjectRequestClient) getObjectRequest(bucket, key, filename string) Presignable {
	req, _ := s.s3Client.GetObjectRequest(&s3.GetObjectInput{
		Bucket:                     aws.String(bucket),
		Key:                        aws.String(key),
		ResponseContentDisposition: aws.String(fmt.Sprintf("attachment; filename=\"%s\"", filename)),
	})
	return req
}

// client_test.go
type (
	MockS3Client struct {
		s3iface.S3API
		mock.Mock
	}
	MockObjectRequestClient struct {
		mock.Mock
	}
	MockPresignable struct {
		mock.Mock
	}
)
func (m *MockPresignable) Presign(time time.Duration) (string, error) {
	args := m.Called(time)
	return args.String(0), args.Error(1)
}
func (m *MockObjectRequestClient) getObjectRequest(bucket, key, filename string) Presignable {
	args := m.Called(bucket, key, filename)
	return args.Get(0).(Presignable)
}
func TestGetPresignedUrl(t *testing.T) {
	bucket := "bucket"
	key := "key"
	name := "spike"
	url := "https://test.com"
	m := MockS3Client{}
	mp := MockPresignable{}
	mo := MockObjectRequestClient{}
	mo.On("getObjectRequest", bucket, key, name).Return(&mp)
	mp.On("Presign", 15*time.Minute).Return(url, nil)
	client := AWSClient{s3Client: &m, objectRequestClient: &mo}
	returnedUrl, err := client.GetPresignedUrl(bucket, key, name)
	assert.NoError(t, err)
	assert.Equal(t, url, returnedUrl)
}