#include "system/includes.h"
#include "system/task.h"
#include "app_config.h"
#include "net_update.h"
#include "update/update_loader_download.h"
#include "dual_bank_updata_api.h"
#include "generic/errno-base.h"
#include "update.h"
#include "timer.h"
#include "fs/fs.h"
#include "os/os_api.h"
#include "device/device.h"
#include "asm/includes.h"

//=======================net_update==========================================================
#define NET_UPDATE_STATE_NONE	0
#define NET_UPDATE_STATE_OK		1
#define NET_UPDATE_STATE_ERR	2
#define NET_UPDATE_STATE_CLOSE	3

#define NET_UPDATE_BUF_CHECK	0x12345678 //防止写超buf检测
/* #define DUAL_BANK_VERIFY_ENABLE */    //回读flash进行校验
/* #define DATA_DOWNLOAD_VERIFY_ENABLE */ //对下载的数据进行校验

#define FLASH_SECTOR_SIZE 			(4*1024)
#define NET_UPDATE_BUFF_SIZE_MAX	(4*1024) //缓存要>=4K，否则可能会引起在初始化时候升级失败

struct net_update {
    u8 update_doing;
    u8 update_state;
    u8 write_to_flash;
    u8 *recv_buf;
    u32 recv_buf_size;
    u32 offset;
    u32 recv_cnt;
    u32 req_seek;
    OS_SEM sem;
    FILE *fd;
};

#ifdef DATA_DOWNLOAD_VERIFY_ENABLE
typedef struct stJL_FILE_HEAD {
    u16 u16Crc;
    u16 u16DataCrc;
    u32 u32Address;
    u32 u32Length;

    u8 u8Attribute;
    u8 u8Res;
    u16 u16Index;
    char szFileName[16];
} JL_FILE_HEAD;

extern u16 calc_crc16_with_init_val(u16 init_crc, u8 *ptr, u16 len);
static int firstBlock = 1;
static u16 calcCrc = 0;
static JL_FILE_HEAD gUpdateHead;
#endif

static struct net_update *net_update_info = NULL;
int storage_device_ready(void);
u32 get_target_udate_addr(void);
//=======================net_update==========================================================
#ifdef DUAL_BANK_VERIFY_ENABLE
static int dual_bank_verify_hdl(int result)
{
    if (result) {
        printf("app core verify OK!");
        //回读校验正确，更新启动信息
        dual_bank_update_burn_boot_info(net_update_finish_callback);
    } else if (net_update_info) {
        //回读校验错误
        net_update_info->update_state = NET_UPDATE_STATE_ERR;
        os_sem_post(&net_update_info->sem);
        printf("net_update err\n\n");
        return -1;
    }

    return 0;
}
#endif

#ifdef DATA_DOWNLOAD_VERIFY_ENABLE
static int net_update_check(JL_FILE_HEAD *head, const u8 *buf, const u32 len)
{
    int ret;

    if ((32 > len) || (NULL == head)) {
        return -1;
    }

    memcpy((u8 *)head, buf, sizeof(JL_FILE_HEAD));

    ret = jl_file_head_valid_check(head);
    if (ret) {
        return -1;
    }

    if (0 == strcmp((head->szFileName), "update_data")) {
        return 0;
    }

    printf("update file not match!\n");
    return -1;
}
#endif

