/*
 *
 *    Copyright (c) 2021 Project CHIP Authors
 *
 *    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.
 */

#include "AppTask.h"
#include "AppConfig.h"
#include "AppEvent.h"
#include "CHIPDeviceManager.h"
#include "DeviceCallbacks.h"
#include "LEDWidget.h"
#include <app-common/zap-generated/attribute-id.h>
#include <app-common/zap-generated/attribute-type.h>
#include <app-common/zap-generated/cluster-id.h>
#include <app/clusters/network-commissioning/network-commissioning.h>
#include <app/clusters/ota-requestor/BDXDownloader.h>
#include <app/clusters/ota-requestor/DefaultOTARequestor.h>
#include <app/clusters/ota-requestor/DefaultOTARequestorDriver.h>
#include <app/clusters/ota-requestor/DefaultOTARequestorStorage.h>
#include <app/server/OnboardingCodesUtil.h>
#include <app/server/Server.h>
#include <app/util/af-enums.h>
#include <app/util/attribute-storage.h>
#include <credentials/DeviceAttestationCredsProvider.h>
#include <credentials/examples/DeviceAttestationCredsExample.h>
#include <lib/support/CodeUtils.h>
#include <platform/CHIPDeviceLayer.h>
#include <platform/bouffalolab/BL602/NetworkCommissioningDriver.h>
#include <platform/bouffalolab/BL602/OTAImageProcessorImpl.h>
#include <platform/internal/CHIPDeviceLayerInternal.h>

#include <InitPlatform.h>
#include <async_log.h>
#include <bl_sys_ota.h>
#include <easyflash.h>
#include <hal_sys.h>
#include <lib/support/ErrorStr.h>

#if PW_RPC_ENABLED
#include "Rpc.h"
#endif

#define FACTORY_RESET_TRIGGER_TIMEOUT 3000
#define FACTORY_RESET_CANCEL_WINDOW_TIMEOUT 3000
#define APP_EVENT_QUEUE_SIZE 10
#define APP_TASK_STACK_SIZE (4096)
#define APP_TASK_PRIORITY 2
#define STATUS_LED_GPIO_NUM GPIO_NUM_2 // Use LED1 (blue LED) as status LED on DevKitC

static const char * const TAG = "lighting-app";
static xTaskHandle OTA_TASK_HANDLE;
static LEDWidget statusLED;
namespace {
TimerHandle_t sFunctionTimer; // FreeRTOS app sw timer.

BaseType_t sAppTaskHandle;
QueueHandle_t sAppEventQueue;

bool sHaveBLEConnections = false;

StackType_t appStack[APP_TASK_STACK_SIZE / sizeof(StackType_t)];
} // namespace

using namespace ::chip;
using namespace ::chip::DeviceManager;
using namespace ::chip::DeviceLayer;
using namespace ::chip::Credentials;

namespace {
chip::app::Clusters::NetworkCommissioning::Instance
    sWiFiNetworkCommissioningInstance(0 /* Endpoint Id */, &(NetworkCommissioning::BLWiFiDriver::GetInstance()));
} // namespace

using namespace ::chip::System;

DefaultOTARequestor gRequestorCore;
DefaultOTARequestorStorage gRequestorStorage;
DefaultOTARequestorDriver gRequestorUser;
BDXDownloader gDownloader;
OTAImageProcessorImpl gImageProcessor;

AppTask AppTask::sAppTask;
// static DeviceCallbacks EchoCallbacks;

CHIP_ERROR AppTask::StartAppTask()
{
    CHIP_ERROR err = CHIP_NO_ERROR;
    sAppEventQueue = xQueueCreate(APP_EVENT_QUEUE_SIZE, sizeof(AppEvent));
    if (sAppEventQueue == NULL)
    {
        log_error("Failed to allocate app event queue\r\n");
        return APP_ERROR_EVENT_QUEUE_FAILED;
    }

    // Start App task.
    sAppTaskHandle = xTaskCreate(AppTaskMain, APP_TASK_NAME, ArraySize(appStack), NULL, 1, NULL);
    if (sAppTaskHandle)
    {
        err = CHIP_NO_ERROR;
    }

    return CHIP_NO_ERROR;
}

