/*
 * Copyright (c) XMEDIA. All rights reserved.
 */

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <dlfcn.h>

#include "xmedia_sys.h"
#include "xmedia_isp.h"
#include "xmedia_vi.h"
#include "sample_comm.h"
#include "sample_comm_pq_bin.h"

xmedia_u32 g_isp_len = 0;
xmedia_u32 g_isp_ex_len = 0;

/**************************** isp bin data content ***************************
 *
 *  magic_isp : 16byte
 *  pipe      : sizeof(xmedia_s32)
 *  isp_data  : sizeof(xmedia_isp_module_info) * ISP_MODULE_ISP_EX_NUM +
 *              xmedia_isp_module_info.length[i] * ISP_MODULE_ISP_EX_NUM
 *
 *****************************************************************************/
xmedia_u32 get_isp_export_len(xmedia_void)
{
    return g_isp_len;
}

/**************************** isp_ex bin data content ***************************
 *
 *  magic_isp : 16byte
 *  pipe      : sizeof(xmedia_s32)
 *  isp_data  : sizeof(xmedia_isp_module_info) + xmedia_isp_module_info.length[ISP_EX]
 *
 *****************************************************************************/
xmedia_u32 get_isp_ex_export_len(xmedia_void)
{
    return g_isp_ex_len;
}

xmedia_u32 pq_bin_isp_export(bin_module_info *module, xmedia_isp_module_info *isp_mod_info)
{
    xmedia_s32 ret;

    isp_mod_info[0].module = XMEDIA_ISP_MODULE_ID_ISP;
    isp_mod_info[1].module = XMEDIA_ISP_MODULE_ID_AWB;
    isp_mod_info[2].module = XMEDIA_ISP_MODULE_ID_AE;
    //isp_mod_info[3].module = XMEDIA_ISP_MODULE_ID_AF;

    ret = xmedia_isp_export(module->vi.pipe, isp_mod_info);
    if (ret != XMEDIA_SUCCESS) {
        SAMPLE_ERR("xmedia_isp_export err(%#x)\n", ret);
        return XMEDIA_FAILURE;
    }

    return XMEDIA_SUCCESS;
}

xmedia_u32 pq_bin_isp_ex_export(bin_module_info *module, xmedia_isp_module_info *isp_mod_info)
{
    xmedia_s32 ret;

    isp_mod_info[0].module = XMEDIA_ISP_MODULE_ID_ISP_EX;

    ret = xmedia_isp_export(module->ex.pipe, isp_mod_info);
    if (ret != XMEDIA_SUCCESS) {
        SAMPLE_ERR("xmedia_isp_export err(%#x)\n", ret);
        return XMEDIA_FAILURE;
    }

    return XMEDIA_SUCCESS;
}

xmedia_u32 get_isp_data_len(bin_module_info *module)
{
    xmedia_s32 ret;
    xmedia_isp_module_info isp_mod_info[XMEDIA_ISP_MODULE_MAX_NUM] = { 0 };

    g_isp_len = MAGIC_DATA_LEN;
    g_isp_len += sizeof(xmedia_s32);
    g_isp_len += sizeof(xmedia_isp_module_info) * ISP_MODULE_ISP_EX_NUM;

    ret = pq_bin_isp_export(module, isp_mod_info);
    if (ret != XMEDIA_SUCCESS) {
        return ret;
    }

    for (xmedia_s32 i = 0; i < ISP_MODULE_ISP_EX_NUM; i++) {
        SAMPLE_PRT("isp[%d].length = %d\n", i, isp_mod_info[i].length);
        g_isp_len += isp_mod_info[i].length;
    }

    return g_isp_len;
}

xmedia_u32 get_isp_ex_data_len(bin_module_info *module)
{
    xmedia_s32 ret;
    xmedia_isp_module_info isp_mod_info[XMEDIA_ISP_MODULE_MAX_NUM] = { 0 };

    g_isp_ex_len = MAGIC_DATA_LEN;
    g_isp_ex_len += sizeof(xmedia_s32);
    g_isp_ex_len += sizeof(xmedia_isp_module_info);

    ret = pq_bin_isp_ex_export(module, isp_mod_info);
    if (ret != XMEDIA_SUCCESS) {
        return ret;
    }

    for (xmedia_s32 i = 0; i < XMEDIA_ISP_MODULE_MAX_NUM; i++) {
        if (isp_mod_info[i].module == XMEDIA_ISP_MODULE_ID_ISP_EX) {
            SAMPLE_PRT("isp_ex.length = %d\n", isp_mod_info[i].length);
            g_isp_ex_len += isp_mod_info[i].length;
            break;
        }
    }

    return g_isp_ex_len;
}

