#include <stdlib.h>
#include "app_ota.h"
#include "httpclient.h"
#include "makeimage.h"
#include "crc32.h"

#include "hlog.h"
#define TAG "TAG_APPOTA"

struct RangeUpgardeParam
{
    int32_t offset;
    int32_t totallen; //ota file length
    int32_t progress;
    int32_t retry;
};

enum upgradeStage
{
    STAGE_HEADER = 0,
    STAGE_AW831,
    STAGE_SOUND,
    STAGE_MT7682,
    STAGE_DONE,
};

enum upgradeRet
{
    RET_FW_NOT_ENOUGH_DATA = -3,
    RET_FW_MAGIC_ERROR = -2,
    RET_FW_CRC_ERROR = -1,
    RET_FW_OK,
    RET_FW_NEED_MORE_DATA,
    RET_FW_NO_NEED_UPGRADE,
};

typedef struct {
    char *url;
    onDownloadImageProgress listener;
}Upgrade_config;

//format: version,length,crc
//setenv mt7682_ota_info 1,552996,1652930298
#define DEV_OTA_PARTITION "/dev/OTA"
#define DOWNLOAD_TRY_TIMES 5

static enum upgradeStage sUpgradeStage = STAGE_HEADER;
static iobuffer sDataBuffer = {NULL, 0, 0};
static struct FWPackHeader sFWHeader;
static int32_t sUpgrading;
//EKEN format

typedef enum {
    PAYLOAD_TYPE_SET_WOW = 1,  
	PAYLOAD_TYPE_KEEPALIVE,	
    PAYLOAD_TYPE_GET_WIFI_DATA,	 
    PAYLOAD_TYPE_CHANGE_WIFI_CONNECT,//4
    PAYLOAD_TYPE_SET_PIR,
    PAYLOAD_TYPE_REBOOT_T31,
    PAYLOAD_TYPE_GET_SOME_DATA,
    PAYLOAD_TYPE_OTA_START,//8
    PAYLOAD_TYPE_OTA_ERASE,
    PAYLOAD_TYPE_OTA_ERASE_RET,
    PAYLOAD_TYPE_OTA_WRITE,
    PAYLOAD_TYPE_OTA_CRC_RET,//12
    PAYLOAD_TYPE_OTA_STOP,
    PAYLOAD_TYPE_SET_DATETIME_TS,
    PAYLOAD_TYPE_SET_AP_SCAN,
    PAYLOAD_TYPE_GET_AP_SCAN_LIST,//16
    PAYLOAD_TYPE_SET_AP_MODE,
    PAYLOAD_TYPE_SET_REBOOT_SYS,
    PAYLOAD_TYPE_SET_LED_STATE,
	PAYLOAD_TYPE_DHCP_OK,//20
    PAYLOAD_TYPE_RING_KEY,
    PAYLOAD_TYPE_LOG_DATA,
    PAYLOAD_TYPE_SET_REG_DATA,
    PAYLOAD_TYPE_GET_REG_DATA,
    PAYLOAD_TYPE_TEST = 999,
}_SPI_PAYLOAD_TYPE; 

typedef struct {
	uint32_t payload_type;
	uint32_t payload_len;
} _SPI_DATA_HEADER;


int32_t startOTAFromiobuffer(onDownloadImageProgress listener);

static int32_t writeDatato7682(int32_t type, uint8_t *payload, uint32_t payloadsize)
{
    _SPI_DATA_HEADER header = {type, payloadsize};
    char *send_buf = (char *)hv_malloc(sizeof(header) + payloadsize);

    memcpy(send_buf, (unsigned char *)&header, sizeof(header));
    if (payload)
    {
        memcpy(send_buf + sizeof(header), payload, payloadsize);
    }
    int32_t length = sizeof(header) + payloadsize;
    /*if (t31_device_transfer_mt7682(send_buf, length, NULL, 0) != 0)
    {
        hv_free(send_buf);
        hlogd("%s: t31_device_transfer_mt7682 failed", __FUNCTION__);
        return -1;
    }*/

    hv_free(send_buf);
    return 0;
}