CHIP_ERROR AppTask::Init()
{
    CHIP_ERROR err = CHIP_NO_ERROR;

    // Create FreeRTOS sw timer for Function Selection.
    sFunctionTimer = xTimerCreate("FnTmr",          // Just a text name, not used by the RTOS kernel
                                  1,                // == default timer period (mS)
                                  false,            // no timer reload (==one-shot)
                                  (void *) this,    // init timer id = app task obj context
                                  TimerEventHandler // timer callback handler
    );
    if (sFunctionTimer == NULL)
    {
        log_error("funct timer create failed\r\n");
        return APP_ERROR_CREATE_TIMER_FAILED;
    }

    err = LightMgr().Init();
    if (err != CHIP_NO_ERROR)
    {
        log_error("LightMgr().Init() failed\r\n");
        return err;
    }

    LightMgr().SetCallbacks(ActionInitiated, ActionCompleted);

    SetRequestorInstance(&gRequestorCore);
    gRequestorStorage.Init(chip::Server::GetInstance().GetPersistentStorage());
    gRequestorCore.Init(chip::Server::GetInstance(), gRequestorStorage, gRequestorUser, gDownloader);
    gImageProcessor.SetOTADownloader(&gDownloader);
    gDownloader.SetImageProcessorDelegate(&gImageProcessor);
    gRequestorUser.SetPeriodicQueryTimeout(OTA_PERIODIC_QUERY_TIMEOUT);
    gRequestorUser.Init(&gRequestorCore, &gImageProcessor);

    ConfigurationMgr().LogDeviceConfig();

    PrintOnboardingCodes(chip::RendezvousInformationFlag(chip::RendezvousInformationFlag::kBLE));

    InitButtons();

#if PW_RPC_ENABLED
    chip::rpc::Init();
#endif

    return err;
}

void AppTask::AppTaskMain(void * pvParameter)
{
    AppEvent event;
    Clock::Timestamp lastChangeTime = Clock::kZero;
    CHIP_ERROR err;

    log_info("App Task entered\r\n");
    log_async_init();
    enable_async_log();

    err = sWiFiNetworkCommissioningInstance.Init();
    if (CHIP_NO_ERROR != err)
    {
        log_error("Network commissioning failed, err:%d \r\n", err);
    }

    chip::CommonCaseDeviceServerInitParams initParams;
    err = initParams.InitializeStaticResourcesBeforeServerInit();
    if (CHIP_NO_ERROR != err)
    {
        log_error("Resources Init failed, err:%d \r\n", err);
        return;
    }

    err = chip::Server::GetInstance().Init(initParams);
    if (CHIP_NO_ERROR != err)
    {
        log_error("Server Init failed, err:%d \r\n", err);
        return;
    }

    // Initialize device attestation config
    SetDeviceAttestationCredentialsProvider(Examples::GetExampleDACProvider());

    err = sAppTask.Init();
    if (err != CHIP_NO_ERROR)
    {
        log_error("AppTask.Init() failed due to %d\r\n", err);
        return;
    }

    while (true)
    {
        BaseType_t eventReceived = xQueueReceive(sAppEventQueue, &event, pdMS_TO_TICKS(10));
        while (eventReceived == pdTRUE)
        {
            log_info("receiving event type: %d\r\n", event.Type);
            sAppTask.DispatchEvent(&event);
            eventReceived = xQueueReceive(sAppEventQueue, &event, 0);
        }
        // Collect connectivity and configuration state from the CHIP stack. Because
        // the CHIP event loop is being run in a separate task, the stack must be
        // locked while these values are queried.  However we use a non-blocking
        // lock request (TryLockCHIPStack()) to avoid blocking other UI activities
        // when the CHIP task is busy (e.g. with a long crypto operation).
        if (PlatformMgr().TryLockChipStack())
        {
            sHaveBLEConnections = (ConnectivityMgr().NumBLEConnections() != 0);
            PlatformMgr().UnlockChipStack();
        }

        // Update the status LED if factory reset has not been initiated.
        //
        // If system has "full connectivity", keep the LED On constantly.
        //
        // If no connectivity to the service OR subscriptions are not fully
        // established THEN blink the LED Off for a short period of time.
        //
        // If the system has ble connection(s) uptill the stage above, THEN blink
        // the LEDs at an even rate of 100ms.
        //
        // Otherwise, blink the LED ON for a very short time.
        if (sAppTask.mFunction != kFunction_FactoryReset)
        {
            if (sHaveBLEConnections)
            {
                // TODO: 3R
                // sStatusLED.Blink(100, 100);
            }
            else
            {
                // TODO: 3R
                // sStatusLED.Blink(50, 950);
            }
        }

        // TODO: 3R
        // sStatusLED.Animate();

        Clock::Timestamp now            = SystemClock().GetMonotonicTimestamp();
        Clock::Timestamp nextChangeTime = lastChangeTime + Clock::Seconds16(5);

        if (nextChangeTime < now)
        {
            lastChangeTime = now;
        }
    }
}

