/*
 *
 *    Copyright (c) 2021 Project CHIP Authors
 *    Copyright (c) 2019 Google LLC.
 *    All rights reserved.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */

#ifdef __cplusplus
extern "C" {
#endif

#include <stdio.h>

#include <FreeRTOS.h>
#include <portable.h>
#include <portmacro.h>
#include <task.h>

#include <aos/kernel.h>
#include <aos/yloop.h>
#include <bl_dma.h>
#include <bl_irq.h>
#include <bl_rtc.h>
#include <bl_sec.h>
#include <bl_sys.h>
#include <bl_uart.h>
#include <blog.h>
#include <easyflash.h>
#include <event_device.h>
#include <hal_board.h>
#include <hal_boot2.h>
#include <hal_button.h>
#include <hal_gpio.h>
#include <hal_sys.h>
#include <hosal_pwm.h>
#include <wifi_mgmr_ext.h>

#define IOT_DVK_3S 1

#if BOARD_ID == IOT_DVK_3S
hosal_pwm_dev_t pwmR = { .port = 0xff };
#else
hosal_pwm_dev_t pwmR, pwmG, pwmB;
#endif

static void (*Button_FactoryResetEventHandler)(void)   = nullptr;
static void (*Button_LightingActionEventHandler)(void) = nullptr;
void Button_Configure_FactoryResetEventHandler(void (*callback)(void))
{
    Button_FactoryResetEventHandler = callback;
}

void Button_Configure_LightingActionEventHandler(void (*callback)(void))
{
    Button_LightingActionEventHandler = callback;
}

static void Platform_Light_Init(void)
{
#if BOARD_ID == IOT_DVK_3S
    if (pwmR.port == 0xff)
    {
        pwmR.port              = 0;
        pwmR.config.pin        = 0;
        pwmR.config.duty_cycle = 0; // duty_cycle range is 0~10000 correspond to 0~100%
        pwmR.config.freq       = 1000;
        hosal_pwm_init(&pwmR);
        vTaskDelay(50);
        hosal_pwm_start(&pwmR);
    }
#else
    pwmR.port              = 0;
    pwmR.config.pin        = 20;
    pwmR.config.duty_cycle = 0; // duty_cycle range is 0~10000 correspond to 0~100%
    pwmR.config.freq       = 1000;
    hosal_pwm_init(&pwmR);

    pwmG.port              = 1;
    pwmG.config.pin        = 21;
    pwmG.config.duty_cycle = 0; // duty_cycle range is 0~10000 correspond to 0~100%
    pwmG.config.freq       = 1000;
    hosal_pwm_init(&pwmG);

    pwmB.port              = 2;
    pwmB.config.pin        = 17;
    pwmB.config.duty_cycle = 0; // duty_cycle range is 0~10000 correspond to 0~100%
    pwmB.config.freq       = 1000;
    hosal_pwm_init(&pwmB);

    vTaskDelay(50);
    hosal_pwm_start(&pwmR);
    hosal_pwm_start(&pwmG);
    hosal_pwm_start(&pwmB);
#endif
}

void BL602_LightState_Update(uint8_t red, uint8_t green, uint8_t blue)
{
#if BOARD_ID == IOT_DVK_3S
    uint32_t level = (red * 10000) / UINT8_MAX;
    log_info("red level: %d\r\n", level);
    hosal_pwm_duty_set(&pwmR, level);
#else
    uint32_t r_level = (red * 10000) / UINT8_MAX;
    uint32_t g_level = (green * 10000) / UINT8_MAX;
    uint32_t b_level = (blue * 10000) / UINT8_MAX;
    hosal_pwm_duty_set(&pwmR, r_level);
    hosal_pwm_duty_set(&pwmG, g_level);
    hosal_pwm_duty_set(&pwmB, b_level);
#endif
}
void user_vAssertCalled(void) __attribute__((weak, alias("vAssertCalled")));
void vAssertCalled(void)
{
    volatile uint32_t ulSetTo1ToExitFunction = 0;

    taskDISABLE_INTERRUPTS();
    while (ulSetTo1ToExitFunction != 1)
    {
        __asm volatile("NOP");
    }
}

void vApplicationMallocFailedHook(void)
{
    printf("Memory Allocate Failed. Current left size is %d bytes\r\n", xPortGetFreeHeapSize());
    while (1)
    {
        /*empty here*/
    }
}

void vApplicationIdleHook(void)
{
    __asm volatile("   wfi     ");
    /*empty*/
}

#if (configUSE_TICKLESS_IDLE != 0)
void vApplicationSleep(TickType_t xExpectedIdleTime_ms)
{
#if defined(CFG_BLE_PDS)
    int32_t bleSleepDuration_32768cycles = 0;
    int32_t expectedIdleTime_32768cycles = 0;
    eSleepModeStatus eSleepStatus;
    bool freertos_max_idle = false;

    if (pds_start == 0)
        return;

    if (xExpectedIdleTime_ms + xTaskGetTickCount() == portMAX_DELAY)
    {
        freertos_max_idle = true;
    }
    else
    {
        xExpectedIdleTime_ms -= 1;
        expectedIdleTime_32768cycles = 32768 * xExpectedIdleTime_ms / 1000;
    }

    if ((!freertos_max_idle) && (expectedIdleTime_32768cycles < TIME_5MS_IN_32768CYCLE))
    {
        return;
    }

    /*Disable mtimer interrrupt*/
    *(volatile uint8_t *) configCLIC_TIMER_ENABLE_ADDRESS = 0;

    eSleepStatus = eTaskConfirmSleepModeStatus();
    if (eSleepStatus == eAbortSleep || ble_controller_sleep_is_ongoing())
    {
        /*A task has been moved out of the Blocked state since this macro was
        executed, or a context siwth is being held pending.Restart the tick
        and exit the critical section. */
        /*Enable mtimer interrrupt*/
        *(volatile uint8_t *) configCLIC_TIMER_ENABLE_ADDRESS = 1;
        // printf("%s:not do ble sleep\r\n", __func__);
        return;
    }

    bleSleepDuration_32768cycles = ble_controller_sleep();

    if (bleSleepDuration_32768cycles < TIME_5MS_IN_32768CYCLE)
    {
        /*BLE controller does not allow sleep.  Do not enter a sleep state.Restart the tick
        and exit the critical section. */
        /*Enable mtimer interrrupt*/
        // printf("%s:not do pds sleep\r\n", __func__);
        *(volatile uint8_t *) configCLIC_TIMER_ENABLE_ADDRESS = 1;
    }
    else
    {
        printf("%s:bleSleepDuration_32768cycles=%ld\r\n", __func__, bleSleepDuration_32768cycles);
        if (eSleepStatus == eStandardSleep &&
            ((!freertos_max_idle) && (expectedIdleTime_32768cycles < bleSleepDuration_32768cycles)))
        {
            hal_pds_enter_with_time_compensation(1, expectedIdleTime_32768cycles - 40); // 40);//20);
        }
        else
        {
            hal_pds_enter_with_time_compensation(1, bleSleepDuration_32768cycles - 40); // 40);//20);
        }
    }
#endif
}
#endif

void vApplicationGetIdleTaskMemory(StaticTask_t ** ppxIdleTaskTCBBuffer, StackType_t ** ppxIdleTaskStackBuffer,
                                   uint32_t * pulIdleTaskStackSize)
{
    /* If the buffers to be provided to the Idle task are declared inside this
    function then they must be declared static - otherwise they will be allocated on
    the stack and so not exists after this function exits. */
    static StaticTask_t xIdleTaskTCB;
    // static StackType_t uxIdleTaskStack[ configMINIMAL_STACK_SIZE ];
    static StackType_t uxIdleTaskStack[512];

    /* Pass out a pointer to the StaticTask_t structure in which the Idle task's
    state will be stored. */
    *ppxIdleTaskTCBBuffer = &xIdleTaskTCB;

    /* Pass out the array that will be used as the Idle task's stack. */
    *ppxIdleTaskStackBuffer = uxIdleTaskStack;

    /* Pass out the size of the array pointed to by *ppxIdleTaskStackBuffer.
    Note that, as the array is necessarily of type StackType_t,
    configMINIMAL_STACK_SIZE is specified in words, not bytes. */
    //*pulIdleTaskStackSize = configMINIMAL_STACK_SIZE;
    *pulIdleTaskStackSize = 512; // size 512 words is For ble pds mode, otherwise stack overflow of idle task will happen.
}

static void event_cb_key_event(input_event_t * event, void * private_data)
{
    switch (event->code)
    {
    case KEY_1: {
        log_info("[KEY_1] [EVT] INIT DONE %lld\r\n", aos_now_ms());
        log_info("short press \r\n");

        if (Button_LightingActionEventHandler != nullptr)
        {
            (*Button_LightingActionEventHandler)();
        }
    }
    break;
    case KEY_2: {
        log_info("[KEY_2] [EVT] INIT DONE %lld\r\n", aos_now_ms());
        log_info("long press \r\n");
    }
    break;
    case KEY_3: {
        log_info("[KEY_3] [EVT] INIT DONE %lld\r\n", aos_now_ms());
        log_info("longlong press \r\n");
        if (Button_FactoryResetEventHandler != nullptr)
        {
            (*Button_FactoryResetEventHandler)();
        }
    }
    break;
    default: {
        log_info("[KEY] [EVT] Unknown code %u, %lld\r\n", event->code, aos_now_ms());
        /*nothing*/
    }
    }
}

extern int get_dts_addr(const char * name, uint32_t * start, uint32_t * off);

void InitPlatform(void)
{
    bl_sys_init();

    hal_button_module_init(8, 1000, 4800, 5000);
    Platform_Light_Init();
    aos_register_event_filter(EV_KEY, event_cb_key_event, NULL);
}

#ifdef __cplusplus
}
#endif