//VIA format
static int32_t writeRAWSDIODatato7672(const char* data, int32_t len)
{
    #if 0
    SdioPacket* packet = PacketCreate();
    putCmd(packet, UPGRADE_REQ);
    putData(packet, data, len);
    int32_t ret = sdio_writePacket(packet);
    hv_free(packet);
    return ret;
    #endif
    return 0;
}

void requestMT7682RebootandUpgrade()
{
    hlogd("request MT7682 reboot to upgrade");
    for (int32_t i = 0; i < 10; i++)
    {
        int32_t magic = 0x20207682;
        if (writeDatato7682(PAYLOAD_TYPE_OTA_START, (uint8_t*)&magic, sizeof(magic)) != 0)
        {
            sleep(1);
        }
        else
        {
            break;
        }
    }

    hlogd("FIXME: should not be here, 7682 should already reboot us");
}

void dump(struct chipFWInfo *chipInfo)
{
    hlogd("dump chipinfo: magic 0x%x chipid %d version %d offset %d length %d crc 0x%x",
          chipInfo->magic, chipInfo->chipID, chipInfo->version, chipInfo->offset,
          chipInfo->length, chipInfo->crc);
}

enum upgradeRet verifyFirmware(int32_t id)
{
    struct chipFWInfo *chipInfo = &sFWHeader.FWInfo[id];
    int32_t fwLen = chipInfo->length;

    if (chipInfo->magic == 0 && fwLen == 0)
    {
        hlogd("id %d no need upgrade", id);
        return RET_FW_NO_NEED_UPGRADE;
    }

    if (sDataBuffer.size < fwLen)
    {
        return RET_FW_NOT_ENOUGH_DATA;
        // return RET_FW_NEED_MORE_DATA;
    }

    if (chipInfo->magic != IMG_MAGIC || chipInfo->chipID != id)
    {
        dump(chipInfo);
        hlogd("verifyChipInfo: check id %d failed", id);
        return RET_FW_MAGIC_ERROR;
    }

    uint32_t crc = crc32(0, (const void *)sDataBuffer.iodata, fwLen);
    if (crc != chipInfo->crc)
    {
        int32_t *data = (int32_t *)sDataBuffer.iodata;
        hlogd("id %d fw crc error: 0x%x VS 0x%x, fwLen %d, fw data 0x%x 0x%x 0x%x 0x%x",
              id, crc, chipInfo->crc, fwLen, *(data), *(data + 1), *(data + 2), *(data + 3));
        return RET_FW_CRC_ERROR;
    }
    hlogd("verifyChipInfo: id:%d check crc:0x%x", id, crc);
    return RET_FW_OK;
}

static int32_t parseHeader()
{
    if (sDataBuffer.size < sizeof(struct FWPackHeader))
    {
        return -1;
    }
    iobuffer_read(&sDataBuffer, &sFWHeader, sizeof(struct FWPackHeader));

    sUpgradeStage++;
    hlogd("parse OTA package header OK");
    for (int32_t i = 0; i < CHIP_MAX; i++)
    {
        struct chipFWInfo *info = &sFWHeader.FWInfo[i];
        if (info->magic == IMG_MAGIC)
        {
            hlogd("FW id: %d version %d length %d offset %d crc 0x%x",
                  i, info->version, info->length, info->offset, info->crc);
        }
    }

    return 0;
}

static int32_t upgradeModule(int32_t id, onDownloadImageProgress listener)
{
    enum upgradeRet ret = verifyFirmware(id);
    if (ret < 0)
        return -2;
    if (ret == RET_FW_NO_NEED_UPGRADE)
        goto end;

    int32_t length = sFWHeader.FWInfo[id].length;
    if (id == MAIN)
    {
        hlogd("AW831 Firmware verify OK, start upgrade");
        #if 0
        if (aw_upgrade_slice("rtos", sDataBuffer.iodata, 0, length, 1))
        {
            hloge("upgradeAW831 aw_upgrade_slice failed");
            return -1;
        }

        if (aw_upgrade_end(0))
        {
            hloge("upgradeAW831 aw_upgrade_end failed");
            return -1;
        }
        #endif
        hlogd("upgradeModule V831 OK");
    }
    else if (id == SOUND)
    {
        hlogd("SOUND Firmware verify OK, start upgrade");
        #if 0
        if (aw_upgrade_slice("/dev/SOUND", sDataBuffer.iodata, 0, length, 1))
        {
            hloge("aw_upgrade_slice SOUND failed");
            return -1;
        }
        #endif
        hlogd("SOUND Firmware upgrade done");
    }
    else if (id == WIFI)
    {
        hlogd("MT7682 Firmware verify OK, start upgrade");
        //hexdump -n 1024 /dev/OTA
        #if 0
        if (aw_upgrade_slice(DEV_OTA_PARTITION, sDataBuffer.iodata, 0, length, 1))
        {
            hloge("store7682Image aw_upgrade_slice failed");
            return -1;
        }
        #endif

        hlogd("upgradeModule store MT7682 firmware OK");
    }

    iobuffer_erase(&sDataBuffer, 0, length);
end:
    sUpgradeStage++;
    return 0;
}

