package main

import "bytes"
import "encoding/hex"
import "encoding/json"
import "flag"
import "fmt"
import "io/ioutil"
import "net"
import "os"
import "os/signal"
import "time"

import _ "net/http/pprof"
import "net/http"
import "log"
import "runtime"

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

import . "yggdrasil"

/**
* This is a very crude wrapper around src/yggdrasil
* It can generate a new config (--genconf)
* It can read a config from stdin (--useconf)
* It can run with an automatic config (--autoconf)
*/

type nodeConfig struct {
  Listen string
  Peers []string
  BoxPub string
  BoxPriv string
  SigPub string
  SigPriv string
  Multicast bool
}

type node struct {
  core Core
  sock *ipv6.PacketConn
}

func (n *node) init(cfg *nodeConfig, logger *log.Logger) {
  boxPub, err := hex.DecodeString(cfg.BoxPub)
  if err != nil { panic(err) }
  boxPriv, err := hex.DecodeString(cfg.BoxPriv)
  if err != nil { panic(err) }
  sigPub, err := hex.DecodeString(cfg.SigPub)
  if err != nil { panic(err) }
  sigPriv, err := hex.DecodeString(cfg.SigPriv)
  if err != nil { panic(err) }
  n.core.DEBUG_init(boxPub, boxPriv, sigPub, sigPriv)
  n.core.DEBUG_setLogger(logger)
  logger.Println("Starting interface...")
  n.core.DEBUG_setupAndStartGlobalUDPInterface(cfg.Listen)
  logger.Println("Started interface")
  go func () {
    if len(cfg.Peers) == 0 { return }
    for {
      for _, p := range cfg.Peers {
        n.core.DEBUG_sendUDPKeys(p)
        time.Sleep(time.Second)
      }
    }
  }()
}

func generateConfig() *nodeConfig {
  core := Core{}
  bpub, bpriv := core.DEBUG_newBoxKeys()
  spub, spriv := core.DEBUG_newSigKeys()
  cfg := nodeConfig{}
  cfg.Listen = "[::]:0"
  cfg.BoxPub = hex.EncodeToString(bpub[:])
  cfg.BoxPriv = hex.EncodeToString(bpriv[:])
  cfg.SigPub = hex.EncodeToString(spub[:])
  cfg.SigPriv = hex.EncodeToString(spriv[:])
  cfg.Peers = []string{}
  cfg.Multicast = true
  return &cfg
}

func doGenconf() string {
  cfg := generateConfig()
  bs, err := json.MarshalIndent(cfg, "", "  ")
  if err != nil { panic(err) }
  return string(bs)
}

var multicastAddr = "[ff02::114]:9001"

func (n *node) listen() {
  groupAddr, err := net.ResolveUDPAddr("udp6", multicastAddr)
  if err != nil { panic(err) }
  bs := make([]byte, 2048)
  for {
    nBytes, rcm, fromAddr, err := n.sock.ReadFrom(bs)
    if err != nil { panic(err) }
    //if rcm == nil { continue } // wat
    //fmt.Println("DEBUG:", "packet from:", fromAddr.String())
    if !rcm.Dst.IsLinkLocalMulticast() { continue }
    if !rcm.Dst.Equal(groupAddr.IP) { continue }
    anAddr := string(bs[:nBytes])
    addr, err := net.ResolveUDPAddr("udp6", anAddr)
    if err != nil { panic(err) ; continue } // Panic for testing, remove later
    from := fromAddr.(*net.UDPAddr)
    //fmt.Println("DEBUG:", "heard:", addr.IP.String(), "from:", from.IP.String())
    if addr.IP.String() != from.IP.String() { continue }
    addr.Zone = from.Zone
    saddr := addr.String()
    //if _, isIn := n.peers[saddr]; isIn { continue }
    //n.peers[saddr] = struct{}{}
    n.core.DEBUG_sendUDPKeys(saddr)
    //fmt.Println("DEBUG:", "added multicast peer:", saddr)
  }
}

func (n *node) announce() {
  groupAddr, err := net.ResolveUDPAddr("udp6", multicastAddr)
  if err != nil { panic(err) }
  udpaddr := n.core.DEBUG_getGlobalUDPAddr()
  anAddr, err := net.ResolveUDPAddr("udp6", udpaddr.String())
  if err != nil { panic(err) }
  destAddr, err := net.ResolveUDPAddr("udp6", multicastAddr)
  if err != nil { panic(err) }
  for {
    ifaces, err := net.Interfaces()
    if err != nil { panic(err) }
    for _, iface := range ifaces {
      n.sock.JoinGroup(&iface, groupAddr)
      //err := n.sock.JoinGroup(&iface, groupAddr)
      //if err != nil { panic(err) }
      addrs, err := iface.Addrs()
      if err != nil { panic(err) }
      for _, addr := range addrs {
        addrIP, _, _ := net.ParseCIDR(addr.String())
        if addrIP.To4() != nil { continue } // IPv6 only
        if !addrIP.IsLinkLocalUnicast() { continue }
        anAddr.IP = addrIP
        anAddr.Zone = iface.Name
        destAddr.Zone = iface.Name
        msg := []byte(anAddr.String())
        n.sock.WriteTo(msg, nil, destAddr)
        break
      }
      time.Sleep(time.Second)
    }
    time.Sleep(time.Second)
  }
}

var pprof = flag.Bool("pprof", false, "Run pprof, see http://localhost:6060/debug/pprof/")
var genconf = flag.Bool("genconf", false, "print a new config to stdout")
var useconf = flag.Bool("useconf", false, "read config from stdin")
var autoconf = flag.Bool("autoconf", false, "automatic mode (dynamic IP, peer with IPv6 neighbors)")

func main() {
  flag.Parse()
  var cfg *nodeConfig
  switch {
    case *autoconf: cfg = generateConfig()
    case *useconf:
      config, err := ioutil.ReadAll(os.Stdin)
      if err != nil { panic(err) }
      decoder := json.NewDecoder(bytes.NewReader(config))
      err = decoder.Decode(&cfg)
      if err != nil { panic(err) }
    case *genconf: fmt.Println(doGenconf())
    default: flag.PrintDefaults()
  }
  if cfg == nil { return }
  logger := log.New(os.Stdout, "", log.Flags())
  if *pprof {
    runtime.SetBlockProfileRate(1)
    go func() { log.Println(http.ListenAndServe("localhost:6060", nil)) }()
  }
  // Setup
  logger.Println("Initializing...")
  n := node{}
  n.init(cfg, logger)
  logger.Println("Starting tun...")
  n.core.DEBUG_startTun() // 1280, the smallest supported MTU
  //n.core.DEBUG_startTunWithMTU(65535) // Largest supported MTU
  defer func() { 
    logger.Println("Closing...")
    n.core.DEBUG_stopTun()
  }()
  logger.Println("Started...")
  if cfg.Multicast {
    addr, err := net.ResolveUDPAddr("udp", multicastAddr)
    if err != nil { panic(err) }
    listenString := fmt.Sprintf("[::]:%v", addr.Port)
    conn, err := net.ListenPacket("udp6", listenString)
    if err != nil { panic(err) }
    //defer conn.Close() // Let it close on its own when the application exits
    n.sock = ipv6.NewPacketConn(conn)
	  if err = n.sock.SetControlMessage(ipv6.FlagDst, true) ; err != nil { panic(err) }
    go n.listen()
    go n.announce()
  }
  // Catch interrupt to exit gracefully
  c := make(chan os.Signal, 1)
  signal.Notify(c, os.Interrupt)
  <-c
  logger.Println("Stopping...")
}