#ifdef __KERNEL__
#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/gfp.h>
#include <linux/mm.h>
#include <linux/device.h>
#include <linux/in.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>

#include "../proc_api/proc_api.h"
#include "../../common/cJSON/cJSON.h"
#include "obj_api.h"

//extern rwlock_t     g_obj_lock;
extern PCMHI_OBJECT g_obj_data;

static int server_obj_show(struct seq_file *seq, void *token)
{
    PCMHI_OBJECT obj, tmp;
    PSERVER_OBJ_CONTENT req = NULL;

    seq_printf(seq, "Total server items:     %u\n", HASH_COUNT(g_obj_data));
    seq_printf(seq, "API root direcotry:     /proc/%s/\n", PROC_API_DIR_NAME);

    //read_lock(&g_obj_lock);
    HASH_ITER(hh, g_obj_data, obj, tmp) {
        read_lock(&obj->lock);
        seq_printf(seq, "    Name:         %s\n", obj->name);
        seq_printf(seq, "    Descript:     %s\n", obj->desc);
        seq_printf(seq, "    Type:         %d\n", obj->type);
        seq_printf(seq, "    RefCount:     %d\n", atomic_read(&obj->ref_count));

        list_for_each_entry(req, &obj->data->content, list) {
            seq_printf(seq, "        Min Port:         %d\n", req->min_port);
            seq_printf(seq, "        Max Port:         %d\n", req->max_port);
            seq_printf(seq, "        Pro Port:         %d\n", req->pro_type);
        }
        read_unlock(&obj->lock);
    }
    //read_unlock(&g_obj_lock);

    return 0;
}

static int server_obj_ioctl(struct seq_file *seq, void *token)
{
    char *json_str = NULL;
    PCMHI_OBJECT obj = NULL;
    PSERVER_OBJ_CONTENT req = NULL;
    PDBGFS_PRIV priv = (PDBGFS_PRIV)(seq->private);

    seq_printf(seq, "Run Command [%s] with (%s)\n", priv->cmd, priv->cmd_data);

    if(strcmp(priv->cmd, "get") == 0) {
        if(strcmp(priv->cmd_data, "all") == 0) {
            PCMHI_OBJECT obj, tmp;
            cJSON *top_array, *top_root = cJSON_CreateObject();

            if(!top_root) {
                return -ENOMEM;
            }

            top_array = cJSON_CreateArray();

            if(!top_array) {
                cJSON_Delete(top_root);
                return -ENOMEM;
            }

            //read_lock(&g_obj_lock);
            HASH_ITER(hh, g_obj_data, obj, tmp) {
                cJSON *array, *root = cJSON_CreateObject();

                if(!root) {
                    cJSON_Delete(top_root);
                    cJSON_Delete(top_array);
                    return -ENOMEM;
                }

                array = cJSON_CreateArray();

                if(!array) {
                    cJSON_Delete(top_root);
                    cJSON_Delete(top_array);
                    cJSON_Delete(root);
                    return -ENOMEM;
                }

                //read_lock(&obj->lock);
                cJSON_AddStringToObject(root, "name", obj->name);
                cJSON_AddStringToObject(root, "desc", obj->desc);
                cJSON_AddNumberToObject(root, "type", obj->type);
                cJSON_AddNumberToObject(root, "ref_count", atomic_read(&obj->ref_count));

                list_for_each_entry(req, &obj->data->content, list) {
                    cJSON *item = cJSON_CreateObject();

                    if(item) {
                        cJSON_AddNumberToObject(item, "min_port", req->min_port);
                        cJSON_AddNumberToObject(item, "max_port", req->max_port);
                        cJSON_AddNumberToObject(item, "pro_type", req->pro_type);
                        cJSON_AddItemToArray(array, item);
                    }
                }
                //read_unlock(&obj->lock);
                cJSON_AddItemToObject(root, "content", array);
                cJSON_AddItemToArray(top_array, root);
            }
            //read_lock(&g_obj_lock);

            cJSON_AddItemToObject(top_root, "data", top_array);
            json_str = cJSON_Print(top_root);

            seq_printf(seq, "%s\n", json_str);
            obj_upgrade_dev_buffer((unsigned char*)json_str, strlen(json_str));
            cJSON_Delete(top_root);
            kfree(json_str);
        } else {
            //read_lock(&g_obj_lock);
            HASH_FIND_STR(g_obj_data, priv->cmd_data, obj);
            //read_unlock(&g_obj_lock);

            if(obj) {
                cJSON *array, *root = cJSON_CreateObject();

                if(!root) {
                    return -ENOMEM;
                }

                array = cJSON_CreateArray();

                if(!array) {
                    return -ENOMEM;
                }

                //read_lock(&obj->lock);
                cJSON_AddStringToObject(root, "name", obj->name);
                cJSON_AddStringToObject(root, "desc", obj->desc);
                cJSON_AddNumberToObject(root, "type", obj->type);
                cJSON_AddNumberToObject(root, "ref_count", atomic_read(&obj->ref_count));

                list_for_each_entry(req, &obj->data->content, list) {
                    cJSON *item = cJSON_CreateObject();

                    if(item) {
                        cJSON_AddNumberToObject(item, "min_port", req->min_port);
                        cJSON_AddNumberToObject(item, "max_port", req->max_port);
                        cJSON_AddNumberToObject(item, "pro_type", req->pro_type);
                        cJSON_AddItemToArray(array, item);
                    }
                }
                //read_unlock(&obj->lock);

                cJSON_AddItemToObject(root, "content", array);

                json_str = cJSON_Print(root);

                seq_printf(seq, "%s\n", json_str);
                obj_upgrade_dev_buffer((unsigned char*)json_str, strlen(json_str));
                cJSON_Delete(root);
                kfree(json_str);
            }
        }
    }

    return 0;
}

static int server_obj_help(struct seq_file *seq, void *token)
{
    PDBGFS_PRIV priv = (PDBGFS_PRIV)(seq->private);
    seq_puts(seq, "==============Options Helps=============\n");
    seq_printf(seq, "usage: echo \"<params>\" > /proc/%s/%s/%s\n",
               PROC_API_DIR_NAME, OBJ_DBG_DIR, priv->name);

    return 0;
}

static DBGFS_PRIV g_DbgConfig[] = {
    {
        "server",   0, 0L, NULL, NULL,
        server_obj_show, server_obj_ioctl, server_obj_help
    },
};

static PROC_API g_object_dbg = {
    OBJ_DBG_DIR, g_DbgConfig, sizeof(g_DbgConfig) / sizeof(g_DbgConfig[0]),
};

int server_proc_init(void)
{
    if(proc_api_register(&g_object_dbg) != ERR_DBGFS_NO_ERROR) {
        printk(KERN_ERR "Regisetr %s Error\n", g_object_dbg.dir_name);
        return -EINVAL;
    }

    return 0;
}

int server_proc_uninit(void)
{
    return proc_api_unregister(&g_object_dbg);
}
#endif