static int32_t rangeUpgrade(Upgrade_config *downcfg, struct RangeUpgardeParam *upgradeParam, onDownloadImageProgress listener){

    httpclient_data_t client_data = {0};
    httpclient_t client = {0};
    static int32_t left_data = 0;
    int32_t ret = UPGRADING;

    sUpgradeStage = STAGE_HEADER;

    int32_t header_size = 1024;
    int32_t body_size = 32001; //one byte more for httpclient

    char *response_header = (char *)hv_malloc(header_size);
    char *response_body = (char *)hv_malloc(body_size);

    hlogd("%s: url %s", __FUNCTION__, downcfg->url);

    HTTPCLIENT_RESULT result = httpclient_connect(&client, downcfg->url);
    if (result != HTTPCLIENT_OK)
    {
        hlogd("httpclient_connect %s failed result %d", downcfg->url, result);
        listener(UPGRADING, 0);
        ret = UPGRADING;
        goto exit;
    }
    else
    {
        hlogd("httpclient_connect %s OK fd %d", downcfg->url, client.socket);
    }

    memset(&client_data, 0, sizeof(client_data));
    client_data.header_buf = response_header;
    client_data.header_buf_len = header_size;
    client_data.response_buf = response_body;
    client_data.response_buf_len = body_size;
    client_data.range_enable = 1;
    client_data.range_begin = sDataBuffer.size;
    client_data.range_end = 0;

    listener(UPGRADING, 0);

    result = httpclient_send_request(&client, downcfg->url, HTTPCLIENT_GET, &client_data);
    if (result != HTTPCLIENT_OK)
    {
        hlogd("httpclient_send_request %s failed result %d", downcfg->url, result);
        listener(UPGRADING, 0);
        ret = UPGRADING;
        goto exit;
    }

    while (result >= HTTPCLIENT_OK)
    {
        result = httpclient_recv_response(&client, &client_data);
        if (result < 0)
        {
            hlogd("httpclient_recv_response %s failed result %d", downcfg->url, result);
			listener(UPGRADING, 0);
            ret = UPGRADING;
            goto exit;
        }
      
        if(upgradeParam->offset == 0)
            upgradeParam->retry = 0;

        if (upgradeParam->totallen == 0)
        {
            left_data = upgradeParam->totallen = client_data.response_content_len;
            hlogd("url %s size %d", downcfg->url, upgradeParam->totallen);
        }

        uint32_t data_len = left_data - client_data.retrieve_len;
        upgradeParam->offset += data_len;
        left_data -= data_len;

        hlogd("upgradeParam totallen %d offset %d leftLen %d",
              upgradeParam->totallen, upgradeParam->offset, client_data.retrieve_len);

        int32_t curProgress = upgradeParam->offset * 100 / upgradeParam->totallen;
        if(curProgress > upgradeParam->progress && curProgress != 100) 
        {
            upgradeParam->progress = curProgress;
            listener(UPGRADING, curProgress);
            ret = UPGRADING;
        }
        
        if (data_len != 0)
        {
            iobuffer_appendData(&sDataBuffer, client_data.response_buf, data_len);
        }

        if (upgradeParam->offset == upgradeParam->totallen)
        {
            hlogd("firmware download done");
            listener(UPGRADING, 100);
            listener(DOWNLOAD_OK, 0);
            ret = DOWNLOAD_OK;
            break;
        }
    }

exit:
    hlogd("httpclient_close fd %d", client.socket);
    httpclient_close(&client);
    
    if (response_header)
        hv_free(response_header);
    if (response_body)
        hv_free(response_body);
/* for compile
    if(ret == UPGRADING) 
        rt_thread_mdelay(2000);*/

    return ret;
}