static void net_update_system_reset(void *priv)
{
    if (get_power_keep_state() & POWER_KEEP_RTC) { //需要使用软关机唤醒的方式复位,否则系统复位会导致RTC时间掉
        printf("cpu by rtc reset soft_poweroff....\n\n");
        power_set_soft_poweroff(10);//first pwoer off 10ms will power on
    } else {
        printf("cpu system_reset ....\n\n");
        system_reset();
    }
}
static int net_update_doing_callback(void *result)
{
    if (result) {
        if (net_update_info) {
            net_update_info->update_state = NET_UPDATE_STATE_ERR;
            os_sem_post(&net_update_info->sem);
        }
        printf("net_update doing err\n\n");
    }

    return 0;
}
static int net_update_finish_callback(int result)
{
    if (!result) {
        if (net_update_info) {
            net_update_info->update_state = NET_UPDATE_STATE_OK;
            os_sem_post(&net_update_info->sem);
        }
        printf("net_update successfuly\n\n");
    } else if (net_update_info) {
        net_update_info->update_state = NET_UPDATE_STATE_ERR;
        os_sem_post(&net_update_info->sem);
        printf("net_update err\n\n");
        return -1;
    }
    return 0;
}
int net_update_request(void)
{
    if (net_update_info) {
        return net_update_info->update_doing;
    }
    return 0;
}
void *net_fopen(char *path, char *mode)//net_fopen支持写flash固件升级和写到SD卡，当名字字符有CONFIG_UPGRADE_OTA_FILE_NAME时是固件升级
{
    //防止超时时，在没退出时，客户端再次重入
    int ret = net_update_request();
    if (ret) {
        printf("err ota update is doing !!!!!!!!!!!!!!\n");//保证FTP传输等网络升级请求需要确保传输队列只有一次OTA文件请求（否则后续无法升级）
        return NULL;
    }

    struct net_update *net_update = zalloc(sizeof(struct net_update));
    if (!net_update) {
        printf("err in no mem \n\n");
        goto err;
    }
    if (strstr(path, CONFIG_UPGRADE_OTA_FILE_NAME)) {//名字是OTA升级名字就进行写flash升级模式
        net_update->recv_buf = malloc(NET_UPDATE_BUFF_SIZE_MAX + 4);
        if (!net_update->recv_buf) {
            goto err;
        }
        net_update->update_doing = true;
        net_update->write_to_flash = true;
        net_update->offset = 0;
        net_update->req_seek = 0;
        net_update->recv_cnt = 0;
        net_update->update_state = NET_UPDATE_STATE_NONE;
        net_update->recv_buf_size = NET_UPDATE_BUFF_SIZE_MAX;
        os_sem_create(&net_update->sem, 0);
        net_update_info = net_update;
        u32 *check = (u32 *)(net_update->recv_buf + net_update->recv_buf_size);
        *check = NET_UPDATE_BUF_CHECK;
        return (void *)net_update;
    } else if (storage_device_ready()) {
        net_update->fd = fopen(path, mode);
        if (!net_update->fd) {
            goto err;
        }
        return (void *)net_update;
    }
err:
    if (net_update) {
        if (net_update->recv_buf) {
            free(net_update->recv_buf);
        }
        free(net_update);
    }
    net_update_info = NULL;
    return NULL;
}
int net_fclose(void *fd, char is_socket_err)
{
    struct net_update *net_update = (struct net_update *)fd;
    int err = 0;

    if (!net_update) {
        net_update = net_update ? net_update : net_update_info;
        printf("warnning net_fclose fd NULL \n");
    }
    if (net_update->write_to_flash) {
        u32 *check = (u32 *)(net_update->recv_buf + net_update->recv_buf_size);
        if (*check != NET_UPDATE_BUF_CHECK) {
            printf("err check in %s, check = 0x%x \n\n\n", __func__, *check);
        }
        printf("net close %s \n", is_socket_err ? "is_socket_err" : "normal");
        if (net_update->offset && net_update->update_state == NET_UPDATE_STATE_NONE && !is_socket_err) {
            err = net_fwrite(net_update, NULL, net_update->offset, 1);//写剩余的缓存到flash
            if (err != net_update->offset) {
                err = -1;
                printf("err net_fclose write  = %d \n", err);
            }
        }

        if (net_update->update_state == NET_UPDATE_STATE_NONE && !is_socket_err) {
#ifdef DATA_DOWNLOAD_VERIFY_ENABLE
            if (calcCrc == gUpdateHead.u16DataCrc) {
                dual_bank_update_burn_boot_info(net_update_finish_callback);
                err = os_sem_pend(&net_update_info->sem, 500);
                if (err) {
                    err = -1;
                    printf("net_update verify wait time out err\n\n\n\n");
                }
            } else {
                printf("crc err, calcCrc = 0x%x, headCrc = 0x%x\n", calcCrc, gUpdateHead.u16DataCrc);
                net_update->update_state == NET_UPDATE_STATE_ERR;
            }
#else

#ifdef DUAL_BANK_VERIFY_ENABLE
            dual_bank_update_verify(NULL, NULL, dual_bank_verify_hdl);
#else
            //更新启动信息
            dual_bank_update_burn_boot_info(net_update_finish_callback);
#endif //DUAL_BANK_VERIFY_ENABLE

            err = os_sem_pend(&net_update_info->sem, 500);
            if (err) {
                err = -1;
                printf("net_update verify wait time out err\n\n\n\n");
            }
#endif //DATA_DOWNLOAD_VERIFY_ENABLE
        }

        net_update->update_doing = 0;
        if (net_update->update_state == NET_UPDATE_STATE_OK) {//升级成功，2s后重启系统
            sys_timeout_add_to_task("sys_timer", NULL, net_update_system_reset, 2000);
            printf(">>>>>>>>>>>net_update successfuly , system will reset after 2s ...\n\n");
        } else {
            err = -1;
            printf(">>>>>>>>>>>net_update err\n\n\n\n");
        }
        net_update->update_state = NET_UPDATE_STATE_CLOSE;
        os_sem_del(&net_update->sem, 0);
        dual_bank_passive_update_exit(NULL);
    } else if (net_update->fd) {
        fclose(net_update->fd);
    }
    if (net_update->recv_buf) {
        free(net_update->recv_buf);
    }
    net_update_info = NULL;
    free(net_update);
    return err;
}
int net_flen(void *fd)
{
    struct net_update *net_update = (struct net_update *)fd;
    if (net_update && !net_update->write_to_flash && net_update->fd) {
        return flen(net_update->fd);
    }
    return 0;
}
int net_fread(void *fd, char *buf, int len)
{
    struct net_update *net_update = (struct net_update *)fd;
    if (net_update && !net_update->write_to_flash && net_update->fd) {
        return fread(buf, 1, len, net_update->fd);
    }
    return 0;
}
int net_fwrite(void *fd, unsigned char *buf, int len, int end)
{
    struct net_update *net_update = (struct net_update *)fd;
    int ret = len;
    int err;
    int wr_len = 0;
    int wr_offset = 0;
    int rd_len = 0;
    int rd_offset = 0;
    int buf_offset = 0;
    int cp_remain = net_update->recv_buf_size;
    u8 *cp_buf = (u8 *)net_update->recv_buf;
    u32 *check = (u32 *)(net_update->recv_buf + net_update->recv_buf_size);

#ifdef DATA_DOWNLOAD_VERIFY_ENABLE
    if (buf) {
        if (firstBlock) {
            err = net_update_check(&gUpdateHead, buf, len);
            if (err) {
                printf("net_update_check err!");
                return -EINVAL;
            }
            calcCrc = calc_crc16_with_init_val(calcCrc, buf + 32, len - 32);
            firstBlock = 0;
        } else {
            calcCrc = calc_crc16_with_init_val(calcCrc, buf, len);
        }
    }
#endif

    if (net_update->write_to_flash) {
        if (net_update->update_state == NET_UPDATE_STATE_OK) {
            net_update->offset = 0;
            return ret;
        } else if (net_update->update_state == NET_UPDATE_STATE_ERR || net_update->update_state == NET_UPDATE_STATE_CLOSE) {
            return -EINVAL;
        }
        while (len) {
            if (net_update->offset < net_update->recv_buf_size && !end) {//写到缓存，直到缓存满才写flash
                rd_len = MIN(net_update->recv_buf_size - net_update->offset, len);
                memcpy(net_update->recv_buf + net_update->offset, buf + rd_offset, rd_len);
                net_update->offset += rd_len;
                rd_offset += rd_len;
                len -= rd_len;
                if (*check != NET_UPDATE_BUF_CHECK) {
                    printf("err check in %s, check = 0x%x \n\n\n", __func__, *check);
                }
                if (net_update->offset < net_update->recv_buf_size) {
                    return ret;
                }
            }
            if (!end) {
                net_update->offset = 0;
                cp_remain = net_update->recv_buf_size - net_update->offset;
            } else {
                cp_remain = net_update->offset;
                len -= cp_remain;
            }
            while (cp_remain) {
                if (!net_update->recv_cnt) {//第一次写则初始化双备份升级
                    err = dual_bank_passive_update_init(0, 0, NET_UPDATE_BUFF_SIZE_MAX, NULL);
                    if (err || dual_bank_update_allow_check(0)) {
                        net_update->update_state = NET_UPDATE_STATE_ERR;
                        printf("net_fwrite init check err \n\n");
                        return err;
                    }
                    u32 target_addr = get_target_udate_addr();
                    u32 addr = ADDR_ALIGNE(target_addr, FLASH_SECTOR_SIZE);
                    u32 first_size = addr - target_addr;
                    if (first_size) {
                        //要先写前4K对齐剩下字节，否则出现数据包不完整
                        err = dual_bank_update_write(cp_buf, first_size, NULL);
                        if (err) {
                            net_update->update_state = NET_UPDATE_STATE_ERR;
                            return err;
                        }

                        memcpy(cp_buf, cp_buf + first_size, \
                               cp_remain > first_size ? (cp_remain - first_size) : cp_remain);

                        net_update->offset = (cp_remain > first_size ? (cp_remain - first_size) : cp_remain);
                        net_update->recv_cnt += first_size;
                        break;
                    }
                }
                if (net_update->update_state) {
                    printf("net_update update_state = %d \n\n", net_update->update_state);
                    net_update->offset = 0;
                    return net_update->update_state == NET_UPDATE_STATE_OK ? ret : -EINVAL;
                }
                if (*check != NET_UPDATE_BUF_CHECK) {
                    printf("err check in %s, check = 0x%x \n\n\n", __func__, *check);
                }
                //写数据到flash
                err = dual_bank_update_write(cp_buf, cp_remain, net_update_doing_callback);
                if (err) {
                    net_update->update_state = NET_UPDATE_STATE_ERR;
                    return err;
                }
                net_update->recv_cnt += cp_remain;
                cp_remain -= cp_remain;
            }
        }
    } else if (net_update->fd) {
        fwrite(buf, 1, len, net_update->fd);
    }
    return ret;
}