/*
 * Copyright (C) 2017 Mentor Graphics Development (Deutschland) GmbH
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "app.hpp"
#include "json_helper.hpp"
#include "layers.hpp"
#include "layout.hpp"
#include "util.hpp"
#include "wayland.hpp"

#include <cstdio>
#include <memory>

#include <cassert>

#include <json-c/json.h>

#include <algorithm>
#include <bits/signum.h>
#include <csignal>
#include <fstream>
#include <json.hpp>
#include <regex>
#include <thread>


namespace wm {

namespace {

using nlohmann::json;

result<json> file_to_json(char const *filename) {
   std::ifstream i(filename);
   if (i.fail()) {
      return Err<json>("Could not open config file");
   }
   json j;
   i >> j;
   return Ok(j);
}

struct result<layer_map> load_layer_map(char const *filename) {
   HMI_DEBUG("wm", "loading IDs from %s", filename);

   auto j = file_to_json(filename);
   if (j.is_err()) {
      return Err<layer_map>(j.unwrap_err());
   }
   json jids = j.unwrap();

   return to_layer_map(jids);
}

}  // namespace


/**
 * App Impl
 */
App::App(wl::display *d)
   : api{this},
     chooks{this},
     display{d},
     controller{},
     outputs(),
     config(),
     layers(),
     id_alloc{},
     pending_events(false),
     policy{} {
   try {
      {
         auto l = load_layer_map(
            this->config.get_string("layers.json").value().c_str());
         if (l.is_ok()) {
            this->layers = l.unwrap();
         } else {
            HMI_ERROR("wm", "%s", l.err().value());
         }
      }
   } catch (std::exception &e) {
      HMI_ERROR("wm", "Loading of configuration failed: %s", e.what());
   }
}

int App::init() {
   if (!this->display->ok()) {
      return -1;
   }

   if (this->layers.mapping.empty()) {
      HMI_ERROR("wm", "No surface -> layer mapping loaded");
      return -1;
   }

   // Make afb event
   for (int i=Event_Val_Min; i<=Event_Val_Max; i++) {
      map_afb_event[kListEventName[i]] = afb_daemon_make_event(kListEventName[i]);
   }

   this->display->add_global_handler(
      "wl_output", [this](wl_registry *r, uint32_t name, uint32_t v) {
         this->outputs.emplace_back(std::make_unique<wl::output>(r, name, v));
      });

   this->display->add_global_handler(
      "ivi_controller", [this](wl_registry *r, uint32_t name, uint32_t v) {
         this->controller =
            std::make_unique<struct compositor::controller>(r, name, v);

         // Init controller hooks
         this->controller->chooks = &this->chooks;

         // This protocol needs the output, so lets just add our mapping here...
         this->controller->add_proxy_to_id_mapping(
            this->outputs.back()->proxy.get(),
            wl_proxy_get_id(reinterpret_cast<struct wl_proxy *>(
               this->outputs.back()->proxy.get())));
      });

   // First level objects
   this->display->roundtrip();
   // Second level objects
   this->display->roundtrip();
   // Third level objects
   this->display->roundtrip();

   return init_layers();
}

int App::dispatch_events() {
   if (this->dispatch_events() == 0) {
      return 0;
   }

   int ret = this->display->dispatch();
   if (ret == -1) {
      HMI_ERROR("wm", "wl_display_dipatch() returned error %d",
               this->display->get_error());
      return -1;
   }
   this->display->flush();

   return 0;
}

int App::dispatch_pending_events() {
   if (this->pop_pending_events()) {
      this->display->dispatch_pending();
      return 0;
   }
   return -1;
}

bool App::pop_pending_events() {
   bool x{true};
   return this->pending_events.compare_exchange_strong(
      x, false, std::memory_order_consume);
}

void App::set_pending_events() {
   this->pending_events.store(true, std::memory_order_release);
}

optional<int> App::lookup_id(char const *name) {
   return this->id_alloc.lookup(std::string(name));
}
optional<std::string> App::lookup_name(int id) {
   return this->id_alloc.lookup(id);
}

/**
 * init_layers()
 */