static void upgradeTask(void *arg)
{
	sUpgrading = 1;
    Upgrade_config *downcfg =(Upgrade_config *)arg;
    onDownloadImageProgress listener = downcfg->listener;
    //RT_ASSERT(listener);
    struct RangeUpgardeParam upgradeParam;
    memset(&upgradeParam, 0, sizeof(upgradeParam));
    int32_t upgradeStatus = UPGRADING;
	//add_suspend(SUSPEND_UPGRADE, 8*60);

    iobuffer_init(&sDataBuffer);
    iobuffer_reserve(&sDataBuffer, 4*1024*1024);
    listener(READY, 0);

    while(strlen(downcfg->url) > 0){
        hlogd("retried %d times rangeUpgrade", upgradeParam.retry);
        upgradeStatus = rangeUpgrade(downcfg, &upgradeParam, listener);
		if(upgradeStatus == DOWNLOAD_OK){
			hlogd("rangeUpgrade download ok");
			break;
		}else if(++upgradeParam.retry > DOWNLOAD_TRY_TIMES){
            hlogd("retried %d times and still download fail !!!", upgradeParam.retry);
            upgradeStatus = DOWNLOAD_FAIL;
            listener(DOWNLOAD_FAIL, 0);
            break;
        }
    }

    if(upgradeStatus == DOWNLOAD_OK)
        startOTAFromiobuffer(listener);
 
exit:
	sUpgrading = 0;
    if (STAGE_DONE != sUpgradeStage)
    {
        hlogd("upgradeTask error, current stage %d", sUpgradeStage);
        #if 0
		goWow(__func__);
        #endif
    }
    else
    {
        hlogd("upgradeTask OK");
    }

    hv_free(downcfg->url);
    hv_free(downcfg);
    return;
}

iobuffer* getOTAiobuffer()
{
    return &sDataBuffer;
}

int32_t startOTAFromiobuffer(onDownloadImageProgress listener)
{
	int32_t ret;
	int32_t upgraded7682 = 0;
    if(sDataBuffer.size == 0) {
        hlogd("sDataBuffer size is 0");
        return -1;
    }
	listener(INSTALL_ING, 0);
	ret = parseHeader();
	if(ret < 0)
		goto end;
    listener(UPGRADING, 10);
	ret = upgradeModule(MAIN, listener);
	if(ret < 0)
		goto end;
    listener(UPGRADING, 50);
	ret = upgradeModule(SOUND, listener);
	if(ret < 0)
		goto end;
    listener(UPGRADING, 80);
	ret = upgradeModule(WIFI, listener);
	if(ret < 0)
		goto end;
	else if(ret == RET_FW_OK){
		upgraded7682 = 1;
	}
    listener(UPGRADING, 100);
end:
	switch(ret){
		case RET_FW_NOT_ENOUGH_DATA:
		case RET_FW_MAGIC_ERROR:
			listener(INSTALL_FAIL, 0);
			break;
		case RET_FW_CRC_ERROR:
			listener(CRC_FAIL, 0);
			break;
		default:// RET_FW_OK or RET_FW_NO_NEED_UPGRADE
			listener(UPGRADE_KERNEL, 0);
	        listener(INSTALL_OK, 0);
			listener(UPGRADE_ALL, 0);
			break;
	}
	/*env_mutex_lock();
	if(upgraded7682){
		char info[32] = {0};
		snprint32_tf(info, sizeof(info), "%d,%d,%d", sFWHeader.FWInfo[WIFI].version, sFWHeader.FWInfo[WIFI].length, sFWHeader.FWInfo[WIFI].crc);
		env_set_string(env_ota_info, info);
	}
	if(!is_adb_online()){//do not report version when update throught adb
		env_set_int32_t(env_need_report_version, 1);
	}
	env_save();
	env_mutex_unlock();*/
	if(upgraded7682){
        requestMT7682RebootandUpgrade();
	}
    return 0;
}

