package main

import (
  "encoding/json"
  "fmt"
  "time"

  "cloud.google.com/go/bigquery"
  "cloud.google.com/go/bigquery/storage/managedwriter/adapt"
  "google.golang.org/protobuf/encoding/protojson"
  "google.golang.org/protobuf/proto"
  "google.golang.org/protobuf/reflect/protoreflect"
  "google.golang.org/protobuf/types/descriptorpb"
  "google.golang.org/protobuf/types/dynamicpb"
)

func main() {
  type Row struct {
    Inserted time.Time `bigquery:"inserted" json:"inserted"`
    Msg      string    `bigquery:"msg" json:"msg"`
  }

  schema, err := bigquery.InferSchema(Row{})
  if err != nil {
    panic(fmt.Errorf("inferring bq schema: %w", err))
  }

  schemaJSON, err := schema.ToJSONFields()
  if err != nil {
    panic(fmt.Errorf("encoding schema: %w", err))
  }
  fmt.Printf("schema: %s\n", string(schemaJSON))

  msgDesc, _, err := dynamicTableDescriptor(schema)
  if err != nil {
    panic(err)
  }

  msg := dynamicpb.NewMessage(msgDesc)
  if _, err = dynamicProtobuf(Row{time.Now(), "hello"}, msg); err != nil {
    panic(fmt.Errorf("encoding row: %w", err))
  }
}

func dynamicTableDescriptor(schema bigquery.Schema) (protoreflect.MessageDescriptor, *descriptorpb.DescriptorProto, error) {
  convertedSchema, err := adapt.BQSchemaToStorageTableSchema(schema)
  if err != nil {
    return nil, nil, fmt.Errorf("converting schema to protobuf: %w", err)
  }

  descriptor, err := adapt.StorageSchemaToProto2Descriptor(convertedSchema, "test")
  if err != nil {
    return nil, nil, fmt.Errorf("adapting converted schema to descriptor: %w", err)
  }

  messageDescriptor, ok := descriptor.(protoreflect.MessageDescriptor)
  if !ok {
    return nil, nil, fmt.Errorf("adapted descriptor is not a message descriptor: %T", descriptor)
  }

  dp, err := adapt.NormalizeDescriptor(messageDescriptor)
  if err != nil {
    return nil, nil, fmt.Errorf("normalizing descriptor: %w", err)
  }
  return messageDescriptor, dp, nil
}

func dynamicProtobuf[T any](row T, msg *dynamicpb.Message) ([]byte, error) {
  buf, err := json.Marshal(row)
  if err != nil {
    return nil, fmt.Errorf("failed json encoding: %w", err)
  }

  if err := protojson.Unmarshal(buf, msg); err != nil {
    return nil, fmt.Errorf("failed protojson decoding: %w", err)
  }

  opts := proto.MarshalOptions{}

  // [proto.Size] is expensive to call, and we know that the binary encoding will
  // generally be smaller than the JSON encoding; buf should already be big enough.
  // Otherwise, it will allocate.
  buf, err = opts.MarshalAppend(buf[:0], msg)
  if err != nil {
    return nil, fmt.Errorf("failed protobuf encoding: %w", err)
  }
  return buf, nil
}