#!/usr/bin/python
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# 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, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

import os
import sys
from argparse import ArgumentParser

import dbus
import dbus.lowlevel

import problem

import report
from reportclient import (RETURN_OK,
                          RETURN_FAILURE,
                          RETURN_CANCEL_BY_USER,
                          RETURN_STOP_EVENT_RUN,
                          log1,
                          set_verbosity)

CD_DUMPDIR = "Directory"
FILENAME_PACKAGE = "package"
FILENAME_UID = "uid"
FILENAME_UUID = "uuid"
FILENAME_DUPHASH = "duphash"


def run_autoreport(problem_data, event_name):
    """Runs autoreporting event

    Requires CD_DUMPDIR key in problem_data.

    Keyword arguments:
    problem_data -- problem data of notified problems

    Returns None as it raises an exception on error

    Raises:
    KeyError -- if any of required elements is missing
    RuntimeError -- if event run fails
    """

    dir_name = problem_data.get(CD_DUMPDIR)
    if dir_name is None:
        raise KeyError(CD_DUMPDIR)

    log1("Running autoreporting event: '{0}'".format(event_name))

    res = report.run_event_state()
    ret = res.run_event_on_dir_name(dir_name[0], event_name)

    if res.children_count == 0 and ret == 0:
        raise RuntimeError("No processing is specified for event '{0}'"
                .format(event_name))

    if not ret in [RETURN_OK, RETURN_CANCEL_BY_USER, RETURN_STOP_EVENT_RUN]:
        raise RuntimeError("Event '{0}' exited with {1}"
                .format(event_name, ret))

def emit_crash_dbus_signal(problem_data):
    """Emits a Crash signal on D-Bus Problem bus

    Emits a signal with 5 members:
        package -- value of 'package' element in problem_data
        problem_id -- value of 'Directory' element in problem_data
        uid -- empty string if 'uid' element is not present in problem_data
        uuid -- empty string if 'uuid' element is not present in problem_data
        duphash -- empty string if 'duphash' element is not present in problem_data

    Keyword arguments:
    problem_data -- problem data of notified problems

    Returns None as it raises an exception on error

    Raises:
    RuntimeError -- for all D-Bus related errors
    KeyError -- if any of required elements is missing
    """

    bus = None
    try:
        bus = dbus.SystemBus()
        msg = dbus.lowlevel.SignalMessage("/org/freedesktop/problems",
                "org.freedesktop.problems", "Crash")

        # List of tuples where the first member is element name and the second
        # member is a Boolean flag which is True if the element is required
        arguments = ((FILENAME_PACKAGE, True), (CD_DUMPDIR, True),
                (FILENAME_UID, False), (FILENAME_UUID, False),
                (FILENAME_DUPHASH, False))

        for elem in arguments:
            itm = problem_data.get(elem[0])

            if itm is None:
                if elem[1]:
                    raise KeyError(elem[0])

                msg.append("", signature="s")
            else:
                msg.append(itm[0], signature="s")


        bus.send_message(msg)
    except dbus.exceptions.DBusException as ex:
        raise RuntimeError("Failed to emit D-Bus Crash signal: {0}"
                .format(ex.message))
    finally:
        if bus is not None:
            bus.close()

def build_notification_problem_data(problem_dir):
    """Loads all necessary problem elements

    Problem dump directory must contain 'package' element.

    Keyword arguments:
    problem_dir -- an absolute file system path problem directory

    Returns an instance of report.problem_data

    Raises:
    ValueError -- if problem_dir is not an absolute path, if problem_dir cannot
        be opened and if any required problem element is missing.
    """

    if not os.path.isabs(problem_dir):
        raise ValueError("problem directory must be absolute path")

    prblm_dt = report.problem_data()

    try:
        dump_dir = report.dd_opendir(problem_dir, report.DD_OPEN_READONLY)
        if not dump_dir:
            raise ValueError("cannot open problem directory")

        dd_load_flag = (report.DD_LOAD_TEXT_RETURN_NULL_ON_FAILURE
                | report.DD_FAIL_QUIETLY_ENOENT)

        package = dump_dir.load_text(FILENAME_PACKAGE, dd_load_flag)
        if not package:
            raise ValueError("problem directory misses '{0}'"
                    .format(FILENAME_PACKAGE))

        pd_add_flag = report.CD_FLAG_TXT | report.CD_FLAG_ISNOTEDITABLE

        prblm_dt.add(FILENAME_PACKAGE, package, pd_add_flag)
        prblm_dt.add(CD_DUMPDIR, problem_dir, pd_add_flag)

        for element in (FILENAME_UID, FILENAME_UUID, FILENAME_DUPHASH):
            val = dump_dir.load_text(element, dd_load_flag)
            if val is not None:
                prblm_dt.add(element, val, pd_add_flag)
    finally:
        dump_dir.close()

    return prblm_dt


