#include <stdio.h>
#include <dlfcn.h>
#include <iostream>
#include <unistd.h>
#include <assert.h>
#include <dirent.h>
#include <gio/gio.h>
#include <string.h>
#include <stdlib.h>
#include <map>
#include "ipmid.H"

// Channel that is used for OpenBMC Barreleye
const char * DBUS_NAME = "org.openbmc.HostIpmi";
const char * OBJ_NAME = "/org/openbmc/HostIpmi/1";

typedef std::pair<ipmi_netfn_t, ipmi_cmd_t> ipmi_fn_cmd_t;
typedef std::pair<ipmid_callback_t, ipmi_context_t> ipmi_fn_context_t;

// Global data structure that contains the IPMI command handler's registrations.
std::map<ipmi_fn_cmd_t, ipmi_fn_context_t> g_ipmid_router_map;

// Method that gets called by shared libraries to get their command handlers registered
void ipmi_register_callback(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
                       ipmi_context_t context, ipmid_callback_t handler)
{
    // Pack NetFn and Command in one.
    auto netfn_and_cmd = std::make_pair(netfn, cmd);

    // Pack Function handler and Data in another.
    auto handler_and_context = std::make_pair(handler, context);

    // Check if the registration has already been made..
    auto iter = g_ipmid_router_map.find(netfn_and_cmd);
    if(iter != g_ipmid_router_map.end())
    {
        fprintf(stderr,"ERROR : Duplicate registration for NetFn [0x%X], Cmd:[0x%X]\n",netfn, cmd);
    }
    else
    {
        // This is a fresh registration.. Add it to the map.
        g_ipmid_router_map.emplace(netfn_and_cmd, handler_and_context);
    }

    return;
}

// Looks at the map and calls corresponding handler functions.
ipmi_ret_t ipmi_netfn_router(ipmi_netfn_t netfn, ipmi_cmd_t cmd, ipmi_request_t request,
                      ipmi_response_t response, ipmi_data_len_t data_len)
{
    // return from the Command handlers.
    ipmi_ret_t rc = IPMI_CC_INVALID;

    // Walk the map that has the registered handlers and invoke the approprite
    // handlers for matching commands.
    auto iter = g_ipmid_router_map.find(std::make_pair(netfn, cmd));
    if(iter == g_ipmid_router_map.end())
    {
        printf("No registered handlers for NetFn:[0x%X], Cmd:[0x%X]"
               " trying Wilcard implementation \n",netfn, cmd);

        // Now that we did not find any specific [NetFn,Cmd], tuple, check for
        // NetFn, WildCard command present.
        iter = g_ipmid_router_map.find(std::make_pair(netfn, IPMI_CMD_WILDCARD));
        if(iter == g_ipmid_router_map.end())
        {
            printf("No Registered handlers for NetFn:[0x%X],Cmd:[0x%X]\n",netfn, IPMI_CMD_WILDCARD);

            // Respond with a 0xC1
            memcpy(response, &rc, IPMI_CC_LEN);
            *data_len = IPMI_CC_LEN;
            return rc;
        }
    }

#ifdef __IPMI_DEBUG__
    // We have either a perfect match -OR- a wild card atleast,
    printf("Calling Net function:[0x%X], Command:[0x%X]\n", netfn, cmd);
#endif

    // Extract the map data onto appropriate containers
    auto handler_and_context = iter->second;

    // Creating a pointer type casted to char* to make sure we advance 1 byte
    // when we advance pointer to next's address. advancing void * would not
    // make sense.
    char *respo = &((char *)response)[IPMI_CC_LEN];

    // Response message from the plugin goes into a byte post the base response
    rc = (handler_and_context.first) (netfn, cmd, request, respo,
                                      data_len, handler_and_context.second);
 
    // Now copy the return code that we got from handler and pack it in first
    // byte.
    memcpy(response, &rc, IPMI_CC_LEN);
 
    // Data length is now actual data + completion code.
    *data_len = *data_len + IPMI_CC_LEN;

    return rc;
}

