//
// Created by xemon on 15.09.22.
//
#include "main.h"
#include "at32f435_437_clock.h"
#include "at32f435_437.h"
#include <SystemDelayInterface.h>
//#include <SerialPort.h>
//#include <ComInt.h>
#include <FirmwareLoader.h>
#include "CmsisRtosThreadUtils.h"
#include "at32_emac.h"
#include "netconf.h"
#include "fs_interface.h"
#include "time.h"
#include "Rtcs.h"
#include "string.h"
#include "SerialPorts.h"
#include "AtCmdCommonProtected.h"
#include "Adcs.h"
#include "Gpios.h"


void extend_sram(void);

void extend_sram(void) {
    // check if ram has been set to expectant size, if not, change eopb0
    if (((USD->eopb0) & 0x07) != FLASH_EOPB0_SRAM_512K) {
        flash_unlock();
        // erase user system data bytes
        flash_user_system_data_erase();

        // change sram size
        flash_eopb0_config(FLASH_EOPB0_SRAM_512K);

        flash_lock();

        // system reset
        nvic_system_reset();
    }
}

#define FIRMWARE_AREA_LENGTH (1024 * 1024)
#define FIRMWARE_UPDATE_ADDR (0x08260000)
#define FIRMWARE_MAIN_ADDR (0x08100000)

tAtCmd At0;
uint8_t At0Rx[255];
uint8_t At0Tx[255];

AtCommandResult
AtModem_Get_Version(tAtCmd *env, char *versionModem, uint8_t *sizeModem, char *versionCrypto, uint8_t *sizeCrypto) {
    AtCmdPrepare(env);
    AtCmdTxClear(env);
    AtCmdTxAddStatic(env, "AT+VERSION");
    AtCmdTxSendLn(env);

    *sizeModem = 0;
    *sizeCrypto = 0;

    uint32_t timeout = env->stdRxTimeout;
    uint32_t endMs = SystemGetMs() + timeout;
    uint32_t leftMs = timeout;

    while (AtCmdReceiveNextLine(env, leftMs) == AT_OK) {
        leftMs = endMs - SystemGetMs();

        if (AtCmdRxBeginWithStatic(env, "OK")) {
            AtCmdRxClear(env);

            return AT_OK;

        } else if (AtCmdRxBeginWithStatic(env, "ERROR")) {
            AtCmdRxClear(env);
            return AT_ERROR;

        } else if (AtCmdRxBeginWithStatic(env, "#VERSION: MODEM_")) {

            char *start = env->rxBuffer.data + sizeof("#VERSION:");
            *sizeModem = env->rxBuffer.len - sizeof("#VERSION: ");
            memcpy(versionModem, start, *sizeModem);

            AtCmdRxClear(env);

        } else if (AtCmdRxBeginWithStatic(env, "#VERSION: CRYPTO_")) {

            char *start = env->rxBuffer.data + sizeof("#VERSION:");
            *sizeCrypto = env->rxBuffer.len - sizeof("#VERSION: ");
            memcpy(versionCrypto, start, *sizeCrypto);

            AtCmdRxClear(env);

        } else {
            AtCmdProcessUnresolvedLine(env);
            AtCmdRxClear(env);
            continue;
        }
    }

    return AT_ERROR;
}


void delay_sec(uint16_t sec);

void httpd_init();

void delay_init();

static struct {
    uint32_t bootloader[2048];
} threadsBuffers;

static struct {
    tThreadData bootloader;
} threads;

THREAD_ATTR_CREATE(osPriorityNormal, bootloader);

//tComInt COMINT;
tFirmwareLoader FIRMWARE_LOADER;
tFs fs;
tFirmwareInfo firmwareInfo;

uint32_t get_fattime(void) {
    struct tm stm;
    RTCS.rtcI0.getTM(&RTCS, &stm);

    return (DWORD)(stm.tm_year - 80) << 25 |
           (DWORD)(stm.tm_mon + 1) << 21 |
           (DWORD)stm.tm_mday << 16 |
           (DWORD)stm.tm_hour << 11 |
           (DWORD)stm.tm_min << 5 |
           (DWORD)stm.tm_sec >> 1;
}


void EMAC_IRQHandler(void) {
    while (emac_received_packet_size_get() != 0) {
        lwip_pkt_handle();
    }

    emac_dma_flag_clear(EMAC_DMA_RI_FLAG);
    emac_dma_flag_clear(EMAC_DMA_NIS_FLAG);
}

FRESULT FS_Init(tFs *env);
void sys_check_timeouts(void);


