import dbus
import dbus.service
import dbus.glib

from gi.repository import GObject


POLICY_NAME = "com.canonical.LandscapeClientSettings.configure"


class PolicyKitMechanism(dbus.service.Object):
    """
    L{PolicyKitMechanism} is a specialised L{dbus.service.Object} which
    provides PolicyKit authorization checks for a provided DBus bus name and
    object path.  Subclasses must therefore call l{__init__} here with their
    object path, bus name and an error class to be raised when permission
    escalation fails.

    @type object_path: string
    @param object_path: The object path to register the subclass with.
    @type bus_name: dbus.service.BusName
    @param bus_name: The L{BusName} to the register the subclass with.
    @type permission_error: dbus.DBusException
    @param permission_error: A L{dbus.DBusException} to be raised when
        PolicyKit authorisation fails for the client.
    """

    def __init__(self, object_path, bus_name, permission_error,
                 bypass=False, conn=None):
        super(PolicyKitMechanism, self).__init__(
            conn, object_path, bus_name)
        self.permission_error = permission_error
        self.dbus_info = None
        self.polkit = None
        self.bypass = bypass

    def _get_polkit_authorization(self, pid, privilege):
        """
        Check that the process with id L{pid} is allowed, by policy to utilise
        the L{privilege }.  If the class was initialised with L{bypass}=True
        then just say it was authorised without checking (useful for testing).
        """
        if self.bypass:
            return (True, None, "Bypass")
        polkit = dbus.Interface(dbus.SystemBus().get_object(
                'org.freedesktop.PolicyKit1',
                '/org/freedesktop/PolicyKit1/Authority', False),
                'org.freedesktop.PolicyKit1.Authority')
        subject = ('unix-process',
                   {'pid': dbus.UInt32(pid, variant_level=1),
                    'start-time': dbus.UInt64(0, variant_level=1)})
        action_id = privilege
        details = {"": ""}  # <- empty strings allow type inference
        flags = dbus.UInt32(1)
        cancellation_id = ""
        return polkit.CheckAuthorization(
            subject,
            action_id,
            details,
            flags,
            cancellation_id,
            timeout=15)

    def _get_peer_pid(self, sender, conn):
        """
        Get the process ID of the L{sender}.
        """
        if self.dbus_info is None:
            self.dbus_info = dbus.Interface(
                conn.get_object('org.freedesktop.DBus',
                '/org/freedesktop/DBus/Bus', False), 'org.freedesktop.DBus')
        return self.dbus_info.GetConnectionUnixProcessID(sender)

    def _is_local_call(self, sender, conn):
        """
        Check if this is a local call, implying it is within a secure context.
        """
        return (sender is None and conn is None)

    def _is_allowed_by_policy(self, sender, conn, privilege):
        """
        Check if we are already in a secure context, and if not check if the
        policy associated with L{privilege} both exists and allows the peer to
        utilise it.  As a side effect, if escalation of privileges is required
        then this will occur and a challenge will be generated if needs be.
        """
        if self._is_local_call(sender, conn):
            return True
        peer_pid = self._get_peer_pid(sender, conn)
        (is_auth, _, details) = self._get_polkit_authorization(peer_pid,
                                                               privilege)
        if not is_auth:
            raise self.permission_error(privilege)
        return True


def listen():
    """
    Invoke a L{gobject.MainLoop} to process incoming DBus events.
    """
    mainloop = GObject.MainLoop()
    mainloop.run()