package gateway

import (
	"errors"
	"fmt"
	"io/ioutil"
	"os"
	"os/exec"
	"strconv"
	"text/template"
	"time"

	"veyron2/rt"
	"veyron2/services/proximity"
	"veyron2/vlog"

	dbus "github.com/guelfey/go.dbus"
)

const (
	ipFwdFile  = "/proc/sys/net/ipv4/ip_forward"
	pingTarget = "www.google.com"
	bridgeName = "napbr0"
	// TODO(spetrovic): Instead of statically assigned addresses, scan
	// over all existing interfaces and find the one that's surely unused.
	bridgeIPAddr        = "192.168.9.1"
	bridgeIPSubnetShort = "192.168.9.0"
	bridgeIPSubnetLong  = "192.168.9.0/24"
	bridgeIPMask        = "255.255.255.0"
	bridgeIPBroadcast   = "192.168.9.255"
	bridgeDHCPStart     = "192.168.9.2"
	bridgeDHCPEnd       = "192.168.9.254"
	dhcpdTemplateStr    = `
# dhcpd config for the NAP bridge interface {{.Bridge}}
#
# {{.Bridge}} ip addr is expected to be {{.IPAddr}}
# serves {{.IPAddrStart}} - {{.IPAddrEnd}}

authoritative;

subnet {{.Subnet}} netmask {{.Netmask}} {
  interface "{{.Bridge}}";
  range {{.IPAddrStart}} {{.IPAddrEnd}};
  option routers {{.IPAddr}};
  option broadcast-address {{.Broadcast}};
}`
	bridgeUpTemplateStr = `
#!/bin/bash
# Script that creates and configures the bridge interface.

brctl addbr {{.Bridge}}
ifconfig {{.Bridge}} inet {{.BridgeAddr}} netmask {{.BridgeMask}} up
`
	bridgeDownTemplateStr = `
#!/bin/bash
# Script that creates and configures the bridge interface.

ifconfig {{.Bridge}} down
brctl delbr {{.Bridge}}
`
	natStartTemplateStr = `
#!/bin/bash
# Script that turns this server's NAT role on.
cp -f {{.IPFwdFile}} {{.IPFwdFile}}.old
echo "1" > {{.IPFwdFile}}
iptables -t nat -A POSTROUTING -s {{.BridgeSubnet}} -j MASQUERADE
iptables -A FORWARD -i {{.Bridge}} -o {{.Gateway}} -j ACCEPT
iptables -A FORWARD -o {{.Bridge}} -i {{.Gateway}} -j ACCEPT
`
	natStopTemplateStr = `
#!/bin/bash
# Script that turns this server's NAT role off.
cp -f {{.IPFwdFile}}.old {{.IPFwdFile}}
iptables -t nat -D POSTROUTING -s {{.BridgeSubnet}} -j MASQUERADE
iptables -D FORWARD -i {{.Bridge}} -o {{.Gateway}} -j ACCEPT
iptables -D FORWARD -o {{.Bridge}} -i {{.Gateway}} -j ACCEPT
`
)

var (
	dhcpdConfig        string
	dhcpdTemplate      = template.Must(template.New("dhcpd").Parse(dhcpdTemplateStr))
	bridgeUpTemplate   = template.Must(template.New("bridgeUp").Parse(bridgeUpTemplateStr))
	bridgeDownTemplate = template.Must(template.New("bridgeDown").Parse(bridgeDownTemplateStr))
	natStartTemplate   = template.Must(template.New("natStart").Parse(natStartTemplateStr))
	natStopTemplate    = template.Must(template.New("natStop").Parse(natStopTemplateStr))
)

func init() {
	d := struct {
		Bridge, IPAddr, IPAddrStart, IPAddrEnd, Subnet, Netmask, Broadcast string
	}{
		bridgeName, bridgeIPAddr, bridgeDHCPStart, bridgeDHCPEnd, bridgeIPSubnetShort, bridgeIPMask, bridgeIPBroadcast,
	}
	var err error
	if dhcpdConfig, err = fileFromTemplate(dhcpdTemplate, d, 0644); err != nil {
		panic(err)
	}
}

