package main

import (
    "encoding/gob"
    "fmt"
    "log"
    "os"
    "time"

    "github.com/aws/aws-sdk-go/aws"
    "github.com/aws/aws-sdk-go/aws/session"
    "github.com/aws/aws-sdk-go/service/s3"
    "github.com/aws/aws-sdk-go/service/s3/s3manager"
)

type fileRecord struct {
    FileName string
    MTime    time.Time
}

type allFiles []fileRecord

var pfile = new(allFiles)
var filesInProcess []fileRecord

// Usage: go run bucket.go BUCKET_NAME
func main() {
    if len(os.Args) != 2 {
        exitErrorf("Bucket name required\nUsage: %s bucket_name",
            os.Args[0])
    }

    bucket := os.Args[1]

    // credentials from the shared credentials file ~/.aws/credentials.
    sess, err := session.NewSession(&aws.Config{
        Region: aws.String("us-east-1")},
    )

    // Create S3 service client
    svc := s3.New(sess)

    // Get the list of items
    resp, err := svc.ListObjectsV2(&s3.ListObjectsV2Input{
        Bucket: aws.String(bucket),
        Prefix: aws.String("weak/")})
    if err != nil {
        exitErrorf("Unable to list items in bucket %q, %v", bucket, err)
    }

    workingDir, err := os.Getwd()
    if err != nil {
        log.Println(err)
    }

    // load file log
    inProcessLog := workingDir + "/inProcessFiles"
    if fileExists(inProcessLog) {
        err = readGob(inProcessLog, pfile)
        if err != nil {
            fmt.Println(err)
        } else {
            for _, v := range *pfile {
                filesInProcess = append(filesInProcess, fileRecord{v.FileName, v.MTime})
            }
        }
    }

    // process files
    for _, item := range resp.Contents {
        if !(fileExists(workingDir + "/" + *item.Key)) {
            filesInProcess = append(filesInProcess, fileRecord{*item.Key, *item.LastModified})
            downloadS3Objects(bucket, item, sess)
        } else {
            fmt.Printf("We already have %s.\n", *item.Key)
        }
    }
    err = writeGob(inProcessLog, filesInProcess)
    if err != nil {
        fmt.Println(err)
    }

    fmt.Println("Found", len(resp.Contents), "items in bucket", bucket)
    fmt.Println("")
}

func exitErrorf(msg string, args ...interface{}) {
    fmt.Fprintf(os.Stderr, msg+"\n", args...)
    os.Exit(1)
}

func downloadS3Objects(bucket string, item *s3.Object, sess *session.Session) {
    file, err := os.Create(*item.Key)
    if err != nil {
        exitErrorf("Unable to open file %q, %v", item, err)
    }

    defer file.Close()

    downloader := s3manager.NewDownloader(sess)

    numBytes, err := downloader.Download(file,
        &s3.GetObjectInput{
            Bucket: aws.String(bucket),
            Key:    aws.String(*item.Key),
        })
    if err != nil {
        exitErrorf("Unable to download item %q, %v", item, err)
    }

    fmt.Println("Downloaded", file.Name(), numBytes, "bytes")
}

func writeGob(filePath string, object interface{}) error {
    file, err := os.Create(filePath)
    if err != nil {
        exitErrorf("Unable to open file %q, %v", filePath, err)
    }

    defer file.Close()

    encoder := gob.NewEncoder(file)
    encoder.Encode(object)
    return err
}

func readGob(filePath string, object interface{}) error {
    file, err := os.Open(filePath)

    if err != nil {
        exitErrorf("Unable to open file %q, %v", filePath, err)
    }

    defer file.Close()
    decoder := gob.NewDecoder(file)
    err = decoder.Decode(object)

    return err
}

func fileExists(filename string) bool {
    info, err := os.Stat(filename)
    if os.IsNotExist(err) {
        return false
    }
    return !info.IsDir()
}