void AppTask::LightActionEventHandler(AppEvent * aEvent)
{
    bool initiated = false;
    LightingManager::Action_t action;
    int32_t actor;
    CHIP_ERROR err = CHIP_NO_ERROR;

    if (aEvent->Type == AppEvent::kEventType_Light)
    {
        action = static_cast<LightingManager::Action_t>(aEvent->LightEvent.Action);
        actor  = aEvent->LightEvent.Actor;
    }
    else if (aEvent->Type == AppEvent::kEventType_Button)
    {
        if (LightMgr().IsLightOn())
        {
            action = LightingManager::OFF_ACTION;
        }
        else
        {
            action = LightingManager::ON_ACTION;
        }
        actor = AppEvent::kEventType_Button;
    }
    else
    {
        err = APP_ERROR_UNHANDLED_EVENT;
    }

    if (err == CHIP_NO_ERROR)
    {
        initiated = LightMgr().InitiateAction(actor, action);

        if (!initiated)
        {
            log_info("Action is already in progress or active.\r\n");
        }
    }
}

void AppTask::ButtonEventHandler(uint8_t btnIdx, uint8_t btnAction)
{
#if 0 // TODO: 3R
    if (btnIdx != APP_LOCK_BUTTON && btnIdx != APP_FUNCTION_BUTTON)
    {
        return;
    }
#endif

    AppEvent button_event = {};
    button_event.Type     = AppEvent::kEventType_Button;
    // button_event.ButtonEvent.PinNo  = btnIdx;
    button_event.ButtonEvent.Action = btnAction;

    /* if (btnIdx == APP_LOCK_BUTTON && btnAction == APP_BUTTON_PRESSED)
    {
        button_event.Handler = LockActionEventHandler;
        log_info("posting button_event(lock button)\r\n");
        sAppTask.PostEvent(&button_event);
    }
    else */
    if (btnIdx == APP_FUNCTION_BUTTON)
    {
        button_event.Handler = FunctionHandler;
        log_info("posting button_event(function button)\r\n");
        sAppTask.PostEvent(&button_event);
    }
}

void AppTask::TimerEventHandler(TimerHandle_t xTimer)
{
    AppEvent event;
    event.Type               = AppEvent::kEventType_Timer;
    event.TimerEvent.Context = (void *) xTimer;
    event.Handler            = FunctionTimerEventHandler;
    sAppTask.PostEvent(&event);
}

void AppTask::FunctionTimerEventHandler(AppEvent * aEvent)
{
    if (aEvent->Type != AppEvent::kEventType_Timer)
    {
        return;
    }

    // If we reached here, the button was held past FACTORY_RESET_TRIGGER_TIMEOUT,
    // initiate factory reset
    if (sAppTask.mFunctionTimerActive && sAppTask.mFunction == kFunction_StartBleAdv)
    {
        log_info("Factory Reset Triggered. Release button within %ums to cancel.\r\n", FACTORY_RESET_CANCEL_WINDOW_TIMEOUT);

        // Start timer for FACTORY_RESET_CANCEL_WINDOW_TIMEOUT to allow user to
        // cancel, if required.
        sAppTask.StartTimer(FACTORY_RESET_CANCEL_WINDOW_TIMEOUT);

        sAppTask.mFunction = kFunction_FactoryReset;
    }
    else if (sAppTask.mFunctionTimerActive && sAppTask.mFunction == kFunction_FactoryReset)
    {
        // Actually trigger Factory Reset
        sAppTask.mFunction = kFunction_NoneSelected;
        ConfigurationMgr().InitiateFactoryReset();
    }
}

