package com.thingworx.edgemodule;

import com.microsoft.azure.sdk.iot.device.*;
import com.microsoft.azure.sdk.iot.device.DeviceTwin.*;
import com.google.gson.Gson;

import java.io.*;
import java.net.URISyntaxException;
import java.util.Random;
import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;

public class TwxEdgeDemo {

// Define method response codes
private static final int METHOD_SUCCESS = 200;
private static final int METHOD_NOT_DEFINED = 404;
private static final int INVALID_PARAMETER = 400;

// Using the MQTT protocol to connect to IoT Hub
private IotHubClientProtocol protocol = IotHubClientProtocol.MQTT;
private ModuleClient client;
private ExecutorService threadPool = Executors.newFixedThreadPool(1);

private static int telemetryInterval = 5000;
private boolean running = true;

public void start() {
try {
client = ModuleClient.createFromEnvironment(protocol);
client.open();

// Register to receive direct method calls.
client.subscribeToMethod(new DeviceMethodCallback() {
@Override
public DeviceMethodData call(String methodName, Object methodData, Object context) {
return handleDirectMethod(methodName, methodData, context);
}
}, null, new IotHubEventCallback() {
@Override
public void execute(IotHubStatusCode responseStatus, Object callbackContext) {
System.out
.println("Direct method # IoT Hub responded to device method acknowledgement with status: "
+ responseStatus.name());
}
}, null);

client.setMessageCallback(new MessageCallback() {

@Override
public IotHubMessageResult execute(Message message, Object callbackContext) {

System.out.println("Received message with content: "
+ new String(message.getBytes(), Message.DEFAULT_IOTHUB_MESSAGE_CHARSET));
for (MessageProperty messageProperty : message.getProperties()) {
System.out.println(messageProperty.getName() + " : " + messageProperty.getValue());
}
return IotHubMessageResult.COMPLETE;
}
}, null);

// Create new thread and start sending messages
threadPool.execute(new MessageSender());

while(running) {
Thread.sleep(2000);
}
} catch (Exception e) {
e.printStackTrace();
}
}

public static void main(String[] args) throws IOException, URISyntaxException {
TwxEdgeDemo demo = new TwxEdgeDemo();
demo.start();

}

private DeviceMethodData handleDirectMethod(String methodName, Object methodData, Object context) {
DeviceMethodData deviceMethodData;
String payload = new String((byte[]) methodData);
switch (methodName) {
case "SetTelemetryInterval": {
int interval;
try {
int status = METHOD_SUCCESS;
interval = Integer.parseInt(payload);
System.out.println("Direct method - Setting telemetry interval (seconds): " + interval);
telemetryInterval = interval * 1000;
deviceMethodData = new DeviceMethodData(status, "Executed direct method " + methodName);
} catch (NumberFormatException e) {
int status = INVALID_PARAMETER;
deviceMethodData = new DeviceMethodData(status, "Invalid parameter " + payload);
}
break;
}
case "SetModuleProperty": {
System.out.println("Direct method - Set Module Property called with: " + payload);
deviceMethodData = new DeviceMethodData(METHOD_SUCCESS, "Executed direct method " + methodName);
break;
}
default: {
int status = METHOD_NOT_DEFINED;
deviceMethodData = new DeviceMethodData(status, "Not defined direct method " + methodName);
}
}
return deviceMethodData;
}

// Specify the telemetry to send to your IoT hub.
private class TelemetryDataPoint {
private double temperature;
private double humidity;

public TelemetryDataPoint(double temperature, double humidity) {
this.temperature = temperature;
this.humidity = humidity;
}

// Serialize object to JSON format.
public String toJson() {
Gson gson = new Gson();
return gson.toJson(this);
}
}

private class MessageSender implements Runnable {
public void run() {
try {
// Initialize the simulated telemetry.
double minTemperature = 20;
double minHumidity = 60;
Random rand = new Random();

while (true) {
// Simulate telemetry.
double currentTemperature = minTemperature + rand.nextDouble() * 15;
double currentHumidity = minHumidity + rand.nextDouble() * 20;
TelemetryDataPoint telemetryDataPoint = new TelemetryDataPoint(currentTemperature, currentHumidity);

// Add the telemetry to the message body as JSON.
Message msg = new Message(telemetryDataPoint.toJson());

// Add a custom application property to the message.
// An IoT hub can filter on these properties without access to the message body.
msg.setProperty("temperatureAlert", (currentTemperature > 30) ? "true" : "false");

System.out.println("Sending message: " + telemetryDataPoint.toJson());

Object lockobj = new Object();
// Send the message.
client.sendEventAsync(msg, new IotHubEventCallback() {
@Override
public void execute(IotHubStatusCode responseStatus, Object context) {
System.out.println("IoT Hub responded to message with status: " + responseStatus.name());

if (context != null) {
synchronized (context) {
context.notify();
}
}
}
}, lockobj);

synchronized (lockobj) {
lockobj.wait();
}
Thread.sleep(telemetryInterval);
}
} catch (InterruptedException e) {
System.out.println("Finished.");
}
}
}
}