//#include <assert.h>
#include "fip.h"
//#include <fip_flash.h>
//#include "log.h"
#include <stdlib.h>
#include <string.h>
#include "tbbr_img_def.h"
#include "utils_def.h"
#include "ptable.h"

#define MAX_TOC_ENTRY_COUNT 12
fip_toc_entry_t m_fip_toc_entry_list[MAX_TOC_ENTRY_COUNT];
fip_info_t m_fip;

/* By default, ARM platforms load images from the FIP */
static const uuid_map_t image_uuid[] = {
#if 0
    { BL2_IMAGE_ID, UUID_TRUSTED_BOOT_FIRMWARE_BL2 },
    { SCP_BL2_IMAGE_ID, UUID_SCP_FIRMWARE_SCP_BL2 },
    { BL31_IMAGE_ID, UUID_EL3_RUNTIME_FIRMWARE_BL31 },
    { BL32_IMAGE_ID, UUID_SECURE_PAYLOAD_BL32 },
    { BL33_IMAGE_ID, UUID_NON_TRUSTED_FIRMWARE_BL33 },
    { TRUSTED_BOOT_FW_CERT_ID, UUID_TRUSTED_BOOT_FW_CERT },
    { TRUSTED_KEY_CERT_ID, UUID_TRUSTED_KEY_CERT },
    { SCP_FW_KEY_CERT_ID, UUID_SCP_FW_KEY_CERT },
    { SOC_FW_KEY_CERT_ID, UUID_SOC_FW_KEY_CERT },
    { TRUSTED_OS_FW_KEY_CERT_ID, UUID_TRUSTED_OS_FW_KEY_CERT },
    { NON_TRUSTED_FW_KEY_CERT_ID, UUID_NON_TRUSTED_FW_KEY_CERT },
    { SCP_FW_CONTENT_CERT_ID, UUID_SCP_FW_CONTENT_CERT },
    { SOC_FW_CONTENT_CERT_ID, UUID_SOC_FW_CONTENT_CERT },
    { TRUSTED_OS_FW_CONTENT_CERT_ID, UUID_TRUSTED_OS_FW_CONTENT_CERT },
    { NON_TRUSTED_FW_CONTENT_CERT_ID, UUID_NON_TRUSTED_FW_CONTENT_CERT },
    { BL32_EXTRA1_IMAGE_ID, UUID_SECURE_PAYLOAD_BL32_EXTRA1 },
    { BL32_EXTRA2_IMAGE_ID, UUID_SECURE_PAYLOAD_BL32_EXTRA2 },
#endif
    { ASR_OS_CP_IMAGE_ID, UUID_NON_TRUSTED_OS_CP },
    { ASR_OS_CP_KEY_CERT_ID, UUID_NON_TRUSTED_CP_CONTENT_CERT },
    { ASR_OS_DSP_IMAGE_ID, UUID_NON_TRUSTED_OS_DSP },
    { ASR_OS_DSP_KEY_CERT_ID, UUID_NON_TRUSTED_DSP_CONTENT_CERT },
    { ASR_OS_APP_IMAGE_ID, UUID_NON_TRUSTED_OS_APP },
    { ASR_OS_APP_KEY_CERT_ID, UUID_NON_TRUSTED_APP_CONTENT_CERT },
    { ASR_OS_USER1_IMAGE_ID, UUID_NON_TRUSTED_OS_USER1 },
    { ASR_OS_USER1_KEY_CERT_ID, UUID_NON_TRUSTED_USER1_CONTENT_CERT },
    { ASR_OS_USER2_IMAGE_ID, UUID_NON_TRUSTED_OS_USER2 },
    { ASR_OS_USER2_KEY_CERT_ID, UUID_NON_TRUSTED_USER2_CONTENT_CERT },
    { ASR_OS_USER3_IMAGE_ID, UUID_NON_TRUSTED_OS_USER3 },
    { ASR_OS_USER3_KEY_CERT_ID, UUID_NON_TRUSTED_USER3_CONTENT_CERT },
    { ASR_OS_LOGO_IMAGE_ID, UUID_NON_TRUSTED_OS_LOGO },
    { ASR_OS_LOGO_KEY_CERT_ID, UUID_NON_TRUSTED_LOGO_CONTENT_CERT },
    { ASR_OS_UPDATER_IMAGE_ID, UUID_NON_TRUSTED_OS_UPDATER },
    { ASR_OS_UPDATER_KEY_CERT_ID, UUID_NON_TRUSTED_UPDATER_CONTENT_CERT },
};