void AppTask::FunctionHandler(AppEvent * aEvent)
{

    if (aEvent->ButtonEvent.Action == APP_BUTTON_LONGPRESSED)
    {
        log_info("FactoryReset! please release boutton!!!\r\n");
        statusLED.Toggle();
        vTaskDelay(1000);
        statusLED.Toggle();
        vTaskDelay(1000);
        statusLED.Toggle();
        vTaskDelay(3000);
        chip::Server::GetInstance().ScheduleFactoryReset();
    }
    else if (aEvent->ButtonEvent.Action == APP_BUTTON_PRESSED)
    {
        AppEvent Lightevent = {};
        Lightevent.Type     = AppEvent::kEventType_Button;
        Lightevent.Handler  = LightActionEventHandler;
        sAppTask.PostEvent(&Lightevent);
    }
}

void AppTask::CancelTimer()
{
    if (xTimerStop(sFunctionTimer, 0) == pdFAIL)
    {
        log_error("app timer stop() failed\r\n");
        return;
    }

    mFunctionTimerActive = false;
}
void AppTask::StartTimer(uint32_t aTimeoutInMs)
{
    if (xTimerIsTimerActive(sFunctionTimer))
    {
        log_warn("app timer already started!\r\n");
        CancelTimer();
    }

    // timer is not active, change its period to required value (== restart).
    // FreeRTOS- Block for a maximum of 100 ticks if the change period command
    // cannot immediately be sent to the timer command queue.
    if (xTimerChangePeriod(sFunctionTimer, aTimeoutInMs / portTICK_PERIOD_MS, 100) != pdPASS)
    {
        log_error("app timer start() failed\r\n");
        return;
    }

    mFunctionTimerActive = true;
}

void AppTask::ActionInitiated(LightingManager::Action_t aAction, int32_t aActor)
{
    // Action initiated, update the light led
    if (aAction == LightingManager::ON_ACTION)
    {
        log_info("Turning light ON\r\n");
#if 0 // TODO: 3R
        sLightLED.Set(true);
#endif
    }
    else if (aAction == LightingManager::OFF_ACTION)
    {
        log_info("Turning light OFF\r\n");
#if 0 // TODO: 3R
        sLightLED.Set(false);
#endif
    }

    if (aActor == AppEvent::kEventType_Button)
    {
        sAppTask.mSyncClusterToButtonAction = true;
    }
}

void AppTask::ActionCompleted(LightingManager::Action_t aAction)
{
    // action has been completed bon the light
    if (aAction == LightingManager::ON_ACTION)
    {
        log_info("Light ON\r\n");
    }
    else if (aAction == LightingManager::OFF_ACTION)
    {
        log_info("Light OFF\r\n");
    }

    if (sAppTask.mSyncClusterToButtonAction)
    {
        UpdateClusterState();
        sAppTask.mSyncClusterToButtonAction = false;
    }
}

void AppTask::PostLightActionRequest(int32_t aActor, LightingManager::Action_t aAction)
{
    AppEvent event;
    event.Type              = AppEvent::kEventType_Light;
    event.LightEvent.Actor  = aActor;
    event.LightEvent.Action = aAction;
    event.Handler           = LightActionEventHandler;
    PostEvent(&event);
}

void AppTask::PostEvent(const AppEvent * aEvent)
{
    if (sAppEventQueue != NULL)
    {
        BaseType_t status;
        if (xPortIsInsideInterrupt())
        {
            BaseType_t higherPrioTaskWoken = pdFALSE;
            log_info("sending event type from isr: %d\r\n", aEvent->Type);
            status = xQueueSendFromISR(sAppEventQueue, aEvent, &higherPrioTaskWoken);

#ifdef portYIELD_FROM_ISR
            portYIELD_FROM_ISR(higherPrioTaskWoken);
#elif portEND_SWITCHING_ISR // portYIELD_FROM_ISR or portEND_SWITCHING_ISR
            portEND_SWITCHING_ISR(higherPrioTaskWoken);
#else                       // portYIELD_FROM_ISR or portEND_SWITCHING_ISR
#error "Must have portYIELD_FROM_ISR or portEND_SWITCHING_ISR"
#endif // portYIELD_FROM_ISR or portEND_SWITCHING_ISR
        }
        else
        {
            log_info("sending event type: %d\r\n", aEvent->Type);
            status = xQueueSend(sAppEventQueue, aEvent, 1);
        }

        if (!status)
            log_error("Failed to post event to app task event queue\r\n");
    }
    else
    {
        log_error("Event Queue is NULL should never happen\r\n");
    }
}