if __name__ == "__main__":
    CMDARGS = ArgumentParser(
            description=("Announce a new or duplicated problem via"
                " all accessible channels"),
            epilog=("Reads the default configuration from 'abrt.conf' file"))
    CMDARGS.add_argument("-d", "--problem-dir",
            type=str, required=True,
            help="An absolute path to a new or duplicated problem directory")
    CMDARGS.add_argument("-v", "--verbose",
            action="count", dest="verbose", default=0,
            help="Be verbose")
    CMDARGS.add_argument("-a", "--autoreporting",
            action="store_true", dest="autoreporting", default=False,
            help="Force to run autoreporting event")
    CMDARGS.add_argument("-e", "--autoreporting-event",
            type=str, dest="autoreporting_event",
            help="Overwrite autoreporting event name")

    OPTIONS = CMDARGS.parse_args()

    DIR_PATH = OPTIONS.problem_dir

    verbose = 0
    ABRT_VERBOSE = os.getenv("ABRT_VERBOSE")
    if ABRT_VERBOSE:
        try:
            verbose = int(ABRT_VERBOSE)
        except:
            pass

    verbose += OPTIONS.verbose
    set_verbosity(verbose)
    os.environ["ABRT_VERBOSE"] = str(verbose)

    try:
        conf = problem.load_conf_file("abrt.conf")
    except OSError as ex:
        sys.stderr.write("{0}".format(str(ex)))
        sys.exit(RETURN_FAILURE)

    try:
        PD = build_notification_problem_data(DIR_PATH)
    except ValueError as ex:
        sys.stderr.write("Cannot notify '{0}': {1}\n".
                format(DIR_PATH, ex.message))
        sys.exit(RETURN_FAILURE)

    # The execution must continue because we should try to notify via all
    # configured channels. One of them might work properly.
    return_status = RETURN_OK
    try:
        emit_crash_dbus_signal(PD)
    except RuntimeError as ex:
        sys.stderr.write("Cannot notify '{0}' via D-Bus: {1}\n".
                format(DIR_PATH, ex.message))
        return_status = RETURN_FAILURE
    except KeyError as ex:
        # this is a bug in build_notification_problem_data()
        sys.stderr.write("BUG: problem data misses required element '{0}'"
                         " required for D-Bus notification\n"
                         .format(ex.message))

        return_status = RETURN_FAILURE

    if OPTIONS.autoreporting or conf.get("AutoreportingEnabled", "no") == "yes":
        event_name = OPTIONS.autoreporting_event
        if not event_name:
            if "AutoreportingEvent" in conf:
                event_name = conf["AutoreportingEvent"]
            else:
                sys.stderr.write("Autoreporting event is not configured\n")
                return_status = RETURN_FAILURE

        if event_name:
            try:
                run_autoreport(PD, event_name)
            except RuntimeError as ex:
                sys.stderr.write("Cannot notify '{0}' via uReport: {1}\n".
                        format(DIR_PATH, ex.message))
                return_status = RETURN_FAILURE
            except KeyError as ex:
                # this is a bug in build_notification_problem_data()
                sys.stderr.write(
                    "BUG: problem data misses required element '{0}'"
                    " required for uReport notification\n".format(ex.message))

                return_status = RETURN_FAILURE

    sys.exit(return_status)