static const uuid_t uuid_null = {{0}, {0}, {0}, 0, 0, {0, 0, 0, 0, 0, 0}};

extern int uart_printf(const char *fmt, ...);

#define LOG_ERR(fmt, ...) uart_printf(fmt, ## __VA_ARGS__)

static inline int compare_uuids(const uuid_t *uuid1, const uuid_t *uuid2)
{
    return memcmp(uuid1, uuid2, sizeof(uuid_t));
}

uint32_t read_data_from_memory(uint32_t from, uint32_t size, uint8_t *to)
{
    uint8_t *start = (uint8_t *)from;

    if (start + size < to || to + size < start) {
        memcpy(to, start, size);
    }
    else if (to != start) {
        memmove(to, start, size);
    }
    return IOT_ERR_SUCCESS;
}

static uint32_t fip_read_data(uint32_t from, uint32_t size, uint8_t *to)
{
   return read_data_from_memory(from, size, to);
}

/*
 * See if a Firmware Image Package is available,
 * by checking if TOC is valid or not.
 */
int is_valid_fip(void *address)
{
    fip_toc_header_t header;

    read_data_from_memory((uint32_t)(uintptr_t)address, sizeof(header), (uint8_t *)&header);

    return header.name == TOC_HEADER_NAME;
}

int fip_get_plat_flag(void *address, uint16_t *flag)
{
    fip_toc_header_t header;

    read_data_from_memory((uint32_t)(uintptr_t)address, sizeof(header), (uint8_t *)&header);

    if (header.name == TOC_HEADER_NAME) {
        *flag = (header.flags >> 32) & 0xFFFF;
        return 0;
    }
    else {
        LOG_ERR("Not a valid FIP");
        return -1;
    }
}


//==============================================
//DESC:
//	initial the static m_fip ,for FIP parse ToC struct
//
//PARAM:
//	address	- the address of fwcert.bin
//
//RETURN:
// fip_handle
//==============================================

fip_handle fip_open(void *address)
{
    fip_handle fh = calloc(1, sizeof(*fh));

    if (!fh) {
        LOG_ERR("Out of memory!");
        return NULL;
    }

    fh->read = fip_read_data;
    fh->address = (uint32_t)(uintptr_t)address;

    if (fh->read(fh->address, sizeof(fh->toc), (uint8_t *)&fh->toc) != IOT_ERR_SUCCESS) {
        LOG_ERR("Read fail!");
        free(fh);
        return NULL;
    }

#if 0
	LOG_ERR("[SECBOOT]fh->address          = [0x%0.8x]\r\n",fh->address);
	LOG_ERR("[SECBOOT]fh->toc.name         = [0x%0.8x]\r\n",fh->toc.name);
	LOG_ERR("[SECBOOT]fh->toc.serial_number= [0x%0.8x]\r\n",fh->toc.serial_number);
	LOG_ERR("[SECBOOT]fh->toc.flags        = [0x%0.8x]\r\n",fh->toc.flags);
#endif

    if (fh->toc.name != TOC_HEADER_NAME) {
        LOG_ERR("fh->address:[%08x] fh->toc:[%08x]", ((uint32_t *)(fh->address))[0], fh->toc.name);
        LOG_ERR("Not a fip!");
        free(fh);
        return NULL;
    }

    fip_toc_entry_t entry;
    uint32_t entry_address = fh->address + sizeof(fh->toc);

//      PARSER THE FIP STRUCT
//
//      ----------------- 
//      | ToC Header     |
//      |----------------|
//      | ToC Entry 0    |
//      |----------------|
//      | ToC Entry 1    |
//      |----------------|
//      | ToC End Marker |
//      |----------------|
//      | Data 0         |
//      |----------------|
//      | Data 1         |
//      |----------------|
//
 
	do {
        if (fh->read(entry_address, sizeof(entry), (uint8_t *)&entry) != IOT_ERR_SUCCESS) {
            LOG_ERR("Read fail!");
            free(fh);
            return NULL;
        }

        entry_address += sizeof(entry);
		if(!compare_uuids(&entry.uuid, &uuid_null) || fh->entry_count >= MAX_TOC_ENTRY_COUNT)
			break;

#if 0
	LOG_ERR("[SECBOOT]>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\r\n");
	LOG_ERR("[SECBOOT]entry.num              = [0x%0.8x]\r\n",fh->entry_count);
	LOG_ERR("[SECBOOT]entry.start            = [0x%0.8x]\r\n",(uint32_t)fh->address);
	LOG_ERR("[SECBOOT]entry.offset_address   = [0x%0.8x]\r\n",(uint32_t)entry.offset_address);
	LOG_ERR("[SECBOOT]entry.size             = [0x%0.8x]\r\n",(uint32_t)entry.size);
#endif


        fh->entry_count++;
    } while (1);

	LOG_ERR("[SECBOOT]fh->entry_count = [%d]\r\n",fh->entry_count);

    fh->entry = calloc(1, fh->entry_count * sizeof(*fh->entry));
    if (!fh->entry) {
        LOG_ERR("Out of memory");
        free(fh);
        return NULL;
    }

    entry_address = fh->address + sizeof(fh->toc);
    if (fh->read(entry_address, fh->entry_count * sizeof(entry), (uint8_t *)fh->entry) != IOT_ERR_SUCCESS) {
        LOG_ERR("Read fail!");
        free(fh->entry);
        free(fh);
        return NULL;
    }

    return fh;
}