void AppTask::DispatchEvent(AppEvent * aEvent)
{
    if (aEvent->Handler)
    {
        aEvent->Handler(aEvent);
    }
    else
    {
        log_warn("Event received with no handler. Dropping event.\r\n");
    }
}

void AppTask::UpdateClusterState(void)
{
    uint8_t newValue = LightMgr().IsLightOn();
    log_info("updating on/off = %x\r\n", newValue);
    EmberAfStatus status =
        emberAfWriteAttribute(1, ZCL_ON_OFF_CLUSTER_ID, ZCL_ON_OFF_ATTRIBUTE_ID, (uint8_t *) &newValue, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
    if (status != EMBER_ZCL_STATUS_SUCCESS)
    {
        log_error("ERR: updating on/off %x\r\n", status);
    }
}

void AppTask::FactoryResetButtonEventHandler(void)
{
    AppEvent button_event           = {};
    button_event.Type               = AppEvent::kEventType_Button;
    button_event.ButtonEvent.Action = APP_BUTTON_LONGPRESSED;

    button_event.Handler = FunctionHandler;
    log_info("FactoryResetButtonEventHandler\r\n");
    sAppTask.PostEvent(&button_event);
}

void AppTask::LightingActionButtonEventHandler(void)
{
    AppEvent button_event           = {};
    button_event.Type               = AppEvent::kEventType_Button;
    button_event.ButtonEvent.Action = APP_BUTTON_PRESSED;

    button_event.Handler = FunctionHandler;
    log_info("LightingActionButtonEventHandler\r\n");
    sAppTask.PostEvent(&button_event);
}

void AppTask::InitButtons(void)
{
    Button_Configure_FactoryResetEventHandler(&FactoryResetButtonEventHandler);
    Button_Configure_LightingActionEventHandler(&LightingActionButtonEventHandler);
}

void AppTask::LightStateUpdateEventHandler(void)
{
    uint8_t onoff, level;
    do
    {
        if (EMBER_ZCL_STATUS_SUCCESS !=
            emberAfReadAttribute(1, ZCL_ON_OFF_CLUSTER_ID, ZCL_ON_OFF_ATTRIBUTE_ID, (uint8_t *) &onoff, sizeof(uint8_t)))
        {
            break;
        }
        if (EMBER_ZCL_STATUS_SUCCESS !=
            emberAfReadAttribute(1, ZCL_LEVEL_CONTROL_CLUSTER_ID, ZCL_CURRENT_LEVEL_ATTRIBUTE_ID, (uint8_t *) &level,
                                 sizeof(uint8_t)))
        {
            break;
        }
        if (0 == onoff)
        {
            statusLED.SetBrightness(0);
            statusLED.Set(0);
            PostLightActionRequest(AppEvent::kEventType_Light, LightingManager::OFF_ACTION);
        }
        else
        {
            statusLED.SetBrightness(level);
            PostLightActionRequest(AppEvent::kEventType_Light, LightingManager::ON_ACTION);
        }
    } while (0);
}

void AppTask::LightStateInit(void)
{
    uint8_t onoff       = 1;
    uint8_t level       = 254;
    EndpointId endpoint = 1;

    emberAfWriteAttribute(endpoint, ZCL_LEVEL_CONTROL_CLUSTER_ID, ZCL_CURRENT_LEVEL_ATTRIBUTE_ID, (uint8_t *) &level,
                          ZCL_INT8U_ATTRIBUTE_TYPE);

    emberAfWriteAttribute(endpoint, ZCL_ON_OFF_CLUSTER_ID, ZCL_ON_OFF_ATTRIBUTE_ID, (uint8_t *) &onoff, ZCL_BOOLEAN_ATTRIBUTE_TYPE);
}