#include "open62541.h"

#include <signal.h>
#include <stdlib.h>

#include <wiringPi.h>
#include "sht21.h"

#define SDA_PIN 2
#define SCL_PIN 3

static UA_Boolean relay_status = false;
static UA_Float temp;
static UA_Float hum;

static int readSensor()
{
    int16_t temperature;
    uint16_t humidity;
    uint8_t err;

    /* Init the library */
    SHT21_Init(SCL_PIN, SDA_PIN);
    /* Read temperature and humidity from sensor */
    err = SHT21_Read(&temperature, &humidity);

    if (SHT21_Cleanup() != 0)
    {
        UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND, "ERROR during SHT cleanup");
        return 1;
    }

    if (err == 0)
    {
        temp = temperature / 10.0;
        hum = humidity / 10.0;
        return UA_STATUSCODE_GOOD;
    }
}

static UA_StatusCode
readTemperature(UA_Server *server,
                const UA_NodeId *sessionId, void *sessionContext,
                const UA_NodeId *nodeId, void *nodeContext,
                UA_Boolean sourceTimeStamp, const UA_NumericRange *range,
                UA_DataValue *dataValue)
{
    if (readSensor() != 0)
    {
        UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND, "ERROR during SHT reading");
        return UA_STATUSCODE_BADINTERNALERROR;
    }

    UA_Variant_setScalarCopy(&dataValue->value, &temp,
                             &UA_TYPES[UA_TYPES_FLOAT]);
    dataValue->hasValue = true;
    return UA_STATUSCODE_GOOD;
}

static UA_StatusCode
readHumidity(UA_Server *server,
             const UA_NodeId *sessionId, void *sessionContext,
             const UA_NodeId *nodeId, void *nodeContext,
             UA_Boolean sourceTimeStamp, const UA_NumericRange *range,
             UA_DataValue *dataValue)
{
    if (readSensor() != 0)
    {
        UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND, "ERROR during SHT reading");
        return UA_STATUSCODE_BADINTERNALERROR;
    }

    UA_Variant_setScalarCopy(&dataValue->value, &hum,
                             &UA_TYPES[UA_TYPES_FLOAT]);
    dataValue->hasValue = true;
    return UA_STATUSCODE_GOOD;
}

static UA_StatusCode
readRelay(UA_Server *server,
          const UA_NodeId *sessionId, void *sessionContext,
          const UA_NodeId *nodeId, void *nodeContext,
          UA_Boolean sourceTimeStamp, const UA_NumericRange *range,
          UA_DataValue *dataValue)
{

    UA_Variant_setScalarCopy(&dataValue->value, &relay_status,
                             &UA_TYPES[UA_TYPES_BOOLEAN]);
    dataValue->hasValue = true;
    return UA_STATUSCODE_GOOD;
}

static UA_StatusCode
writeRelay(UA_Server *server,
           const UA_NodeId *sessionId, void *sessionContext,
           const UA_NodeId *nodeId, void *nodeContext,
           const UA_NumericRange *range, const UA_DataValue *data)
{
    relay_status = *(UA_Boolean *)(data->value.data);
    digitalWrite(10, relay_status);

    return UA_STATUSCODE_GOOD;
}