xmedia_u32 get_isp_import_len(xmedia_u8* buffer)
{
    xmedia_u32 len;
    xmedia_u8 *pos = buffer;
    xmedia_isp_module_info isp_mod_info[XMEDIA_ISP_MODULE_MAX_NUM] = { 0 };

    pos += MAGIC_DATA_LEN;
    pos += sizeof(xmedia_s32);

    memcpy(&isp_mod_info, pos, sizeof(xmedia_isp_module_info) * ISP_MODULE_ISP_EX_NUM);
    pos += sizeof(xmedia_isp_module_info) * ISP_MODULE_ISP_EX_NUM;

    for (xmedia_s32 index = 0; index < ISP_MODULE_ISP_EX_NUM; index++) {
        SAMPLE_PRT("isp[%d].length=%d\n", index, isp_mod_info[index].length);
        pos += isp_mod_info[index].length;
    }

    len = pos - buffer;

    return len;
}

xmedia_u32 get_isp_ex_import_len(xmedia_u8* buffer)
{
    xmedia_u32 len;
    xmedia_u8 *pos = buffer;
    xmedia_isp_module_info isp_mod_info[XMEDIA_ISP_MODULE_MAX_NUM] = { 0 };

    pos += MAGIC_DATA_LEN;
    pos += sizeof(xmedia_s32);

    memcpy(&isp_mod_info, pos, sizeof(xmedia_isp_module_info));
    pos += sizeof(xmedia_isp_module_info);

    SAMPLE_PRT("isp_ex.length=%d\n", isp_mod_info[0].length);
    pos += isp_mod_info[0].length;

    len = pos - buffer;

    return len;
}

xmedia_s32 pq_bin_export_isp_data(bin_module_info *module, xmedia_u8 *buffer, xmedia_u32 isp_data_len)
{
    xmedia_u8 *pos = buffer;
    xmedia_isp_module_info isp_mod_info[XMEDIA_ISP_MODULE_MAX_NUM] = { 0 };
    xmedia_s32 ret;

    CHECK_NULL_PTR(module);
    CHECK_NULL_PTR(buffer);

    memcpy(pos, magic_isp, MAGIC_DATA_LEN);
    pos += MAGIC_DATA_LEN;

    memcpy(pos, &module->vi.pipe, sizeof(xmedia_s32));
    pos += sizeof(xmedia_s32);

    ret = pq_bin_isp_export(module, isp_mod_info);
    if (ret != XMEDIA_SUCCESS) {
        return XMEDIA_FAILURE;
    }

    memcpy(pos, &isp_mod_info, sizeof(xmedia_isp_module_info) * ISP_MODULE_ISP_EX_NUM);
    pos += sizeof(xmedia_isp_module_info) * ISP_MODULE_ISP_EX_NUM;

    for (xmedia_s32 index = 0; index < ISP_MODULE_ISP_EX_NUM; index++) {
        memcpy(pos, isp_mod_info[index].addr, isp_mod_info[index].length);
        pos += isp_mod_info[index].length;
    }

    if (isp_data_len != (pos - buffer)) {
        SAMPLE_ERR("The exported length does not match the expected length.\n");
        return XMEDIA_FAILURE;
    }

    return XMEDIA_SUCCESS;
}