func newServer(p proximity.Proximity, gateway, device string) (*server, error) {
	s := &server{
		proximity: p,
		gateway:   gateway,
		device:    device,
		done:      make(chan bool),
	}
	err := s.configureBluetooth()
	if err == nil {
		err = s.bridgeUp()
	}
	if err == nil {
		err = s.startNAT()
	}
	if err == nil {
		err = s.startDHCP()
	}
	if err == nil {
		err = s.startNAP()
	}
	if err != nil {
		s.Stop()
		return nil, err
	}
	go s.rttLoop()
	return s, nil
}

type server struct {
	proximity       proximity.Proximity
	gateway, device string
	dhcpCmd         *exec.Cmd
	oldFwdVal       []byte
	conn            *dbus.Conn
	done            chan bool
	advertisedName  string
}

func (s *server) Stop() {
	s.stopNAP()
	s.stopDHCP()
	s.stopNAT()
	s.bridgeDown()
	close(s.done) // terminates rttLoop
}

func (s *server) bridgeUp() error {
	d := struct {
		Bridge, BridgeAddr, BridgeMask string
	}{
		bridgeName, bridgeIPAddr, bridgeIPMask,
	}
	if err := runScript(bridgeUpTemplate, d); err != nil {
		return fmt.Errorf("couldn't create bridge: %v", err)
	}
	return nil
}

func (s *server) bridgeDown() {
	d := struct {
		Bridge string
	}{
		bridgeName,
	}
	runScript(bridgeDownTemplate, d)
}

func (s *server) startNAT() error {
	d := struct {
		IPFwdFile, Bridge, Gateway, BridgeSubnet string
	}{
		ipFwdFile, bridgeName, s.gateway, bridgeIPSubnetLong,
	}
	if err := runScript(natStartTemplate, d); err != nil {
		return fmt.Errorf("couldn't start NAT: %v", err)
	}
	return nil
}

func (s *server) stopNAT() {
	d := struct {
		IPFwdFile, Bridge, Gateway, BridgeSubnet string
	}{
		ipFwdFile, bridgeName, s.gateway, bridgeIPSubnetLong,
	}
	runScript(natStopTemplate, d)
}

func (s *server) startDHCP() error {
	s.dhcpCmd = exec.Command("dhcpd", "-cf", dhcpdConfig, "-f", bridgeName)
	if err := s.dhcpCmd.Start(); err != nil {
		return fmt.Errorf("couldn't start dhcpd on bridge %q: %v", bridgeName, err)
	}
	return nil
}

func (s *server) stopDHCP() {
	if s.dhcpCmd == nil || s.dhcpCmd.Process == nil {
		// dhcpd not started?
		return
	}
	s.dhcpCmd.Process.Kill()
}

func (s *server) configureBluetooth() error {
	if err := exec.Command("hciconfig", s.device, "piscan").Run(); err != nil {
		return fmt.Errorf("couldn't make Bluetooth device %q discoverable: %v", s.device, err)
	}
	return nil
}

func (s *server) startNAP() error {
	var err error
	if s.conn, err = dbus.SystemBus(); err != nil {
		return fmt.Errorf("couldn't access system dbus: %v", err)
	}
	// Get the adapter.
	obj := s.conn.Object("org.bluez", dbus.ObjectPath("/"))
	var adapterPath dbus.ObjectPath
	if err := obj.Call("org.bluez.Manager.DefaultAdapter", 0).Store(&adapterPath); err != nil {
		return fmt.Errorf("couldn't find device %q: %v", s.device, err)
	}
	adapter := s.conn.Object("org.bluez", adapterPath)
	// Add a bluetooth agent.
	agent := &yesAgent{}
	if err = s.conn.Export(agent, agentPath, agentIface); err != nil {
		return fmt.Errorf("error exporting agent to dbus: %v", err)
	}
	if call := adapter.Call("org.bluez.Adapter.RegisterAgent", 0, agentPath, "NoInputNoOutput"); call.Err != nil {
		return fmt.Errorf("couldn't register agent: %v", call.Err)
	}
	// Register the NAP server.
	if call := adapter.Call("org.bluez.NetworkServer.Register", 0, "nap", bridgeName); call.Err != nil {
		return fmt.Errorf("couldn't start NAP server: %v", call.Err)
	}
	return nil
}