// This gets called by Glib loop on seeing a Dbus signal 
static void handle_ipmi_command(GDBusProxy *proxy,
                        gchar      *sender_name,
                        gchar      *signal_name,
                        GVariant   *parameters,
                        gpointer    user_data)
{
    // Used to re-construct the message into IPMI specific ones.
    guchar *parameters_str;
    unsigned char sequence, netfn, cmd;

    // Request and Response buffer.
    unsigned char request[MAX_IPMI_BUFFER] = {0};
    unsigned char response[MAX_IPMI_BUFFER] = {0};

    size_t msg_length = 0;
    size_t data_len = 0;

    // Response from Net Function Router
    ipmi_ret_t rc = 0;

    // Variables to marshall and unmarshall the messages.
    GVariantIter *iter;
    guchar data;
    GVariant *dbus_response;
    GVariantBuilder *builder;

    // Pretty print the message that came on Dbus
    parameters_str = (guchar *) g_variant_print (parameters, TRUE);
    printf ("*** Received Signal: %s: %s :%s\n",
            signal_name,
            sender_name,
            parameters_str);

    // Consume the data pattern "<bYte><bYte><bYte><Array_of_bYtes>
    g_variant_get(parameters, "(yyyay)", &sequence, &netfn, &cmd, &iter);

    printf("Sequence: %x\n",sequence );
    printf("Netfn   : %x\n",netfn );
    printf("Cmd     : %x\n",cmd );

    // Further break down the GVariant byte array
    while (g_variant_iter_loop (iter, "y", &data))
    {
        request[msg_length++] = data;
    }

    // Done with consuming data.
    g_free (parameters_str);

    // Needed to see what we get back from the handlers.
    data_len = msg_length;

    // Now that we have parsed the entire byte array from the caller 
    // we can call the ipmi router to do the work...
    rc = ipmi_netfn_router(netfn, cmd, (void *)request, (void *)response, &data_len);
    if(rc == 0)
    {
        printf("SUCCESS handling NetFn:[0x%X], Cmd:[0x%X]\n",netfn, cmd);
    }
    else
    {
        fprintf(stderr,"ERROR:[0x%X] handling NetFn:[0x%X], Cmd:[0x%X]\n",rc, netfn, cmd);
    }

    // Now build a response Gvariant package
    // This example may help
    // http://stackoverflow.com/questions/22937588/how-to-send-byte-array-over-gdbus

    printf("Bytes to return\n");
   // hexdump(response,data_len);

    // Now we need to put the data as "Array Of Bytes" as we got them.
    builder = g_variant_builder_new (G_VARIANT_TYPE ("ay"));

    for (uint out_data = 0; out_data < data_len; out_data++)
    {
        g_variant_builder_add (builder, "y", response[out_data]);
    }

    dbus_response = g_variant_new ("(yyyay)", sequence, netfn+1, cmd, builder);

    // Variant builder is no longer needed.
    g_variant_builder_unref (builder);

    parameters_str = (guchar *) g_variant_print (dbus_response, TRUE);
    printf (" *** Response Signal :%s\n", parameters_str);

    // Done packing the data.
    g_free (parameters_str);

    // NOW send the respone message in the Dbus calling "sendMessage" interface.
    g_dbus_proxy_call_sync (proxy,
            "sendMessage",
            dbus_response,
            G_DBUS_CALL_FLAGS_NONE,
            -1,
            NULL,
            NULL);
}