xmedia_s32 pq_bin_export_isp_ex_data(bin_module_info *module, xmedia_u8 *buffer, xmedia_u32 isp_ex_data_len)
{
    xmedia_u8 *pos = buffer;
    xmedia_isp_module_info isp_mod_info[XMEDIA_ISP_MODULE_MAX_NUM] = { 0 };
    xmedia_s32 ret;

    CHECK_NULL_PTR(module);
    CHECK_NULL_PTR(buffer);

    memcpy(pos, magic_isp_ex, MAGIC_DATA_LEN);
    pos += MAGIC_DATA_LEN;

    memcpy(pos, &module->ex.pipe, sizeof(xmedia_s32));
    pos += sizeof(xmedia_s32);

    ret = pq_bin_isp_ex_export(module, isp_mod_info);
    if (ret != XMEDIA_SUCCESS) {
        return XMEDIA_FAILURE;
    }

    memcpy(pos, &isp_mod_info, sizeof(xmedia_isp_module_info));
    pos += sizeof(xmedia_isp_module_info);

    for (xmedia_s32 index = 0; index < XMEDIA_ISP_MODULE_MAX_NUM; index++) {
        if (isp_mod_info[index].module == XMEDIA_ISP_MODULE_ID_ISP_EX) {
            memcpy(pos, isp_mod_info[index].addr, isp_mod_info[index].length);
            pos += isp_mod_info[index].length;
            break;
        }

        if (index == XMEDIA_ISP_MODULE_MAX_NUM) {
            return XMEDIA_FAILURE;
        }
    }

    if (isp_ex_data_len != (pos - buffer)) {
        SAMPLE_ERR("The exported length does not match the expected length.\n");
        return XMEDIA_FAILURE;
    }

    return XMEDIA_SUCCESS;
}

xmedia_s32 pq_bin_import_isp_data(bin_module_info *module, xmedia_u8* buffer)
{
    xmedia_s32 ret = XMEDIA_SUCCESS;
    xmedia_u8 *pos = buffer;
    xmedia_isp_module_info isp_mod_info[XMEDIA_ISP_MODULE_MAX_NUM] = { 0 };

    pos += MAGIC_DATA_LEN;
    pos += sizeof(xmedia_s32);

    memcpy(&isp_mod_info, pos, sizeof(xmedia_isp_module_info) * ISP_MODULE_ISP_EX_NUM);
    pos += sizeof(xmedia_isp_module_info) * ISP_MODULE_ISP_EX_NUM;

    for (xmedia_s32 index = 0; index < ISP_MODULE_ISP_EX_NUM; index++) {
        isp_mod_info[index].addr = pos;
        pos += isp_mod_info[index].length;
    }

    ret = xmedia_isp_import(module->vi.pipe, isp_mod_info);
    if (ret != XMEDIA_SUCCESS) {
        SAMPLE_ERR("xmedia_isp_import failed.\n");
        return XMEDIA_FAILURE;
    }

    return XMEDIA_SUCCESS;
}

xmedia_s32 pq_bin_import_isp_ex_data(bin_module_info *module, xmedia_u8* buffer)
{
    xmedia_s32 ret = XMEDIA_SUCCESS;
    xmedia_u8 *pos = buffer;
    xmedia_isp_module_info isp_mod_info[XMEDIA_ISP_MODULE_MAX_NUM] = { 0 };

    pos += MAGIC_DATA_LEN;
    pos += sizeof(xmedia_s32);

    memcpy(&isp_mod_info, pos, sizeof(xmedia_isp_module_info));
    pos += sizeof(xmedia_isp_module_info);

    isp_mod_info[0].addr = pos;
    pos += isp_mod_info[0].length;

    ret = xmedia_isp_import(module->ex.pipe, isp_mod_info);
    if (ret != XMEDIA_SUCCESS) {
        SAMPLE_ERR("xmedia_isp_import failed.\n");
        return XMEDIA_FAILURE;
    }

    return XMEDIA_SUCCESS;
}