void createUpgradeTask(char *otaURL, onDownloadImageProgress listener)
{
	if(sUpgrading){
		hlogd("%s sUpgrading return",__func__);
		return;
	}
    hlogd("createUpgradeTask : %s", otaURL);
    Upgrade_config *p = (Upgrade_config*)hv_malloc(sizeof(Upgrade_config));
    //RT_ASSERT(p);
    p->url = strdup(otaURL);
    p->listener = listener;
/*
    rt_thread_t task_t = rt_thread_create("upgradeTask", upgradeTask, p, 10*1024, CONFIG_FINSH_THREAD_PRIORITY, 20);
    if(task_t == RT_NULL){
         listener(READY_FAIL, 0);
    }else{
        rt_thread_startup(task_t);
    }*/
}

typedef struct
{
    uint32_t m_magic;
    /* version of app */
    uint32_t m_ver;
    /* app len*/
    uint32_t m_body_len;
    uint32_t m_checkcrc;
    uint32_t m_bin_start_addr;
    uint32_t reserve[3];

} bl_sota_update_info_t; //32bytes

int32_t isUpgrading(void){
    return sUpgrading;
}
int32_t upgradeMT7682(void)
{
    hlogd("%s start", __FUNCTION__);
	sUpgrading = 1;
    char *info = NULL;//env_get_string(env_ota_info, NULL);
    if (info == NULL)
    {
        hlogd("%s: can't find env  env_ota_info", __FUNCTION__);
        return -1;
    }

    int32_t ret = -1;
    int32_t max_block_size = 1024;
    int32_t block_size = max_block_size;
    int32_t fwVersion = -1, fwSize = 0, fwCrc = 0;
    if (3 != sscanf(info, "%d,%d,%d", &fwVersion, &fwSize, &fwCrc))
    {
        hlogd("%s: firmware info error: %s", __FUNCTION__, info);
        return -1;
    }

    int32_t otaFD = open(DEV_OTA_PARTITION, O_RDONLY);
    if (otaFD < 0)
    {
        hlogd("%s: open %s failed", __FUNCTION__, DEV_OTA_PARTITION);
        return -1;
    }

    char *buf = hv_malloc(block_size);
    if (!buf)
    {
        hlogd("%s: hv_malloc upgrade buffer %d error", __FUNCTION__, block_size);
        goto __ota_exit;
    }

    {
        //先发送一包数据表示固件的相关信息
        bl_sota_update_info_t sota_header;
        sota_header.m_magic = 0x08317682;
        sota_header.m_ver = fwVersion;
        sota_header.m_body_len = fwSize;
        sota_header.m_checkcrc = fwCrc;
        hlogd("%s: start upgrade version %d length %d crc 0x%x",
              __FUNCTION__, sota_header.m_ver, sota_header.m_body_len, sota_header.m_checkcrc);

        if (writeRAWSDIODatato7672((const char *)&sota_header, sizeof(sota_header)))
        {
            hlogd("%s: write sota_header failed", __FUNCTION__);
            return -1;
        }
        hlogd("%s: write sota_header ok", __FUNCTION__);
    }

    int32_t leftSize = fwSize;
    do
    {
        block_size = leftSize > max_block_size ? max_block_size : leftSize;
        int32_t avail = read(otaFD, buf, block_size);
        if (avail == -1)
        {
            hlogd("read source failed");
            goto __ota_exit;
        }

        leftSize -= avail;
        if (writeRAWSDIODatato7672((const char *)buf, avail) != 0)
        {
            hlogd("%s: write sota data failed", __FUNCTION__);
            goto __ota_exit;
        }
        hlogd("%s: write data %d ok", __FUNCTION__, avail);

    } while (leftSize);

    ret = 0;
__ota_exit:
    if (buf)
    {
        hv_free(buf);
    }
    if (otaFD)
    {
        close(otaFD);
    }

    if (ret == 0)
    {
        hlogd("%s: done", __FUNCTION__);
    }
    else
    {
        hlogd("%s: failed", __FUNCTION__);
    }
    return ret;
}