package DBUS

import (
	"fmt"
  "strings"
	//"strconv"
	"github.com/godbus/dbus"
)

type DbusInterface struct {
	Dest string
	Path dbus.ObjectPath
	Iface string
	Obj *dbus.Object
  SigFuncs  map[string]interface{}
}

func NewDbusInterface(conn *dbus.Conn,dest string, path dbus.ObjectPath ,iface string) *DbusInterface {
  m := &DbusInterface{}
	o := conn.Object(dest,path)

	m.Obj = o.(*dbus.Object)
	m.Dest = dest
	m.Path = path
  
	m.SigFuncs = make(map[string]interface{})

	if len(iface) > 2 {
		m.Iface = iface
	}
	return m
}

func (self *DbusInterface) Method(name string, args...interface{} ) *dbus.Call {
	var method string
	if self.Iface != "" {
		method = fmt.Sprintf("%s.%s.%s", self.Dest, self.Iface,name)
	}else {
		method = fmt.Sprintf("%s.%s", self.Dest,name)
	}

	if args != nil {
		return self.Obj.Call( method , 0,args...)
	}else {
		return self.Obj.Call( method, 0)
	}
}

func (self *DbusInterface) Get( thecall *dbus.Call, retvalues ...interface{}) error {
	if len(thecall.Body) == 0 {
		return nil
	}
	err:=  thecall.Store(retvalues...)
  
	if err != nil {
		panic(fmt.Sprintf("Failed: %s,%s",err,thecall.Method))
	}
  
  return err
}

func (self *DbusInterface) EnableSignal(signame string) {
  iface := self.Dest
  if self.Iface != "" {
    iface = iface+ "."+self.Iface
  }
  self.Obj.AddMatchSignal(iface,signame)
}


func (self *DbusInterface) HandleSignal( sig *dbus.Signal) {
	
	iface := self.Dest
	if self.Iface != "" {
		iface = iface+ "."+self.Iface
	}

	if strings.HasPrefix(sig.Name,iface) {
		func_name := strings.Replace( sig.Name, iface, "",-1)[1:]
		for k,v := range self.SigFuncs {
			if k == func_name {
				v.(func([]interface{}))(sig.Body)
				break
			}
		}
	}

}

type DBusInterface interface {
	WifiStrength() int
	IsWifiConnectedNow() bool 	
}

type DBus struct {
	Conn *dbus.Conn
	Daemon *DbusInterface
  Wifi    *DbusInterface
}

func NewDBus() *DBus {
	d := &DBus{}
	return d
}

func (self *DBus) Init() {
  //conn_option := dbus.WithSignalHandler(self)
  
	conn, err := dbus.SystemBus()
  //conn,err := dbus.SystemBusPrivate(conn_option)
  
  if err != nil {
    panic(fmt.Sprintf("Failed to connect to system bus:", err))
  }

	self.Conn = conn

	self.Daemon = NewDbusInterface(conn, "org.wicd.daemon","/org/wicd/daemon" ,"",)
	self.Wifi   = NewDbusInterface(conn, "org.wicd.daemon","/org/wicd/daemon/wireless","wireless")
}

func (self *DBus) WifiStrength() int {
	var fast bool
	var iwconfig string
  var sig_display_type int
	var strength int

	self.Daemon.Get( self.Daemon.Method("NeedsExternalCalls"), &fast)

	if fast == false {
			self.Wifi.Get( self.Wifi.Method("GetIwconfig"), &iwconfig  )
	}else{
		iwconfig = ""
	}
	self.Daemon.Get( self.Daemon.Method("GetSignalDisplayType"), &sig_display_type )
	
	if sig_display_type == 0 {
		self.Wifi.Get( self.Wifi.Method("GetCurrentSignalStrength",iwconfig), &strength)
	} else{
		self.Wifi.Get( self.Wifi.Method("GetCurrentDBMStrength",iwconfig), &strength)
	}

	return strength	
}

func (self *DBus) check_for_wireless(iwconfig string, wireless_ip string)  bool {
  var network string
  var sig_display_type int
	var strength int
	if wireless_ip == "" {
		return false
	}

	self.Wifi.Get( self.Wifi.Method("GetCurrentNetwork",iwconfig), &network)
	self.Daemon.Get( self.Daemon.Method("GetSignalDisplayType"), &sig_display_type )
	
	if sig_display_type == 0 {
		self.Wifi.Get( self.Wifi.Method("GetCurrentSignalStrength",iwconfig), &strength)
	}else {
		self.Wifi.Get( self.Wifi.Method("GetCurrentDBMStrength",iwconfig), &strength)
	}

	if strength == 0 {
		return false
	}
	strength_str := ""
	self.Daemon.Get( self.Daemon.Method("FormatSignalForPrinting",strength), &strength_str)

	return true
}

func (self *DBus) GetWifiIP() string {
  var wireless_ip string
  if self.Wifi != nil {
    self.Wifi.Get( self.Wifi.Method("GetWirelessIP", ""), &wireless_ip)
  }
  return wireless_ip
  
}

func (self *DBus) IsWifiConnectedNow() bool {
  var fast bool
  var iwconfig string
  var wireless_connecting bool
	var wireless_ip string

	self.Wifi.Get( self.Wifi.Method("CheckIfWirelessConnecting"), &wireless_connecting  )
	self.Daemon.Get( self.Daemon.Method("NeedsExternalCalls"), &fast)
	if wireless_connecting == true {
		return false
	}else {
		if fast == false {
			self.Wifi.Get( self.Wifi.Method("GetIwconfig"), &iwconfig  )
		}else {
			iwconfig = ""
		}

		self.Wifi.Get( self.Wifi.Method("GetWirelessIP", iwconfig), &wireless_ip)
		
		if self.check_for_wireless(iwconfig,wireless_ip) == true {
			return true
		}else {
			return false
		}
		
	}	
}

func (self *DBus) ListenSignal() {
	c := make(chan *dbus.Signal, 10)
	self.Conn.Signal(c)
  
  for v := range c {
    //fmt.Printf("%+v %#v\n",v,v)
    //fmt.Printf("body len:%d \n\n",len(v.Body)) 
    
    self.Wifi.HandleSignal(v)
    self.Daemon.HandleSignal(v)
    
  }  
}

var DBusHandler *DBus //global 

func init() {
  if DBusHandler == nil {
    DBusHandler = NewDBus()
    DBusHandler.Init()
  
    go DBusHandler.ListenSignal()
  }
  
}