package main

import "fmt"
import "net"
import "time"
import "flag"
import "os"
import "runtime/pprof"

import "golang.org/x/net/ipv6"

// TODO look into netmap + libpcap to bypass the kernel as much as possible

func basic_test() {

  // TODO need a way to look up who our link-local neighbors are for each iface!

  udpAddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:0")
  if err != nil { panic(err) }
  sock, err := net.ListenUDP("udp", udpAddr)
  if err != nil { panic(err) }
  defer sock.Close()

  writer := func () {
    raddr := sock.LocalAddr().(*net.UDPAddr)
    send, err := net.ListenUDP("udp", nil)
    if err != nil { panic(err) }
    defer send.Close()
    conn := ipv6.NewPacketConn(send)
    defer conn.Close()
    var msgs []ipv6.Message
    for idx := 0 ; idx < 1024 ; idx++ {
      msg := ipv6.Message{Addr: raddr, Buffers: [][]byte{make([]byte, 1280)}}
      msgs = append(msgs, msg)
    }
    for {
      /*
      var msgs []ipv6.Message
      for idx := 0 ; idx < 1024 ; idx++ {
        msg := ipv6.Message{Addr: raddr, Buffers: [][]byte{make([]byte, 1280)}}
        msgs = append(msgs, msg)
      }
      */
      conn.WriteBatch(msgs, 0)
    }

  }
  go writer()
  //go writer()
  //go writer()
  //go writer()

  numPackets := 65536
  size := 0
  count := 0
  start := time.Now()
  /*
  conn := ipv6.NewPacketConn(sock)
  defer conn.Close()
  for ; count < numPackets ; count++ {
    msgs := make([]ipv6.Message, 1024)
    for _, msg := range msgs {
      msg.Buffers = append(msg.Buffers, make([]byte, 2048))
    }
    n, err := conn.ReadBatch(msgs, 0)
    if err != nil { panic(err) }
    fmt.Println("DEBUG: n", n)
    for _, msg := range msgs[:n] {
      fmt.Println("DEBUG: msg", msg)
      size += msg.N
      //for _, bs := range msg.Buffers {
      //  size += len(bs)
      //}
      count++
    }
  }
  //*/
  //*
  for ; count < numPackets ; count++ {
    msg := make([]byte, 2048)
    n, _, err := sock.ReadFromUDP(msg)
    if err != nil { panic(err) }
    size += n
  }
  //*/
  timed := time.Since(start)

  fmt.Printf("%f packets per second\n", float64(count)/timed.Seconds())
  fmt.Printf("%f bits/second\n", float64(8*size)/timed.Seconds())
}

var cpuprofile = flag.String("cpuprofile", "", "write cpu profile `file`")
var memprofile = flag.String("memprofile", "", "write memory profile to this file")

func main () {
  flag.Parse()
  if *cpuprofile != "" {
      f, err := os.Create(*cpuprofile)
      if err != nil {
          panic(fmt.Sprintf("could not create CPU profile: ", err))
      }
      if err := pprof.StartCPUProfile(f); err != nil {
          panic(fmt.Sprintf("could not start CPU profile: ", err))
      }
      defer pprof.StopCPUProfile()
  }
  if *memprofile != "" {
      f, err := os.Create(*memprofile)
      if err != nil {
          panic(fmt.Sprintf("could not create memory profile: ", err))
      }
      defer func () { pprof.WriteHeapProfile(f) ; f.Close() }()
  }
  basic_test()

}