/*
 * This work is licensed under a Creative Commons CCZero 1.0 Universal License.
 * See http://creativecommons.org/publicdomain/zero/1.0/ for more information.
 */

#include <signal.h>
#include <stdlib.h>
#include <time.h>
#include <sys/select.h>

#include <ua_types.h>
#include <ua_server.h>
#include <logger_stdout.h>
#include <networklayer_tcp.h>
#include <ua_config_standard.h>

#include <mosquitto.h>

#include "TestModel.h"

/*
 * Configuration
 */
#define MQTT_HOST "localhost"
#define MQTT_PORT 1883
#define MQTT_TEMPERATURE_TOPIC "temperature"


/*
 * shared data
 */
uint32_t upTime = 0;
double measuredTemperature = 0;




UA_Logger logger = Logger_Stdout;
UA_Boolean running = true;



static void stopHandler(int sign) {
  UA_LOG_INFO(logger, UA_LOGCATEGORY_SERVER, "received ctrl-c");
  running = false;
}

static UA_StatusCode
readInteger(void *handle, const UA_NodeId nodeid, UA_Boolean sourceTimeStamp,
            const UA_NumericRange *range, UA_DataValue *dataValue) {
  dataValue->hasValue = true;
  UA_Variant_setScalarCopy(&dataValue->value, handle, &UA_TYPES[UA_TYPES_INT32]);
  return UA_STATUSCODE_GOOD;
}

static UA_StatusCode
readDouble(void *handle, const UA_NodeId nodeid, UA_Boolean sourceTimeStamp,
	   const UA_NumericRange *range, UA_DataValue *dataValue) {
  dataValue->hasValue = true;
  UA_Variant_setScalarCopy(&dataValue->value, handle, &UA_TYPES[UA_TYPES_DOUBLE]);
  return UA_STATUSCODE_GOOD;
}


void connect_callback(struct mosquitto *mosq, void *obj, int result) {
}

void message_callback(struct mosquitto *mosq, void *obj,
		      const struct mosquitto_message *message) {
  UA_LOG_INFO(logger, UA_LOGCATEGORY_USERLAND, "received mqtt message with topic %s",
	      message->topic);
  if (0 == strcmp(message->topic, MQTT_TEMPERATURE_TOPIC)) {
    UA_LOG_INFO(logger, UA_LOGCATEGORY_USERLAND, "this is about the temperature");
    measuredTemperature = atof((char*)message->payload);
  }
}

uint64_t millis() {
  struct timeval te;
  gettimeofday(&te, NULL);
  uint64_t ms = te.tv_sec * 1000 + te.tv_usec / 1000;
  return ms;
}


int main(int argc, char** argv) {
  signal(SIGINT, stopHandler); /* catches ctrl-c */

  /* initialize the server */
  UA_ServerConfig config = UA_ServerConfig_standard;
  UA_ServerNetworkLayer nl = UA_ServerNetworkLayerTCP(UA_ConnectionConfig_standard, 16664);
  config.networkLayers = &nl;
  config.networkLayersSize = 1;
  UA_Server *server = UA_Server_new(config);

  /* create nodes from nodeset */
  TestModel(server);

  UA_DataSource uptimeDataSource = (UA_DataSource) {
    .handle = &upTime, .read = readInteger, .write = 0};
  UA_Server_setVariableNode_dataSource(server, UA_NODEID_NUMERIC(2, 6006),
				       uptimeDataSource);


  UA_DataSource measuredTemperatureDataSource = (UA_DataSource) {
    .handle = &measuredTemperature, .read = readDouble, .write = 0};
  UA_Server_setVariableNode_dataSource(server, UA_NODEID_NUMERIC(2, 6004),
				       measuredTemperatureDataSource);

  UA_StatusCode retval = UA_Server_run_startup(server);

  

  mosquitto_lib_init();
  
  char mqttClientId[24];
  struct mosquitto *mosq;
  mosq = mosquitto_new(mqttClientId, true, 0);
  mosquitto_connect_callback_set(mosq, connect_callback);
  mosquitto_message_callback_set(mosq, message_callback);
  mosquitto_connect(mosq, MQTT_HOST, MQTT_PORT, 60);
  mosquitto_subscribe(mosq, NULL, MQTT_TEMPERATURE_TOPIC, 0);
  

  if (retval == UA_STATUSCODE_GOOD) {
     
    while (running == true) {
      upTime = time(0);
      // measuredTemperature += 0.25;
	
      uint16_t canWait = 0;
      
      canWait = UA_Server_run_iterate(server, 0);
      // UA_LOG_INFO(logger, UA_LOGCATEGORY_USERLAND, "canWait: %i", canWait);

      uint64_t beforeMosquittoLoop = millis();
      mosquitto_loop(mosq, 0, 1);
      uint64_t durationMosquittoLoop = millis() - beforeMosquittoLoop;
      canWait = (canWait > durationMosquittoLoop) ? (canWait - durationMosquittoLoop) : 0;
      
      struct timeval timeout = { .tv_sec = 0, .tv_usec = canWait * 1000 };
      select(0, 0, 0, 0, &timeout);
    }
  }

    
  /* ctrl-c received -> clean up */
  UA_Server_delete(server);
  nl.deleteMembers(&nl);
  // return (int)retval;
}
