#!/usr/bin/python3
# -*- coding: utf-8 -*-
from gi.repository import Gtk

import gettext
import os
import re
import sys

_ = gettext.gettext
gettext.textdomain("arkose-gui")

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"])

    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 not separate_home:
    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",
                     "XDG_RUNTIME_DIR", "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)
