#!/usr/bin/python
# -*- coding: utf-8 -*-
import sys, os, re, gettext

from gettext import gettext as _
gettext.textdomain("arkose-gui")

try:
    from gi.repository import Gtk as gtk
except ImportError:
    import gtk

builder = gtk.Builder()
builder.set_translation_domain("arkose-gui")
if os.path.exists("gui/arkose-gui.xml"):
    xml_file = "gui/arkose-gui.xml"
elif os.path.exists("/usr/share/arkose/gui/arkose-gui.xml"):
    xml_file = "/usr/share/arkose/gui/arkose-gui.xml"
else:
    print(_("Unable to find .xml UI file"))
    sys.exit(1)

builder.add_from_file(xml_file)

winArkose = builder.get_object("winArkose")
ckNetwork = builder.get_object("ckNetwork")
ckHome = builder.get_object("ckHome")
ckTmp = builder.get_object("ckTmp")
eCmd = builder.get_object("eCmd")
spnSize = builder.get_object("spnSize")
adjSize = builder.get_object("adjSize")
rbExt4 = builder.get_object("rbExt4")
rbTmpfs = builder.get_object("rbTmpfs")
hbType = builder.get_object("hbType")
lblWarning = builder.get_object("lblWarning")
lblSocket = builder.get_object("lblSocket")
start = False

def default_memory():
    meminfo = open("/proc/meminfo", "r")
    meminfo_dict = {}
    for line in meminfo.readlines():
        values = line.split(":")
        meminfo_dict[values[0]] = values[1].split()[0].strip()
    meminfo.close()
    return ((int(meminfo_dict['MemFree']) + int(meminfo_dict['Buffers']) + int(meminfo_dict['Cached'])) / 1024 / 2)

def socket_support():
    minimal_version = 36
    version_long = open("/proc/version", "r").read().split()[2]
    try:
        version = int(re.split(".*2.6.([0-9]*).*", version_long)[1])
    except:
        version = 99
    return version >= minimal_version

def show_about(button):
    about = gtk.AboutDialog()
    about.set_name("Arkose")
    about.set_version("1.2.3")
    about.set_copyright("Copyright © 2010 Stéphane Graber")
    about.set_website("http://www.stgraber.org")
    about.set_comments(_("A tool to create desktop sandboxes."))
    about.set_authors(["Stéphane Graber"])

    retval = about.run()
    about.hide()

def execute(button):
    global start
    start = True
    winArkose.hide()
    gtk.main_quit()

builder.connect_signals({
    "on_winArkose_destroy" : gtk.main_quit,
    "on_btnAbout_clicked" : show_about,
    "on_btnCancel_clicked" : gtk.main_quit,
    "on_eCmd_activate" : execute,
    "on_btnExec_clicked" : execute,
})

# Set default values
adjSize.set_value(default_memory())

if len(sys.argv) > 1:
    eCmd.set_text(' '.join(sys.argv[1:]))

# Check if /home is on a separate partition
separate_home = False
mounts = open("/proc/mounts", "r")
for line in mounts.readlines():
    fields = line.split()
    if fields[1] == '/home':
        separate_home = True
        break

if separate_home == False:
    rbTmpfs.set_active(True)
    hbType.set_visible(False)
    lblWarning.set_visible(True)

if socket_support():
    lblSocket.set_markup(_("To be able to start graphical software on your current kernel,\nyou'll need either <b>network support</b> or <b>real /tmp</b>."))
else:
    lblSocket.set_markup(_("To be able to start graphical software on your current kernel,\nyou'll need <b>network support</b>."))

winArkose.show()

gtk.main()

if start:
    if os.path.exists("cli/arkose"):
        arkose = os.path.realpath("cli/arkose")
    else:
        arkose = "arkose"

    params = []
    params += ["-s", str(int(adjSize.get_value()))]
    if ckNetwork.get_active():
        params.append("-n")

    if ckHome.get_active():
        params.append("-h")

    if ckTmp.get_active():
        params.append("-T")

    if eCmd.get_text():
        params.append("-c")
        params += eCmd.get_text().split(" ")

    # Set filesystem
    if rbExt4.get_active():
        params += ["-t", "ext4"]
    else:
        params += ["-t", "tmpfs"]

    env_whitelist = ["PWD", "PATH", "HOME", "DISPLAY", "XAUTHORITY", "PULSE_SERVER", "DBUS_SESSION_BUS_ADDRESS"]

    env = []
    for variable in env_whitelist:
        value = os.getenv(variable, None)
        if value:
            env.append("%s = %s" % (variable, value))

    cmd = ["pkexec", "env"]
    cmd += env
    cmd.append(arkose)
    cmd += params

    os.execv("/usr/bin/pkexec", cmd)
