// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
/*
 * Copyright (C) 2014 Canonical Ltd
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 3 as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 * Authored by: Marco Trevisan <marco.trevisan@canonical.com>
 */

#include "SessionDBusManager.h"

namespace unity
{
namespace session
{
namespace dbus
{
const std::string NAME = "com.canonical.Unity";
const std::string INTERFACE = "com.canonical.Unity.Session";
const std::string OBJECT_PATH = "/com/canonical/Unity/Session";
const std::string INTROSPECTION_XML =
R"(<node>
  <interface name="com.canonical.Unity.Session">
    <method name="RealName">
      <arg type="s" direction="out" name="realname" />
    </method>
    <method name="UserName">
      <arg type="s" direction="out" name="username" />
    </method>
    <method name="HostName">
      <arg type="s" direction="out" name="hostname" />
    </method>
    <method name="Lock" />
    <method name="PromptLock" />
    <method name="ActivateScreenSaver" />
    <method name="DeactivateScreenSaver" />
    <method name="Logout" />
    <method name="RequestLogout" />
    <method name="Reboot" />
    <method name="RequestReboot" />
    <method name="Shutdown" />
    <method name="RequestShutdown" />
    <method name="Suspend" />
    <method name="Hibernate" />
    <method name="CancelAction" />
    <method name="CanShutdown">
      <arg type="b" direction="out" name="canshutdown" />
    </method>
    <method name="CanSuspend">
      <arg type="b" direction="out" name="cansuspend" />
    </method>
    <method name="CanHibernate">
      <arg type="b" direction="out" name="canhibernate" />
    </method>

    <signal name="LockRequested" />
    <signal name="Locked" />
    <signal name="UnlockRequested" />
    <signal name="Unlocked" />
    <signal name="LogoutRequested">
      <arg type="b" name="have_inhibitors" />
    </signal>
    <signal name="RebootRequested">
      <arg type="b" name="have_inhibitors" />
    </signal>
    <signal name="ShutdownRequested">
      <arg type="b" name="have_inhibitors" />
    </signal>
  </interface>
</node>)";
}

DBusManager::DBusManager(session::Manager::Ptr const& session)
  : session_(session)
  , server_(dbus::NAME)
{
  server_.AddObjects(dbus::INTROSPECTION_XML, dbus::OBJECT_PATH);
  object_ = server_.GetObject(dbus::INTERFACE);
  object_->SetMethodsCallsHandler([this] (std::string const& method, GVariant*) -> GVariant* {
    if (method == "RealName")
    {
      return g_variant_new("(s)", session_->RealName().c_str());
    }
    else if (method == "UserName")
    {
      return g_variant_new("(s)", session_->UserName().c_str());
    }
    else if (method == "HostName")
    {
      return g_variant_new("(s)", session_->HostName().c_str());
    }
    else if (method == "Lock")
    {
      session_->LockScreen();
    }
    else if (method == "PromptLock")
    {
      session_->PromptLockScreen();
    }
    else if (method == "ActivateScreenSaver")
    {
      session_->ScreenSaverActivate();
    }
    else if (method == "DeactivateScreenSaver")
    {
      session_->ScreenSaverDeactivate();
    }
    else if (method == "Logout")
    {
      session_->Logout();
    }
    else if (method == "RequestLogout")
    {
      session_->logout_requested.emit(false);
    }
    else if (method == "Reboot")
    {
      session_->Reboot();
    }
    else if (method == "RequestReboot")
    {
      session_->reboot_requested.emit(false);
    }
    else if (method == "Shutdown")
    {
      session_->Shutdown();
    }
    else if (method == "RequestShutdown")
    {
      session_->shutdown_requested.emit(false);
    }
    else if (method == "Suspend")
    {
      session_->Suspend();
    }
    else if (method == "Hibernate")
    {
      session_->Hibernate();
    }
    else if (method == "CancelAction")
    {
      session_->CancelAction();
      session_->cancel_requested.emit();
    }
    else if (method == "CanShutdown")
    {
      return g_variant_new("(b)", session_->CanShutdown() != FALSE);
    }
    else if (method == "CanSuspend")
    {
      return g_variant_new("(b)", session_->CanSuspend() != FALSE);
    }
    else if (method == "CanHibernate")
    {
      return g_variant_new("(b)", session_->CanHibernate() != FALSE);
    }

    return nullptr;
  });

  connections_.Add(session_->lock_requested.connect([this] {
    object_->EmitSignal("LockRequested");
  }));
  connections_.Add(session_->prompt_lock_requested.connect([this] {
    object_->EmitSignal("LockRequested");
  }));
  connections_.Add(session_->locked.connect([this] {
    object_->EmitSignal("Locked");
  }));
  connections_.Add(session_->unlock_requested.connect([this] {
    object_->EmitSignal("UnlockRequested");
  }));
  connections_.Add(session_->unlocked.connect([this] {
    object_->EmitSignal("Unlocked");
  }));
  connections_.Add(session_->logout_requested.connect([this] (bool inhibitors) {
    object_->EmitSignal("LogoutRequested", g_variant_new("(b)", inhibitors));
  }));
  connections_.Add(session_->reboot_requested.connect([this] (bool inhibitors) {
    object_->EmitSignal("RebootRequested", g_variant_new("(b)", inhibitors));
  }));
  connections_.Add(session_->shutdown_requested.connect([this] (bool inhibitors) {
    object_->EmitSignal("ShutdownRequested", g_variant_new("(b)", inhibitors));
  }));
}

} // session
} // unity