func (s *server) stopNAP() {
	if s.conn == nil {
		return
	}
	// Unregister the NAP server.
	obj := s.conn.Object("org.bluez", dbus.ObjectPath(fmt.Sprintf("/org/bluez/%s", s.device)))
	obj.Call("org.bluez.NetworkServer.Unegister", 0, "nap")

	// Remove the bluetooth agent.
	obj.Call("org.bluez.Adapter.UnregisterAgent", 0, agentPath)
	s.conn.Export(nil, agentPath, agentIface)
}

func (s *server) rttLoop() {
	defer vlog.VI(1).Info("gateway server's RTT loop exiting")
	for {
		select {
		case <-s.done:
			return
		case <-time.After(1 * time.Second):
		}

		rtt, err := rtt()
		if err != nil {
			vlog.Errorf("error getting RTT: %v", err)
			s.advertiseName("")
		} else {
			s.advertiseName(nameFromRTT(rtt))
		}
	}
}

func (s *server) advertiseName(name string) {
	if s.advertisedName != "" {
		if err := s.proximity.UnregisterName(rt.R().TODOContext(), s.advertisedName); err != nil {
			vlog.Errorf("error unregistering name %q with proximity service: %v", s.advertisedName, err)
		}
	}
	s.advertisedName = ""
	if name != "" {
		if err := s.proximity.RegisterName(rt.R().TODOContext(), name); err == nil {
			s.advertisedName = name
		} else {
			vlog.Errorf("error registering name %q with proximity service: %v", name, err)
		}
	}
}

func runScript(t *template.Template, data interface{}) error {
	fname, err := fileFromTemplate(t, data, 0777)
	if err != nil {
		return fmt.Errorf("couldn't create template file: %v", err)
	}
	defer os.Remove(fname)
	if err := exec.Command("bash", fname).Run(); err != nil {
		return fmt.Errorf("couldn't execute script %q: %v", fname, err)
	}
	return nil
}

func fileFromTemplate(t *template.Template, data interface{}, perm os.FileMode) (string, error) {
	// Create temp file and set the right permissions on it.
	f, err := ioutil.TempFile("", "tmp")
	if err != nil {
		return "", fmt.Errorf("couldn't create temp file: %v", err)
	}
	if err := os.Chmod(f.Name(), perm); err != nil {
		f.Close()
		os.Remove(f.Name())
		return "", fmt.Errorf("couldn't change permissions on file %q to %v: err", f.Name(), perm, err)
	}

	// Execute the template and write it out into the temp file.
	if err := t.Execute(f, data); err != nil {
		f.Close()
		os.Remove(f.Name())
		return "", err
	}
	return f.Name(), nil
}

func rtt() (time.Duration, error) {
	v, err := ping(pingTarget)
	if err != nil {
		return 0, fmt.Errorf("error executing RTT command: %v", err)
	}
	if len(v) == 0 {
		return 0, errors.New("got empty RTT value")
	}
	f, err := strconv.ParseFloat(v, 64)
	if err != nil {
		return 0, fmt.Errorf("error parsing RTT value %q: %v", v, err)
	}
	if f < 0 {
		return 0, fmt.Errorf("negative RTT value: %f", f)
	}
	return time.Duration(int(f+0.5)) * time.Millisecond, nil
}