package main

import (
    "context"
    "log"
    "time"

    "github.com/golang/protobuf/ptypes/timestamp"
    "github.com/golang/protobuf/ptypes"
    "github.com/golang/protobuf/ptypes/wrappers"

    "github.com/mongodb/mongo-go-driver/bson"
    "github.com/mongodb/mongo-go-driver/bson/bsoncodec"
    "github.com/mongodb/mongo-go-driver/bson/primitive"
    "github.com/mongodb/mongo-go-driver/mongo"
    "github.com/mongodb/mongo-go-driver/mongo/options"
    "github.com/mongodb/mongo-go-driver/x/mongo/driver/topology"

    "github.com/amsokol/mongo-go-driver-protobuf"
)

type Data struct {
    BoolValue   *wrappers.BoolValue
    BytesValue  *wrappers.BytesValue
    DoubleValue *wrappers.DoubleValue
    FloatValue  *wrappers.FloatValue
    Int32Value  *wrappers.Int32Value
    Int64Value  *wrappers.Int64Value
    StringValue *wrappers.StringValue
    Uint32Value *wrappers.UInt32Value
    Uint64Value *wrappers.UInt64Value

    Timestamp *timestamp.Timestamp
}

func main() {
    log.Printf("connecting to MongoDB server...")

    rb := bson.NewRegistryBuilder()
    rb = codecs.Register(rb)
    reg := rb.Build()
    client, err := mongo.NewClientWithOptions("mongodb://localhost:27017",
        &options.ClientOptions{
            Registry: reg,
        })
    if err != nil {
        log.Fatalf("failed to create new MongoDB client: %#v", err)
    }
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()

    err = client.Connect(ctx)
    if err != nil {
        log.Fatalf("failed to connect to MongoDB: %#v", err)
    }

    log.Printf("done")

    // get collection
    coll := client.Database("experiments").Collection("proto")

    t := time.Now()
    ts, _ := ptypes.TimestampProto(t)

    in := Data{
        BoolValue:   &wrappers.BoolValue{Value: true},
        BytesValue:  &wrappers.BytesValue{Value: make([]byte, 5)},
        DoubleValue: &wrappers.DoubleValue{Value: 1.2},
        FloatValue:  &wrappers.FloatValue{Value: 1.3},
        Int32Value:  &wrappers.Int32Value{Value: -12345},
        Int64Value:  &wrappers.Int64Value{Value: -123456789},
        StringValue: &wrappers.StringValue{Value: "qwerty"},
        Uint32Value: &wrappers.UInt32Value{Value: 12345},
        Uint64Value: &wrappers.UInt64Value{Value: 123456789},

        Timestamp: ts,
    }

    log.Printf("insert data into collection <experiments.proto>...")
    res, err := coll.InsertOne(ctx, &in)
    if err != nil {
        log.Fatalf("insert data into collection <experiments.proto>: %#v", err)
    }
    id := res.InsertedID
    log.Printf("done, id=%s", id.(primitive.ObjectID).Hex())

    var out Data
    filter := bson.D{{Key: "_id", Value: id}}
    cur := coll.FindOne(ctx, filter)

    log.Printf("selecting data with id=%s from  collection <experiments.proto>...", id.(primitive.ObjectID).Hex())
    err = cur.Decode(&out)
    if err != nil {
        log.Fatalf("failed to get data (id=%#v) from collection <experiments.proto>: %#v", id, err)
    }

    log.Printf("done")
}