int App::init_layers() {
   if (!this->controller) {
      HMI_ERROR("wm", "ivi_controller global not available");
      return -1;
   }

   if (this->outputs.empty()) {
      HMI_ERROR("wm", "no output was set up!");
      return -1;
   }

   auto &c = this->controller;

   auto &o = this->outputs.front();
   auto &s = c->screens.begin()->second;
   auto &layers = c->layers;

   // Write output dimensions to ivi controller...
   c->output_size = compositor::size{uint32_t(o->width), uint32_t(o->height)};

   // Clear scene
   layers.clear();

   // Clear screen
   s->clear();

   // Quick and dirty setup of layers
   for (auto const &i : this->layers.mapping) {
      c->layer_create(i.second.layer_id, o->width, o->height);
      auto &l = layers[i.second.layer_id];
      l->set_destination_rectangle(0, 0, o->width, o->height);
      l->set_visibility(1);
      HMI_DEBUG("wm", "Setting up layer %s (%d) for surface role match \"%s\"",
               i.second.name.c_str(), i.second.layer_id, i.second.role.c_str());
   }

   // Add layers to screen
   s->set_render_order(this->layers.layers);

   this->layout_commit();

   return 0;
}

void App::surface_set_layout(int surface_id, optional<int> sub_surface_id) {
   if (!this->controller->surface_exists(surface_id)) {
      HMI_ERROR("wm", "Surface %d does not exist", surface_id);
      return;
   }

   auto o_layer_id = this->layers.get_layer_id(surface_id);

   if (!o_layer_id) {
      HMI_ERROR("wm", "Surface %d is not associated with any layer!", surface_id);
      return;
   }

   uint32_t layer_id = *o_layer_id;

   auto const &layer = this->layers.get_layer(layer_id);
   auto rect = layer.value().rect;
   auto &s = this->controller->surfaces[surface_id];

   int x = rect.x;
   int y = rect.y;
   int w = rect.w;
   int h = rect.h;

   // less-than-0 values refer to MAX + 1 - $VALUE
   // e.g. MAX is either screen width or height
   if (w < 0) {
      w = this->controller->output_size.w + 1 + w;
   }
   if (h < 0) {
      h = this->controller->output_size.h + 1 + h;
   }

   if (sub_surface_id) {
      if (o_layer_id != this->layers.get_layer_id(*sub_surface_id)) {
         HMI_ERROR("wm",
            "surface_set_layout: layers of surfaces (%d and %d) don't match!",
            surface_id, *sub_surface_id);
         return;
      }

      int x_off = 0;
      int y_off = 0;

      // split along major axis
      if (w > h) {
         w /= 2;
         x_off = w;
      } else {
         h /= 2;
         y_off = h;
      }

      auto &ss = this->controller->surfaces[*sub_surface_id];

      HMI_DEBUG("wm", "surface_set_layout for sub surface %u on layer %u",
               *sub_surface_id, layer_id);

      // configure surface to wxh dimensions
      ss->set_configuration(w, h);
      // set source reactangle, even if we should not need to set it.
      ss->set_source_rectangle(0, 0, w, h);
      // set destination to the display rectangle
      ss->set_destination_rectangle(x + x_off, y + y_off, w, h);

   }

   HMI_DEBUG("wm", "surface_set_layout for surface %u on layer %u", surface_id,
            layer_id);

   // configure surface to wxh dimensions
   s->set_configuration(w, h);
   // set source reactangle, even if we should not need to set it.
   s->set_source_rectangle(0, 0, w, h);

   // set destination to the display rectangle
   s->set_destination_rectangle(x, y, w, h);

   HMI_DEBUG("wm", "Surface %u now on layer %u with rect { %d, %d, %d, %d }",
            surface_id, layer_id, x, y, w, h);
}

void App::layout_commit() {
   this->controller->commit_changes();
   this->display->flush();
}

