// Copyright 2020 Fuzhou Rockchip Electronics Co., Ltd. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <stdbool.h>
#include <sys/types.h>
#include <unistd.h>
#include <ctype.h>
#include <inttypes.h>

#include <glib.h>

#include <pthread.h>
#include <gdbus.h>

#include "json-c/json.h"
#include "dbus.h"

#define TIMEOUT         120000
static DBusConnection *dbusconn = 0;
static int need_loop = 1;
GMainLoop *main_loop = NULL;

struct dbus_callback {
    dbus_method_return_func_t cb;
    void *user_data;
};

static pthread_mutex_t mutex;

static void dbus_method_reply(DBusPendingCall *call, void *user_data)
{
    struct dbus_callback *callback = user_data;
    int res = 0;
    DBusMessage *reply;
    DBusMessageIter iter;

    reply = dbus_pending_call_steal_reply(call);
    dbus_pending_call_unref(call);
    if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
        DBusError err;

        dbus_error_init(&err);
        dbus_set_error_from_message(&err, reply);

        callback->cb(NULL, err.message, callback->user_data);

        dbus_error_free(&err);
        goto end;
    }

    dbus_message_iter_init(reply, &iter);
    res = callback->cb(&iter, NULL, callback->user_data);

end:

    g_free(callback);
    dbus_message_unref(reply);
}

static int send_method_call(DBusConnection *connection,
                            DBusMessage *message, dbus_method_return_func_t cb,
                            void *user_data)
{
    int res = -ENXIO;
    DBusPendingCall *call;
    struct dbus_callback *callback;

    if (!dbus_connection_send_with_reply(connection, message, &call, TIMEOUT))
        goto end;

    if (!call)
        goto end;

    if (cb) {
        callback = g_new0(struct dbus_callback, 1);
        callback->cb = cb;
        callback->user_data = user_data;
        dbus_pending_call_set_notify(call, dbus_method_reply,
                                     callback, NULL);
        res = -EINPROGRESS;
    }

end:
    dbus_message_unref(message);
    return res;
}

int callfunipc_dbus_method_call(DBusConnection *connection,
                     const char *service, const char *path, const char *interface,
                     const char *method, dbus_method_return_func_t cb,
                     void *user_data, dbus_append_func_t append_func,
                     void *append_data)
{
    DBusMessage *message;
    DBusMessageIter iter;

    message = dbus_message_new_method_call(service, path, interface,
                                           method);

    if (!message)
        return -ENOMEM;

    if (append_func) {
        dbus_message_iter_init_append(message, &iter);
        append_func(&iter, append_data);
    }

    return send_method_call(connection, message, cb, user_data);
}

void callfunipc_append_path(DBusMessageIter *iter, void *user_data)
{
    const char *path = user_data;

    dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &path);
}

int callfunipc_populate_set(DBusMessageIter *iter, const char *error,
                 void *user_data)
{
    char *json;
    struct UserData* userdata = user_data;

    if (userdata)
        pthread_mutex_unlock(&userdata->mutex);

    return 0;
}

int callfunipc_populate_get(DBusMessageIter *iter, const char *error,
                 void *user_data)
{
    char *json;
    struct UserData* userdata = user_data;

    if (error) {
        printf("%s err\n", __func__);
        if (userdata)
            pthread_mutex_unlock(&userdata->mutex);

        return 0;
    }

    dbus_message_iter_get_basic(iter, &json);
    userdata->json_str = g_strdup(json);

    if (userdata)
        pthread_mutex_unlock(&userdata->mutex);

    return 0;
}

static void *loop_thread(void *arg)
{
    main_loop = g_main_loop_new(NULL, FALSE);

    //g_timeout_add(100, time_cb, NULL);
    g_main_loop_run(main_loop);

    if (main_loop)
        g_main_loop_unref(main_loop);

    main_loop = NULL;

    return 0;
}

int callfunipc_dbus_async(struct UserData* userdata)
{
    struct timespec tout;

    if (need_loop && main_loop == NULL) {
        pthread_t tid;
        pthread_create(&tid, NULL, (void*)loop_thread, NULL);
    }

    clock_gettime(CLOCK_REALTIME, &tout);
    tout.tv_sec += 1;

    if (pthread_mutex_timedlock(&userdata->mutex, &tout) != 0) {
        printf("%s again get\n", __func__);
        return -1;
    }

    pthread_mutex_unlock(&userdata->mutex);

    return 0;
}

void callfunipc_dbus_deconnection(struct UserData* userdata)
{
    dbus_connection_unref(userdata->connection);
    if (userdata)
        g_free(userdata);
}

struct UserData* callfunipc_dbus_connection(void)
{
    DBusError dbus_err;
    struct UserData* userdata;

    userdata = malloc(sizeof(struct UserData));
    memset(userdata, 0, sizeof(struct UserData));
    pthread_mutex_init(&userdata->mutex, NULL);

    dbus_error_init(&dbus_err);
    userdata->connection = g_dbus_setup_bus(DBUS_BUS_SYSTEM, NULL, &dbus_err);
    pthread_mutex_lock(&userdata->mutex);

    return userdata;
}

void callfunipc_disable_loop(void)
{
    need_loop = 0;
}