#include "Nuki.h"
#include <FreeRTOS.h>

Nuki* nukiInst;

Nuki::Nuki(const std::string& name, uint32_t id, Network* network)
: _nukiBle(name, id),
  _network(network)
{
    nukiInst = this;

    memset(&_lastKeyTurnerState, sizeof(KeyTurnerState), 0);
    memset(&_keyTurnerState, sizeof(KeyTurnerState), 0);

    network->setLockActionReceived(nukiInst->onLockActionReceived);
}

void Nuki::initialize()
{
    _nukiBle.initialize();
}

void Nuki::update()
{
    if (!_paired) {
        Serial.println(F("Nuki start pairing"));

        if (_nukiBle.pairNuki()) {
            Serial.println(F("Nuki paired"));
            _paired = true;
        }
        else
        {
            vTaskDelay( 200 / portTICK_PERIOD_MS);
            return;
        }
    }

    vTaskDelay( 100 / portTICK_PERIOD_MS);
    _nukiBle.requestKeyTurnerState(&_keyTurnerState);

    char str[20];
    lockstateToString(_keyTurnerState.lockState, str);
    Serial.print(F("Nuki lock state: "));
    Serial.println(str);

    if(_keyTurnerState.lockState != _lastKeyTurnerState.lockState)
    {
        _network->publishKeyTurnerState(str);
    }

    memcpy(&_lastKeyTurnerState, &_keyTurnerState, sizeof(KeyTurnerState));

    vTaskDelay( 20000 / portTICK_PERIOD_MS);
}

void Nuki::lockstateToString(const LockState state, char* str)
{
    switch(state)
    {
        case LockState::uncalibrated:
            strcpy(str, "uncalibrated");
            break;
        case LockState::locked:
            strcpy(str, "locked");
            break;
        case LockState::locking:
            strcpy(str, "locking");
            break;
        case LockState::unlocked:
            strcpy(str, "unlocked");
            break;
        case LockState::unlatched:
            strcpy(str, "unlatched");
            break;
        case LockState::unlockedLnga:
            strcpy(str, "unlockedLnga");
            break;
        case LockState::unlatching:
            strcpy(str, "unlatching");
            break;
        case LockState::calibration:
            strcpy(str, "calibration");
            break;
        case LockState::bootRun:
            strcpy(str, "bootRun");
            break;
        case LockState::motorBlocked:
            strcpy(str, "motorBlocked");
            break;
        default:
            strcpy(str, "undefined");
            break;
    }
}

LockAction Nuki::lockActionToEnum(const char *str)
{
    if(strcmp(str, "unlock") == 0) return LockAction::unlock;
    else if(strcmp(str, "lock") == 0) return LockAction::lock;
    else if(strcmp(str, "unlatch") == 0) return LockAction::unlatch;
    else if(strcmp(str, "lockNgo") == 0) return LockAction::lockNgo;
    else if(strcmp(str, "lockNgoUnlatch") == 0) return LockAction::lockNgoUnlatch;
    else if(strcmp(str, "fullLock") == 0) return LockAction::fullLock;
    else if(strcmp(str, "fobAction2") == 0) return LockAction::fobAction2;
    else if(strcmp(str, "fobAction1") == 0) return LockAction::fobAction1;
    else if(strcmp(str, "fobAction3") == 0) return LockAction::fobAction3;
    return (LockAction)0xff;
}


void Nuki::onLockActionReceived(const char *value)
{
    LockAction action =  nukiInst->lockActionToEnum(value);
    Serial.print("Action: ");
    Serial.println((int)action);
    if(action != (LockAction)0xff)
    {
//        nukiInst->_nukiBle.lockAction(action, 0, 0);
        vTaskDelay( 5000 / portTICK_PERIOD_MS);
    }
}