xmedia_s32 pq_bin_data_export(bin_module_info *module, xmedia_u8 *buffer, xmedia_u32 total_len)
{
    xmedia_s32 ret;
    xmedia_u32 len;
    xmedia_s32 result = -1;
    xmedia_u8 *pos = buffer;

    xmedia_sys_get_tuning_connect(&result);
    if (result == 0 || result == -1) {
        SAMPLE_ERR("xmedia_sys_get_tuning_connect failed\n");
        return XMEDIA_FAILURE;
    }

    // Export ISP Data
    if (module->vi.enable == XMEDIA_TRUE) {
        len = get_isp_export_len();

        ret = pq_bin_export_isp_data(module, buffer, len);
        if (ret != XMEDIA_SUCCESS) {
            SAMPLE_ERR("pq_bin_export_isp_data failed\n");
            return ret;
        }

        buffer += len;
    }

    // Export ISP_EX Data
    if (module->ex.enable == XMEDIA_TRUE) {
        len = get_isp_ex_export_len();

        ret = pq_bin_export_isp_ex_data(module, buffer, len);
        if (ret != XMEDIA_SUCCESS) {
            SAMPLE_ERR("pq_bin_export_isp_ex_data failed\n");
            return ret;
        }

        buffer += len;
    }

    if (total_len != buffer - pos) {
        SAMPLE_ERR("The exported length does not match the expected length.\n");
        return XMEDIA_FAILURE;
    }

    return XMEDIA_SUCCESS;
}

xmedia_s32 pq_bin_data_import(bin_module_info *module, xmedia_u8 *buffer, xmedia_u32 total_len)
{
    xmedia_s32 ret = XMEDIA_SUCCESS;
    xmedia_u32 len;
    xmedia_s32 result = -1;

    if (buffer == XMEDIA_NULL) {
        SAMPLE_ERR("buffer is a null pointer.\n");
        return XMEDIA_FAILURE;
    }

    xmedia_sys_get_tuning_connect(&result);
    if (result == 0 || result == -1) {
        SAMPLE_ERR("xmedia_sys_get_tuning_connect failed.\n");
        return XMEDIA_FAILURE;
    }

    //isp data
    if (total_len > sizeof(magic_isp) && memcmp(&magic_isp, buffer, sizeof(magic_isp)) == 0) {
        len = get_isp_import_len(buffer);
        total_len -= len;

        if (total_len < 0) {
            SAMPLE_ERR("pq_bin data is incomplete!\n");
            return XMEDIA_FAILURE;
        }

        if (module->vi.enable == XMEDIA_TRUE) {
            SAMPLE_ERR("pq_bin isp data size: %d\n", len);

            ret = pq_bin_import_isp_data(module, buffer);
            if (ret != XMEDIA_SUCCESS) {
                SAMPLE_ERR("pq_bin import isp data failed\n");
                return ret;
            }

            SAMPLE_ERR("pq_bin import isp data success\n");
        }

        buffer += len;
    } else if (module->vi.enable == XMEDIA_TRUE) {
        SAMPLE_ERR("pq_bin does not cantain data for isp, cannot enable isp.\n");
        return XMEDIA_FAILURE;
    }

    //isp_ex data
    if (total_len > sizeof(magic_isp_ex) && memcmp(&magic_isp_ex, buffer, sizeof(magic_isp_ex)) == 0) {
        len = get_isp_ex_import_len(buffer);
        total_len -= len;

        if (total_len < 0) {
            SAMPLE_ERR("pq_bin data is incomplete!\n");
            return XMEDIA_FAILURE;
        }

        if (module->ex.enable == XMEDIA_TRUE) {
            SAMPLE_ERR("pq_bin isp_ex data size: %d\n", len);

            ret = pq_bin_import_isp_ex_data(module, buffer);
            if (ret != XMEDIA_SUCCESS) {
                SAMPLE_ERR("pq_bin import isp_ex data failed\n");
                return ret;
            }

            SAMPLE_ERR("pq_bin import isp_ex data success\n");
        }
    } else if (module->ex.enable == XMEDIA_TRUE) {
        SAMPLE_ERR("pq_bin does not cantain data for isp_ex, cannot enable isp_ex.\n");
        return XMEDIA_FAILURE;
    }

    return XMEDIA_SUCCESS;
}