__NO_RETURN void BootloaderThread() {

    SerialPortClearRxBuffer(&SERIAL_PORTS.GONEC1IO);

    AtCmdInit(
            &At0, &SERIAL_PORTS.GONEC1IO,
            At0Rx, sizeof(At0Rx),
            At0Tx, sizeof(At0Tx),
            2000, 2000
    );



    Adcs_Init();

    adc_ordinary_software_trigger_enable(ADCS.vcc.ADCx, TRUE);
    while (adc_flag_get(ADCS.vcc.ADCx, ADC_OCCE_FLAG) == RESET) {
    }
    uint16_t data = adc_ordinary_conversion_data_get(ADCS.vcc.ADCx);
    adc_flag_clear(ADCS.vcc.ADCx, ADC_OCCO_FLAG);


    error_status status = emac_system_init_eth();
//    while (status == ERROR);
    tcpip_stack_init(data);
    httpd_init();

    //InitSerialPorts();

    //GpioPinEnable(&GPIO_PINS.rs485Power);

    //tSerialPortIO *serial = &SERIAL_PORTS.ComIntHalfDuplexIo;

//    uint8_t byte;

//    if (checkFirmware()) {

//    }

//    ComIntInit(&COMINT, serial, &FIRMWARE_LOADER);

//    ComIntRun(&COMINT);

//
    while (1) {

        lwip_periodic_handle(SystemGetMs());
        sys_check_timeouts();

        while (emac_received_packet_size_get() != 0) {
            lwip_pkt_handle();
        }

        SystemDelayMs(1);

//        SerialPortReceive(serial, &byte, 1, SystemWaitForever);
//        SerialPortTransmit(serial, &byte, 1, SystemWaitForever);

//        GpioPinEnable(&PINS.green);
//        SystemDelayMs(500);
//
//        GpioPinDisable(&PINS.green);
//        lwip_periodic_handle(SystemGetMs());

//        if (emac_received_packet_size_get() != 0)
//            lwip_pkt_handle();

//        lwip_periodic_handle(SystemGetMs());

//        SystemDelayMs(1);

    }
}

__NO_RETURN int main() {
    system_clock_config();

    delay_init();

    memset(&firmwareInfo, 0, sizeof(tFirmwareInfo));

    FirmwareLoader_Init(&FIRMWARE_LOADER, FIRMWARE_AREA_LENGTH, FIRMWARE_MAIN_ADDR, FIRMWARE_UPDATE_ADDR);

//    FirmwareLoader_RunFirmware(&FIRMWARE_LOADER);

    Gpios_Init();
    Rtcs_Init();

    FRESULT res;

    res = FS_Init(&fs);

    if (res == FR_OK) {

        res = f_mkdir(dir_temp);
        res = f_mkdir(dir_web);

        char dirUpdateFileName[64];
        dirUpdateFileName[0] = '\0';
        strcat(dirUpdateFileName, dir_web);
        strcat(dirUpdateFileName, "load");

        // Информация о файле обновления
        FILINFO fno;
        FRESULT fr;
        fr = f_stat(dirUpdateFileName, &fno);
        // Если файл не найден (прошивки нет)
        if (fr) {
            firmwareInfo.isErrorFirmwareWEB = 1;
        } else {
            if (FirmwareLoader_CheckAndUpdate(&FIRMWARE_LOADER)) {
                FirmwareLoader_RunFirmware(&FIRMWARE_LOADER);
            } else {
                firmwareInfo.isErrorFirmwareDEV = 1;
            }
        }

    } else {

        if (FirmwareLoader_CheckAndUpdate(&FIRMWARE_LOADER) == false) {
            firmwareInfo.isErrorFirmwareDEV = 1;
        }

        firmwareInfo.isErrorCardSD = 1;
        firmwareInfo.isErrorFirmwareWEB = 1;
    }

    crm_periph_clock_enable(CRM_GPIOA_PERIPH_CLOCK, TRUE);
    crm_periph_clock_enable(CRM_GPIOB_PERIPH_CLOCK, TRUE);
    crm_periph_clock_enable(CRM_GPIOC_PERIPH_CLOCK, TRUE);
    crm_periph_clock_enable(CRM_GPIOD_PERIPH_CLOCK, TRUE);
    crm_periph_clock_enable(CRM_GPIOE_PERIPH_CLOCK, TRUE);
    crm_periph_clock_enable(CRM_GPIOF_PERIPH_CLOCK, TRUE);
    crm_periph_clock_enable(CRM_GPIOH_PERIPH_CLOCK, TRUE);
    crm_periph_clock_enable(CRM_GPIOG_PERIPH_CLOCK, TRUE);

    nvic_priority_group_config(NVIC_PRIORITY_GROUP_4);

    SerialPorts_Init();

    osKernelInitialize();

    THREAD_ADD(bootloader, NULL, BootloaderThread);

    osKernelStart();

    while (1) {

    }
}