//----------------------------------------------------------------------
// handler_select
// Select all the files ending with with .so. in the given diretcory
// @d: dirent structure containing the file name
//----------------------------------------------------------------------
int handler_select(const struct dirent *entry)
{
    // To hold ".so" from entry->d_name;
    char dname_copy[4] = {0};

    // We want to avoid checking for everything and isolate to the ones having
    // .so in them.
    if(strstr(entry->d_name, IPMI_PLUGIN_EXTN))
    {
        // It is possible that .so could be anywhere in the string but unlikely
        // But being careful here. Get the base address of the string, move 
        // until end and come back 3 steps and that gets what we need.
        strcpy(dname_copy, (entry->d_name + strlen(entry->d_name)-strlen(IPMI_PLUGIN_EXTN)));
        if(strcmp(dname_copy, IPMI_PLUGIN_EXTN) == 0)
        {
            return 1;
        }
    }
    return 0;
}

// This will do a dlopen of every .so in ipmi_lib_path and will dlopen everything so that they will
// register a callback handler 
void ipmi_register_callback_handlers(const char* ipmi_lib_path)
{
    // For walking the ipmi_lib_path
    struct dirent **handler_list;
    int num_handlers = 0;

    // This is used to check and abort if someone tries to register a bad one.
    void *lib_handler = NULL;

    if(ipmi_lib_path == NULL)
    {
        fprintf(stderr,"ERROR; No handlers to be registered for ipmi.. Aborting\n");
        assert(0);
    }
    else
    {
        // 1: Open ipmi_lib_path. Its usually "/usr/lib/phosphor-host-ipmid"
        // 2: Scan the directory for the files that end with .so
        // 3: For each one of them, just do a 'dlopen' so that they register 
        //    the handlers for callback routines.

        std::string handler_fqdn = ipmi_lib_path;
        
        // Append a "/" since we need to add the name of the .so. If there is
        // already a .so, adding one more is not any harm.
        handler_fqdn += "/";

        num_handlers = scandir(ipmi_lib_path, &handler_list, handler_select, alphasort);
        while(num_handlers--)
        {
            printf("Registering handler:[%s]\n",handler_list[num_handlers]->d_name);

            handler_fqdn += handler_list[num_handlers]->d_name;
            lib_handler = dlopen(handler_fqdn.c_str(), RTLD_NOW);
            if(lib_handler == NULL)
            {
                fprintf(stderr,"ERROR opening:[%s]\n",handler_list[num_handlers]->d_name);
                dlerror();
            }
            // Wipe the memory allocated for this particular entry.
            free(handler_list[num_handlers]);
        }
        // Done with all registration.
        free(handler_list);
    }

    // TODO : What to be done on the memory that is given by dlopen ?.
    return;
}

int main(int argc, char *argv[])
{
    // Register all the handlers that provider implementation to IPMI commands.
    ipmi_register_callback_handlers(HOST_IPMI_LIB_PATH);

#ifdef __IPMI_DEBUG__
    printf("Registered Function handlers:\n");

    // Print the registered handlers and their arguments.
    for(auto& iter : g_ipmid_router_map)
    {
        ipmi_fn_cmd_t fn_and_cmd = iter.first;
        printf("NETFN:[0x%X], cmd[0x%X]\n", fn_and_cmd.first, fn_and_cmd.second);  
    }
#endif
       
    // Infrastructure that will wait for IPMi Dbus messages and will call 
    // into the corresponding IPMI providers.
    GDBusProxy *proxy;
    GMainLoop *loop;

    loop = g_main_loop_new (NULL, FALSE);

    // Proxy to use GDbus for OpenBMC channel.
    proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION,
                                           G_DBUS_PROXY_FLAGS_NONE,
                                           NULL, /* GDBusInterfaceInfo */
                                           DBUS_NAME,
                                           OBJ_NAME,
                                           DBUS_NAME,
                                           NULL,
                                           NULL);

    // On receiving the Dbus Signal, handle_ipmi_command gets invoked.
    g_signal_connect (proxy,
                    "g-signal",
                    G_CALLBACK (handle_ipmi_command),
                    NULL);

    // This will not return unless we return false from the upmi_handler function.
    g_main_loop_run (loop);

    return 0;
}