xmedia_u32 get_pq_bin_length(xmedia_u8 *para)
{
    xmedia_u32 offSet = 0;
    xmedia_u32 length = 0;
    xmedia_u32 tmp_len = 0;
    bin_module_info mod = { 0 };

    mod.vi.pipe = *(xmedia_s32 *)(para + offSet);
    offSet += sizeof(xmedia_s32);

    mod.vpss.pipe = *(xmedia_s32 *)(para + offSet);
    offSet += sizeof(xmedia_s32);

    mod.mcf.pipe = *(xmedia_s32 *)(para + offSet);
    offSet += sizeof(xmedia_s32);

    mod.mcf.ichn = *(xmedia_s32 *)(para + offSet);
    offSet += sizeof(xmedia_s32);

    mod.ex.pipe = *(xmedia_s32 *)(para + offSet);
    offSet += sizeof(xmedia_s32);

    mod.vi.enable = *(xmedia_s32 *)(para + offSet);
    offSet += sizeof(xmedia_s32);

    mod.vpss.enable = *(xmedia_s32 *)(para + offSet);
    offSet += sizeof(xmedia_s32);

    mod.mcf.enable = *(xmedia_s32 *)(para + offSet);
    offSet += sizeof(xmedia_s32);

    mod.ex.enable = *(xmedia_s32 *)(para + offSet);

    if (mod.vi.enable != XMEDIA_TRUE && mod.ex.enable != XMEDIA_TRUE) {
        SAMPLE_ERR("Please at least one module that you want to export.\n");
        return XMEDIA_FAILURE;
    }

    if (mod.vi.enable == XMEDIA_TRUE) {
        tmp_len = get_isp_data_len(&mod);
        if (tmp_len == XMEDIA_FAILURE) {
            return XMEDIA_FAILURE;
        }

        SAMPLE_ERR("Export ISP data total len: %u\n", tmp_len);
        length += tmp_len;
    }

    if (mod.ex.enable == XMEDIA_TRUE) {
        tmp_len = get_isp_ex_data_len(&mod);
        if (tmp_len == XMEDIA_FAILURE) {
            return XMEDIA_FAILURE;
        }

        SAMPLE_ERR("Export ISP_EX data total len: %u\n", tmp_len);
        length += tmp_len;
    }

    return length;
}

xmedia_s32 sample_comm_pq_bin_export(bin_module_info *module, xmedia_u8 *buffer,
    xmedia_u32 total_length, xmedia_char *file_name)
{
    xmedia_s32 ret;
    xmedia_u32 tmp_len;
    FILE *fd = XMEDIA_NULL;

    fd = fopen(file_name, "wb+");
    if (fd == XMEDIA_NULL) {
        SAMPLE_ERR("pq bin file open failed.\n");
        ret = -1;
        goto err;
    }

    ret = pq_bin_data_export(module, buffer, total_length);
    if (ret != 0) {
        SAMPLE_ERR("pq_bin_data_export err(%#x)!\n", ret);
    } else {
        tmp_len = fwrite(buffer, 1, total_length, fd);
        if (tmp_len != total_length) {
            SAMPLE_ERR("write pq bin file err!\n");
            ret = -1;
            goto err;
        }

        SAMPLE_ERR("\nexport bin data success!\n");
    }

err:
    if (fd != XMEDIA_NULL) {
        fclose(fd);
    }

    return ret;
}

xmedia_s32 sample_comm_pq_bin_import(bin_module_info *module, xmedia_char *file_name)
{
    xmedia_s32 ret = XMEDIA_FAILURE;
    xmedia_u32 size;
    xmedia_u32 tmp_len;
    xmedia_u8 *buffer = XMEDIA_NULL;
    FILE *fd = XMEDIA_NULL;

    fd = fopen(file_name, "r");
    if (fd == XMEDIA_NULL) {
        SAMPLE_ERR("No such file.\n");
        return XMEDIA_FAILURE;
    }

    fseek(fd, 0, SEEK_END);
    size = ftell(fd);
    fseek(fd, 0, SEEK_SET);

    buffer = (xmedia_u8 *)malloc(size);
    if (buffer == XMEDIA_NULL) {
        SAMPLE_ERR("buffer malloc fail\n");
        fclose(fd);
        return XMEDIA_FAILURE;
    }

    tmp_len = fread(buffer, sizeof(xmedia_u8), size, fd);
    if (tmp_len == 0) {
        SAMPLE_ERR("read error\n");
        goto err;
    }

    ret = pq_bin_data_import(module, buffer, size);
    if (ret != XMEDIA_SUCCESS) {
        SAMPLE_ERR("pq_bin_data_import err(%#x)\n", ret);
    } else {
        SAMPLE_ERR("\nimport bin data success!\n");
    }

err:
    fclose(fd);
    free(buffer);
    buffer = XMEDIA_NULL;

    return ret;
}