char const *App::api_activate_surface(char const *drawing_name, char const *drawing_area) {
   ST();

   auto const &surface_id = this->lookup_id(drawing_name);

   if (!surface_id) {
      return "Surface does not exist";
   }

   if (!this->controller->surface_exists(*surface_id)) {
      return "Surface does not exist in controller!";
   }

   auto layer_id = this->layers.get_layer_id(*surface_id);

   if (!layer_id) {
      return "Surface is not on any layer!";
   }

   auto o_state = *this->layers.get_layout_state(*surface_id);

   if (o_state == nullptr) {
      return "Could not find layer for surface";
   }

   struct LayoutState &state = *o_state;

   // disable layers that are above our current layer
   for (auto const &l : this->layers.mapping) {
      if (l.second.layer_id <= *layer_id) {
         continue;
      }

      bool flush = false;
      if (l.second.state.main != -1) {
         this->deactivate(l.second.state.main);
         l.second.state.main = -1;
         flush = true;
      }

      if (l.second.state.sub != -1) {
         this->deactivate(l.second.state.sub);
         l.second.state.sub = -1;
         flush = true;
      }

      if (flush) {
         this->layout_commit();
      }
   }

   auto layer = this->layers.get_layer(*layer_id);

   if (state.main == -1) {
      this->try_layout(
         state, LayoutState{*surface_id}, [&] (LayoutState const &nl) {
            HMI_DEBUG("wm", "Layout: %s", kNameLayoutNormal);
            this->surface_set_layout(*surface_id);
            state = nl;

            // Commit for configuraton
            this->layout_commit();

            if (!(layer->is_normal_layout_only)) {
               // Wait for configuration listener
               controller->is_configured = false;
               while (!(controller->is_configured)) {
                  dispatch_pending_events();
               }
            }

            std::string str_area = std::string(kNameLayoutNormal) + "." + std::string(kNameAreaFull);
            this->emit_syncdraw(drawing_name, str_area.c_str());
            this->enqueue_flushdraw(state.main);
         });
   } else {
      if (0 == strcmp(drawing_name, "HomeScreen")) {
         this->try_layout(
            state, LayoutState{*surface_id}, [&] (LayoutState const &nl) {
               HMI_DEBUG("wm", "Layout: %s", kNameLayoutNormal);
               std::string str_area = std::string(kNameLayoutNormal) + "." + std::string(kNameAreaFull);
               this->emit_syncdraw(drawing_name, str_area.c_str());
               this->enqueue_flushdraw(state.main);
            });
      } else {
         bool can_split = this->can_split(state, *surface_id);

         if (can_split) {
            this->try_layout(
               state,
               LayoutState{state.main, *surface_id},
               [&] (LayoutState const &nl) {
                  HMI_DEBUG("wm", "Layout: %s", kNameLayoutSplit);
                  std::string main =
                     std::move(*this->lookup_name(state.main));

                  this->surface_set_layout(state.main, surface_id);
                  if (state.sub != *surface_id) {
                      if (state.sub != -1) {
                         this->deactivate(state.sub);
                      }
                  }
                  state = nl;

                  // Commit for configuraton and visibility(0)
                  this->layout_commit();

                  // Wait for configuration listener
                  controller->is_configured = false;
                  while (!(controller->is_configured)) {
                     dispatch_pending_events();
                  }

                  std::string str_area_main = std::string(kNameLayoutSplit) + "." + std::string(kNameAreaMain);
                  std::string str_area_sub = std::string(kNameLayoutSplit) + "." + std::string(kNameAreaSub);
                  this->emit_syncdraw(main.c_str(), str_area_main.c_str());
                  this->emit_syncdraw(drawing_name, str_area_sub.c_str());
                  this->enqueue_flushdraw(state.main);
                  this->enqueue_flushdraw(state.sub);
               });
         } else {
            this->try_layout(
               state, LayoutState{*surface_id}, [&] (LayoutState const &nl) {
                  HMI_DEBUG("wm", "Layout: %s", kNameLayoutNormal);

                  this->surface_set_layout(*surface_id);
                  if (state.main != *surface_id) {
                      this->deactivate(state.main);
                  }
                  if (state.sub != -1) {
                      if (state.sub != *surface_id) {
              <style>.highlight .hll { background-color: #ffffcc }
.highlight .c { color: #888888 } /* Comment */
.highlight .err { color: #a61717; background-color: #e3d2d2 } /* Error */
.highlight .k { color: #008800; font-weight: bold } /* Keyword */
.highlight .ch { color: #888888 } /* Comment.Hashbang */
.highlight .cm { color: #888888 } /* Comment.Multiline */
.highlight .cp { color: #cc0000; font-weight: bold } /* Comment.Preproc */
.highlight .cpf { color: #888888 } /* Comment.PreprocFile */
.highlight .c1 { color: #888888 } /* Comment.Single */
.highlight .cs { color: #cc0000; font-weight: bold; background-color: #fff0f0 } /* Comment.Special */
.highlight .gd { color: #000000; background-color: #ffdddd } /* Generic.Deleted */
.highlight .ge { font-style: italic } /* Generic.Emph */
.highlight .gr { color: #aa0000 } /* Generic.Error */
.highlight .gh { color: #333333 } /* Generic.Heading */
.highlight .gi { color: #000000; background-color: #ddffdd } /* Generic.Inserted */
.highlight .go { color: #888888 } /* Generic.Output */
.highlight .gp { color: #555555 } /* Generic.Prompt */
.highlight .gs { font-weight: bold } /* Generic.Strong */
.highlight .gu { color: #666666 } /* Generic.Subheading */
.highlight .gt { color: #aa0000 } /* Generic.Traceback */
.highlight .kc { color: #008800; font-weight: bold } /* Keyword.Constant */
.highlight .kd { color: #008800; font-weight: bold } /* Keyword.Declaration */
.highlight .kn { color: #008800; font-weight: bold } /* Keyword.Namespace */
.highlight .kp { color: #008800 } /* Keyword.Pseudo */
.highlight .kr { color: #008800; font-weight: bold } /* Keyword.Reserved */
.highlight .kt { color: #888888; font-weight: bold } /* Keyword.Type */
.highlight .m { color: #0000DD; font-weight: bold } /* Literal.Number */
.highlight .s { color: #dd2200; background-color: #fff0f0 } /* Literal.String */
.highlight .na { color: #336699 } /* Name.Attribute */
.highlight .nb { color: #003388 } /* Name.Builtin */
.highlight .nc { color: #bb0066; font-weight: bold } /* Name.Class */
.highlight .no { color: #003366; font-weight: bold } /* Name.Constant */
.highlight .nd { color: #555555 } /* Name.Decorator */
.highlight .ne { color: #bb0066; font-weight: bold } /* Name.Exception */
.highlight .nf { color: #0066bb; font-weight: bold } /* Name.Function */
.highlight .nl { color: #336699; font-style: italic } /* Name.Label */
.highlight .nn { color: #bb0066; font-weight: bold } /* Name.Namespace */
.highlight .py { color: #336699; font-weight: bold } /* Name.Property */
.highlight .nt { color: #bb0066; font-weight: bold } /* Name.Tag */
.highlight .nv { color: #336699 } /* Name.Variable */
.highlight .ow { color: #008800 } /* Operator.Word */
.highlight .w { color: #bbbbbb } /* Text.Whitespace */
.highlight .mb { color: #0000DD; font-weight: bold } /* Literal.Number.Bin */
.highlight .mf { color: #0000DD; font-weight: bold } /* Literal.Number.Float */
.highlight .mh { color: #0000DD; font-weight: bold } /* Literal.Number.Hex */
.highlight .mi { color: #0000DD; font-weight: bold } /* Literal.Number.Integer */
.highlight .mo { color: #0000DD; font-weight: bold } /* Literal.Number.Oct */
.highlight .sa { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Affix */
.highlight .sb { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Backtick */
.highlight .sc { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Char */
.highlight .dl { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Delimiter */
.highlight .sd { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Doc */
.highlight .s2 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Double */
.highlight .se { color: #0044dd; background-color: #fff0f0 } /* Literal.String.Escape */
.highlight .sh { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Heredoc */
.highlight .si { color: #3333bb; background-color: #fff0f0 } /* Literal.String.Interpol */
.highlight .sx { color: #22bb22; background-color: #f0fff0 } /* Literal.String.Other */
.highlight .sr { color: #008800; background-color: #fff0ff } /* Literal.String.Regex */
.highlight .s1 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Single */
.highlight .ss { color: #aa6600; background-color: #fff0f0 } /* Literal.String.Symbol */
.highlight .bp { color: #003388 } /* Name.Builtin.Pseudo */
.highlight .fm { color: #0066bb; font-weight: bold } /* Name.Function.Magic */
.highlight .vc { color: #336699 } /* Name.Variable.Class */
.highlight .vg { color: #dd7700 } /* Name.Variable.Global */
.highlight .vi { color: #3333bb } /* Name.Variable.Instance */
.highlight .vm { color: #336699 } /* Name.Variable.Magic */
.highlight .il { color: #0000DD; font-weight: bold } /* Literal.Number.Integer.Long */</style><div class="highlight"><pre><span></span>AGL framework, IoT.bzh proposal overview
========================================

Foreword
--------

This document describes what we intend to do. It may happen that our
current implementation and the content of this document differ.

In case of differences, it is assumed that this document is right
and the implementation is wrong.


Introduction
------------

During the first works in having the security model of Tizen
integrated in AGL (Automotive Grade Linux) distribution, it became
quickly obvious that the count of components specific to Tizen
to integrate was huge.

Here is a minimal list of what was needed:

 <span class="k">-</span> platform/appfw/app-installers
 <span class="k">-</span> platform/core/security/cert-svc
 <span class="k">-</span> platform/core/appfw/ail
 <span class="k">-</span> platform/core/appfw/aul-1
 <span class="k">-</span> platform/core/appfw/libslp-db-util
 <span class="k">-</span> platform/core/appfw/pkgmgr-info
 <span class="k">-</span> platform/core/appfw/slp-pkgmgr

But this list isn&#39;t complete because many dependencies are hidden.
Those hidden dependencies are including some common libraries but also many
tizen specific sub-components (iniparser, bundle, dlog, libtzplatform-config,
db-util, vconf-buxton, ...).

This is an issue because AGL is not expected to be Tizen. Taking it would
either need to patch it for removing unwanted components or to take all
of them.

However, a careful study of the core components of the security framework
of Tizen showed that their dependencies to Tizen are light (and since some
of our work, there is no more dependency to tizen).
Those components are <span class="gs">**cynara**, **security-manager**, **D-Bus aware of cynara**</span>.

Luckyly, these core security components of Tizen are provided
by [meta-intel-iot-security][meta-intel], a set of yocto layers.
These layers were created by Intel to isolate Tizen specific security
components from the initial port of Tizen to Yocto.
The 3 layers are providing components for:

 <span class="k">*</span> Implementing Smack LSM
 <span class="k">*</span> Implementing Integrity Measurement Architecture
 <span class="k">*</span> Implementing Tizen Security Framework

The figure below shows the history of these layers.

![Security_model_history][Security_model_history]

We took the decision to use these security layers that provides the
basis of the Tizen security, the security framework.

For the components of the application framework, built top of
the security framework, instead of pulling the huge set of packages
from Tizen, we decided to refit it by developping a tiny set of
components that would implement the same behaviour but without all
the dependencies and with minor architectural improvements for AGL.

These components are <span class="gs">**afm-system-daemon** and **afm-user-daemon**</span>.
They provides infrastructure for installing, uninstalling,
launching, terminating, pausing and resuming applications in
a multi user secure environment.

A third component exists in the framework, the binder <span class="gs">**afb-daemon**</span>.
The binder provides the easiest way to provide secured API for
any tier. Currently, the use of the binder is not absolutely mandatory.

This documentation explains the framework created by IoT.bzh
by rewriting the Tizen Application Framework. Be aware of the
previous foreword.


Overview
--------

The figure below shows the major components of the framework
and their interactions going through the following scenario:
APPLICATION installs an other application and then launch it.

![AppFW-APP_install_sequences][AppFW-APP_install_sequences]

Let follow the sequence of calls:

<span class="k">1.</span> APPLICATION calls its <span class="gs">**binder**</span> to install the OTHER application.

<span class="k">2.</span> The binding <span class="gs">**afm-main-binding** of the **binder**</span> calls, through
   <span class="gs">**D-Bus**</span> system, the system daemon to install the OTHER application.

<span class="k">3.</span> The system <span class="gs">**D-Bus**</span> checks wether APPLICATION has the permission
   or not to install applications by calling <span class="gs">**CYNARA**</span>.

<span class="k">4.</span> The system <span class="gs">**D-Bus** transmits the request to **afm-system-daemon**</span>.

   <span class="gs">**afm-system-daemon**</span> checks the application to install, its
   signatures and rights and install it.

<span class="k">5.</span> <span class="gs">**afm-system-daemon** calls **SECURITY-MANAGER**</span> for fullfilling
   security context of the installed application.

<span class="k">6.</span> <span class="gs">**SECURITY-MANAGER** calls **CYNARA**</span> to install initial permissions
   for the application.

<span class="k">7.</span> APPLICATION call its binder to start the nearly installed OTHER application.

<span class="k">8.</span> The binding <span class="gs">**afm-main-binding** of the **binder**</span> calls, through
   <span class="gs">**D-Bus**</span> session, the user daemon to launch the OTHER application.

<span class="k">9.</span> The session <span class="gs">**D-Bus**</span> checks wether APPLICATION has the permission
   or not to start an application by calling <span class="gs">**CYNARA**</span>.

<span class="k">10.</span> The session <span class="gs">**D-Bus** transmits the request to **afm-user-daemon**</span>.

<span class="k">11.</span> <span class="gs">**afm-user-daemon**</span> checks wether APPLICATION has the permission
    or not to start the OTHER application <span class="gs">**CYNARA**</span>.

<span class="k">12.</span> <span class="gs">**afm-user-daemon** uses **SECURITY-MANAGER**</span> features to set
    the seciruty context for the OTHER application.

<span class="k">13.</span> <span class="gs">**afm-user-daemon**</span> launches the OTHER application.

This scenario does not cover all the features of the frameworks.
Shortly because details will be revealed in the next chapters,
the components are:

<span class="k">*</span> ***SECURITY-MANAGER***: in charge of setting Smack contexts and rules,
  of setting groups, and, of creating initial content of <span class="ge">*CYNARA*</span> rules
  for applications.

<span class="k">*</span> ***CYNARA***: in charge of handling API access permissions by users and by
  applications.

<span class="k">*</span> ***D-Bus***: in charge of chec