int fip_close(fip_handle fh)
{
    if (fh) {
        free(fh->entry);
        free(fh);
    }

    return 0;
}

static int find_uuid_by_id(unsigned int image_id)
{
	int i;
    for (i = 0; i < (int)ARRAY_SIZE(image_uuid); i++) {
        if (image_uuid[i].id == image_id) {
            return i;
        }
    }

    LOG_ERR("Can't find uuid by id %d", image_id);
    return -1;
}

int fip_get_image_info_by_uuid(fip_handle fh, const uuid_t *puuid, unsigned int image_id, uint32_t *pstart, uint32_t *poffset, uint32_t *psize)
{
    int index = 0;

    if (!fh) {
        LOG_ERR("Fip handle is empty");
        return -1;
    }

    if (!fh->entry_count) {
        LOG_ERR("Fip has no any images!");
        return -1;
    }

    if (puuid == NULL) {
        index = find_uuid_by_id(image_id);
        if (index < 0) {
            return -1;
        }

        puuid = &image_uuid[index].uuid;
    }

    int entry_index = -1;
	int i;
    for (i = 0; i < fh->entry_count; i++) {
        if (!compare_uuids(&fh->entry[i].uuid, puuid)) {
            entry_index = i;
            break;
        }
    }

    if (entry_index < 0) {
        LOG_ERR("Fip doesn't contain image(id=%u)", image_id);
        return -1;
    }

    if (pstart) {
        *pstart = fh->address;
    }

    if (poffset) {
        *poffset = fh->entry[entry_index].offset_address;
    }

    if (psize) {
        *psize = fh->entry[entry_index].size;
    }

    return 0;
}

int fip_get_image_info(fip_handle fh, unsigned int image_id, uint32_t *pstart, uint32_t *poffset, uint32_t *psize)
{
    return fip_get_image_info_by_uuid(fh, NULL, image_id, pstart, poffset, psize);
}

int fip_close_image(fip_image_handle fih)
{
    free(fih);
    return 0;
}

int32_t fip_read_image(fip_image_handle fih, uint8_t *data, uint32_t size)
{
    if (!fih) {
        LOG_ERR("Can't read empty fip img");
        return 0;
    }

    if (!data) {
        LOG_ERR("Can't store to empty buffer");
        return 0;
    }

    uint32_t real_size = MIN(size, fih->size);

    if (!real_size) {
        return 0;
    }

    int32_t ret = fih->read(fih->start + fih->offset, real_size, data);

    if (ret < 0) {
        LOG_ERR("Read fail!");
    }

    return ret;
}