static void
addVariables(UA_Server *server)
{
    UA_NodeId parentNodeId; // get the nodeid assigned by the server
    UA_ObjectAttributes oAttr = UA_ObjectAttributes_default;
    oAttr.displayName = UA_LOCALIZEDTEXT("en-US", "AirConditioner");
    UA_Server_addObjectNode(server, UA_NODEID_NULL,
                            UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),
                            UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES),
                            UA_QUALIFIEDNAME(1, "AirConditioner"), UA_NODEID_NUMERIC(0, UA_NS0ID_BASEOBJECTTYPE),
                            oAttr, NULL, &parentNodeId);

    // Define the attribute of the Temperature variable node
    UA_VariableAttributes tempAttr = UA_VariableAttributes_default;
    UA_Float myTemp = 0.1;
    UA_Variant_setScalar(&tempAttr.value, &myTemp, &UA_TYPES[UA_TYPES_FLOAT]);
    tempAttr.description = UA_LOCALIZEDTEXT("en-US", "Temperature");
    tempAttr.displayName = UA_LOCALIZEDTEXT("en-US", "Temperature");
    tempAttr.dataType = UA_TYPES[UA_TYPES_FLOAT].typeId;
    tempAttr.accessLevel = UA_ACCESSLEVELMASK_READ;

    // Add the variable node to the information model
    UA_DataSource tempDataSource;
    tempDataSource.read = readTemperature;
    UA_Server_addDataSourceVariableNode(server, UA_NODEID_NULL, parentNodeId,
                                        UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT),
                                        UA_QUALIFIEDNAME(1, "Temperature"),
                                        UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), tempAttr, tempDataSource, NULL, NULL);

    // Define the attribute of the Humidity variable node
    UA_VariableAttributes humAttr = UA_VariableAttributes_default;
    UA_Float myHum = 0.1;
    UA_Variant_setScalar(&humAttr.value, &myHum, &UA_TYPES[UA_TYPES_FLOAT]);
    humAttr.description = UA_LOCALIZEDTEXT("en-US", "Humidity");
    humAttr.displayName = UA_LOCALIZEDTEXT("en-US", "Humidity");
    humAttr.dataType = UA_TYPES[UA_TYPES_FLOAT].typeId;
    humAttr.accessLevel = UA_ACCESSLEVELMASK_READ;

    // Add the variable node to the information model
    UA_DataSource humDataSource;
    humDataSource.read = readHumidity;
    UA_Server_addDataSourceVariableNode(server, UA_NODEID_NULL, parentNodeId,
                                        UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT),
                                        UA_QUALIFIEDNAME(1, "Humidity"),
                                        UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), humAttr, humDataSource, NULL, NULL);

    UA_VariableAttributes statusAttr = UA_VariableAttributes_default;
    UA_Boolean status = true;
    UA_Variant_setScalar(&statusAttr.value, &status, &UA_TYPES[UA_TYPES_BOOLEAN]);
    statusAttr.description = UA_LOCALIZEDTEXT("en-US", "Status");
    statusAttr.displayName = UA_LOCALIZEDTEXT("en-US", "Status");
    statusAttr.dataType = UA_TYPES[UA_TYPES_BOOLEAN].typeId;
    statusAttr.accessLevel = UA_ACCESSLEVELMASK_READ | UA_ACCESSLEVELMASK_WRITE;

    UA_DataSource statusDataSource;
    statusDataSource.read = readRelay;
    statusDataSource.write = writeRelay;
    UA_Server_addDataSourceVariableNode(server, UA_NODEID_NULL, parentNodeId,
                                        UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT),
                                        UA_QUALIFIEDNAME(1, "Status"),
                                        UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), statusAttr, statusDataSource, NULL, NULL);
}

static volatile UA_Boolean running = true;
static void stopHandler(int sig)
{
    UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND, "received ctrl-c");
    running = false;
}

int main(void)
{
    signal(SIGINT, stopHandler);
    signal(SIGTERM, stopHandler);

    if (wiringPiSetup() == -1)
        return 1;

    pinMode(10, INPUT); // aka pin 24
    relay_status = digitalRead(10);
    pinMode(10, OUTPUT); // aka pin 24

    UA_Server *server = UA_Server_new();
    UA_ServerConfig_setDefault(UA_Server_getConfig(server));

    UA_ServerConfig *config = UA_Server_getConfig(server);
    config->verifyRequestTimestamp = UA_RULEHANDLING_ACCEPT;

    addVariables(server);

    UA_StatusCode retval = UA_Server_run(server, &running);

    UA_Server_delete(server);
    return retval == UA_STATUSCODE_GOOD ? EXIT_SUCCESS : EXIT_FAILURE;
}