#!/usr/bin/python

import pygtk
import gtk
import gtk.glade
import gnome
import gnome.ui
import os
import commands
import dbus
import gettext
import locale
import subprocess
import gconf

locale.setlocale(locale.LC_ALL, '')
gtk.glade.bindtextdomain('aircraft-manager', '/usr/share/locale')
gtk.glade.textdomain('aircraft-manager')
gettext.install('aircraft-manager', '/usr/share/locale')

class GUI():
    """TODO"""

    def __init__(self):
        gnome.init('aircraft-manager', '1.0')

        self.initializing = True
        
        self.gconf_key_aircraft_manager_state = "/apps/airplane-manager/airplane-manager-state"
        self.gconf_key_bluetooth_am_enter_state = "/apps/airplane-manager/bluetooth-am-enter-state"
        self.gconf_key_wifi_am_enter_state = "/apps/airplane-manager/wifi-am-enter-state"
        self.gconf_key_wifi_am_state = "/apps/airplane-manager/wifi-am-state"

        self.gconf_client = gconf.client_get_default()
        
        self.glade_file = "/usr/share/aircraft-manager/ui/aircraft-manager.glade"
        self.wTree = gtk.glade.XML(self.glade_file)

        self.dialog = self.wTree.get_widget("dialog1")
        if (self.dialog):
            self.dialog.connect("delete_event", gtk.main_quit)

        self.but_OK = self.wTree.get_widget("buttonOK")
        if (self.but_OK):
            self.but_OK.connect("clicked", self.but_OK_clicked)

        self.but_cancel = self.wTree.get_widget("buttonCancel")
        if (self.but_cancel):
            self.but_cancel.connect("clicked", self.but_cancel_clicked)

        self.buttonEnterAM = self.wTree.get_widget("buttonEnterAM")
        if (self.buttonEnterAM):
            self.buttonEnterAM.connect("clicked", self.buttonEnterAM_clicked)

        self.buttonExitAM = self.wTree.get_widget("buttonExitAM")
        if (self.buttonExitAM):
            self.buttonExitAM.connect("clicked", self.buttonExitAM_clicked)

        self.labelAircraftMode= self.wTree.get_widget("labelAircraftMode")

        self.cbBT = self.wTree.get_widget("checkbuttonBT")
        self.cbWIFI = self.wTree.get_widget("checkbuttonWifi")

        self.cb_wifi_airplane = self.wTree.get_widget("checkbutton_wifi_airplane")
        if (self.cb_wifi_airplane):
            self.cb_wifi_airplane.connect("clicked", self.cb_wifi_airplane_clicked)

        # get wifi am state on launch so OK and Cancel buttons can be enabled/disabled
        # when user changes to new state or reverts to initial
        self.gconf_key_wifi__in_am_init_state = self.gconf_client.get_bool(self.gconf_key_wifi_am_state)

        #set check boxes to actual radio power state, before signals are connected
        self.cbBT.set_active(self.getBtState())
        self.cbWIFI.set_active(self.getWifiState())

        self.vboxRadioPower = self.wTree.get_widget("vboxRadioPower")
        self.notebook1 = self.wTree.get_widget("notebook1")

        # determine if we are in aircraft mode, and if so do the right things

        self.current_am_state = self.gconf_client.get_bool(self.gconf_key_aircraft_manager_state)
        #print "current am state: " + str(self.current_am_state)

        self.nextAMstate = None
        if self.current_am_state:
            self.aircraftMode = True
            self.buttonExitAM.show()
            self.buttonEnterAM.hide()
            self.labelAircraftMode.set_label(_("Airplane Mode: <span weight='bold'>Enabled</span>"))
            self.cb_wifi_airplane.set_active(self.gconf_client.get_bool(self.gconf_key_wifi_am_state))
        else: 
            self.aircraftMode = False
            self.buttonExitAM.hide()
            self.buttonEnterAM.show()
            self.labelAircraftMode.set_label(_("Airplane Mode: <span weight='bold'>Disabled</span>"))

        if self.aircraftMode: 
            self.vboxRadioPower.set_sensitive(False)
            self.notebook1.set_current_page(1)
            self.but_OK.set_sensitive(False)
            self.but_cancel.set_sensitive(False)

        self.initializing = False

        return None

    def cb_wifi_airplane_clicked(self, widget):
        if not self.aircraftMode or self.initializing:
            return None
        if widget.get_active():
            if self.gconf_key_wifi__in_am_init_state:
                self.but_OK.set_sensitive(False)
                self.but_cancel.set_sensitive(False)
            else:
                self.but_OK.set_sensitive(True)
                self.but_cancel.set_sensitive(True)
        else:
            if self.gconf_key_wifi__in_am_init_state:
                self.but_OK.set_sensitive(True)
                self.but_cancel.set_sensitive(True)
            else:
                self.but_OK.set_sensitive(False)
                self.but_cancel.set_sensitive(False)
        return None

    def buttonEnterAM_clicked(self, widget):
        self.nextAMstate = True
        self.but_OK_was_clicked = False
        self.finish_UI()
        return None

    def buttonExitAM_clicked(self, widget):
        self.nextAMstate = False
        self.but_OK_was_clicked = False
        self.finish_UI()
        return None

    def but_OK_clicked(self, widget):
        self.but_OK_was_clicked = True
        self.finish_UI()
        return None 

    def finish_UI(self):

        # ---- Aircraft mode ---- #

        nextStateIsAM = self.nextAMstate

        if (not self.aircraftMode) and nextStateIsAM and not self.but_OK_was_clicked: 
            # turn aircraft mode on, which means save current radio status and shut off radios

            # saved aircraft mode as True to gconf key
            self.gconf_client.set_bool(self.gconf_key_aircraft_manager_state, True)

            #write current radio state to gconf keys

            self.gconf_client.set_bool(self.gconf_key_bluetooth_am_enter_state, self.cbBT.get_active())
            self.gconf_client.set_bool(self.gconf_key_wifi_am_enter_state, self.cbWIFI.get_active())

            # save wifi_airplane_mode from checkbox to gconf key
            self.gconf_client.set_bool(self.gconf_key_wifi_am_state, self.cb_wifi_airplane.get_active())

            cmd = 'echo ' + \
                '"BT:"' + str(self.cbBT.get_active()) + '"\n"' + \
                '"WIFI:"' + str(self.cbWIFI.get_active()) + '"\n"' + \
                '> /usr/share/aircraft-manager/radioStates'
            #print "write radioStates: " + cmd
            os.system(cmd)

            #turn off AC charging
            self.ac_charging_off()

            #shut off radios that are on

            if self.getBtState(): 
                self.bluetooth_off()

            #Don't shut off wifi if wifi_airplane is enabled
            if self.getWifiState() and not self.cb_wifi_airplane.get_active(): 
                self.wifi_off()

            gtk.main_quit()
            return None
        
        if (self.aircraftMode) and (not nextStateIsAM) and not self.but_OK_was_clicked:
            
            #turn aircraft mode off

            # saved aircraft mode as False to gconf key  
            self.gconf_client.set_bool(self.gconf_key_aircraft_manager_state, False)

            # set wifi_airplane_mode gconf to false as default when not in aircrat mode
            self.gconf_client.set_bool(self.gconf_key_wifi_am_state, False)

            #turn on AC charging
            self.ac_charging_on()   

            # get radio state on entering aircraft mode and turn on those that should be on     
            if self.gconf_client.get_bool(self.gconf_key_bluetooth_am_enter_state):
                self.bluetooth_on()
            #turn on wifi if it was on before being in aircraft mode or if wifi was on in am
            if self.gconf_client.get_bool(self.gconf_key_wifi_am_enter_state) or \
                self.gconf_client.get_bool(self.gconf_key_wifi_am_state):
                self.wifi_on()

            gtk.main_quit()
            return None

        # if in aircraft mode but not leaving or entering, user may have enabled/disable
        # wifi in aircraft mode, so check and do the right things
        if self.aircraftMode and self.but_OK_was_clicked:
            wifi_am_gconf = self.gconf_client.get_bool(self.gconf_key_wifi_am_state)
            #print "wifi_am_gconf: " + str(wifi_am_gconf)
        
            if self.cb_wifi_airplane.get_active() and not wifi_am_gconf:
                self.wifi_on()
                self.gconf_client.set_bool(self.gconf_key_wifi_am_state, True)
            if not self.cb_wifi_airplane.get_active() and wifi_am_gconf:
                print "trying to turn wif off"
                self.wifi_off()
                self.gconf_client.set_bool(self.gconf_key_wifi_am_state, False)

            gtk.main_quit()
            return None
   

        # ---- Not Entering or Exiting or In Aircraft Mode ---- #

        #At this point, user is neither entering nor exiting aircraft mode. 
        #So, turn on/off radios according to UI control states
        
        #Wifi
        if self.cbWIFI.get_active() and (not self.getWifiState()): self.wifi_on()
        if (not self.cbWIFI.get_active()) and (self.getWifiState()): self.wifi_off()

        #Bluetooth
        if self.cbBT.get_active() and (not self.getBtState()): 
            self.bluetooth_on()
        if (not self.cbBT.get_active()) and (self.getBtState()): 

            self.bluetooth_off()

        gtk.main_quit()
        
        return None

    def bluetooth_on(self):
        cmd = ["/usr/bin/gksu", 
               "/usr/bin/aircraft-manager-util BT on", 
               "--"]
        ret = subprocess.call(cmd)
        return None 

    def bluetooth_off(self):
        cmd = ["/usr/bin/gksu", 
               "/usr/bin/aircraft-manager-util BT off", 
               "--"]
        ret = subprocess.call(cmd)
        return None 

    def wifi_on(self):
        cmd = ["/usr/bin/gksu", 
               "/usr/bin/aircraft-manager-util WIFI on", 
               "--"]
        ret = subprocess.call(cmd)
        return None 

    def wifi_off(self):
        cmd = ["/usr/bin/gksu", 
               "/usr/bin/aircraft-manager-util WIFI off", 
               "--"]
        ret = subprocess.call(cmd)
        return None 

    def ac_charging_on(self):
        cmd = ["/usr/bin/gksu", 
               "/usr/bin/aircraft-manager-util AC_CHARGING on", 
               "--"]
        ret = subprocess.call(cmd)
        return None 

    def ac_charging_off(self):
        cmd = ["/usr/bin/gksu", 
               "/usr/bin/aircraft-manager-util AC_CHARGING off", 
               "--"]
        ret = subprocess.call(cmd)
        return None 

    def but_cancel_clicked(self, widget):
        gtk.main_quit()
        return None         

    # get states

    def getBtState(self):
        res = str(commands.getoutput("ps -A | grep -c bluetoothd-serv"))
        if res==str(0): return False
        else: return True

    def getWifiState(self):
        # create remote dbus object for network manager
        bus = dbus.SystemBus()
        nm = bus.get_object('org.freedesktop.NetworkManager', '/org/freedesktop/NetworkManager')
        nmOutput = nm.getWirelessEnabled()
        return nmOutput[0]

    def run(self):
        gtk.main()
        return None 

if __name__ == "__main__":
    app = GUI()
    app.run()

