// This is a sample application demonstarting the use of the proposed NOTIFY_CONNECTION_LOST synthetic notification
// 
// This sample requires C++23
//
// This application will connect to a TwinCAT PLC and output the PLC state. If the connection drops, the application
// will attempt to reconnect once a until successful.
// 
// To simplify the code, error handling has been largely omitted.
//
// Without the NOTIFY_CONNECTION_LOST the application would never detect the connection loss, because it does not
// send any commands, and thus never gets any errors. With the NOTIFY_CONNECTION_LOST notification, the connection
// loss is detected, and the connection reestablished.
//
// To test:
//
// - Start the application and connect to a TwinCAT PLC instance. The application will start logging the device state.
// - Start and stop the PLC to verify that the device state is logged
// - Put TwinCAT into config mode. This will cause TwinCAT to drop the connection.
// - Put TwinCAT back into run mode. The application will reestablish the connection and resume logging the device state.
// - Start and stop the PLC to verify that the device state is logged again
//
// Without the NOTIFY_CONNECTION_LOST notification, the connection will never be reestablished, and logging of the PLC state
// will never resume even after TwinCAT has been put back into run mode.
#include <AdsLib.h>
#include <chrono>
#include <cstddef>
#include <cstdlib>
#include <iostream>
#include <semaphore>
#include <span>
#include <thread>
using namespace std::literals;
// A semaphore used to communicate with the main thread
std::binary_semaphore connectionLostSemaphore { 0 };
// Callback for connection loss notifications
void connectionLostCallback(const AmsAddr *amsAddress, std::uint32_t type, std::uint32_t userValue)
{
	// Log the connection loss
	std::cout << "Connection loss detected." << std::endl;
	// Notify the main thread
	connectionLostSemaphore.release();
}
// Callback for device state notifications
void deviceStateCallback(const AmsAddr *amsAddress, const AdsNotificationHeader *header, std::uint32_t userValue)
{
	// Sanity check
	if (header->cbSampleSize != sizeof(std::uint16_t))
	{
		std::cout << "Received invalid device state with size " << header->cbSampleSize << std::endl;
		return;
	}
	
	// Get the value
	std::uint16_t state;
	std::memcpy(&state, header + 1, sizeof(state));
	if constexpr (std::endian::native != std::endian::little)
	{
		state = std::byteswap(state);
	}
	
	// Log the state
	std::cout << "Device state: " << state << std::endl;
}
auto main(int argc, char *argv[]) -> int
{
	// Decode the parameters
	if (argc < 4)
	{
		std::cerr << "Usage: <AMS Net-ID> <AMS Port> <IP address>" << std::endl;
		return EXIT_FAILURE;
	}
	AmsAddr amsAddress { .netId { argv[1] }, .port { std::uint16_t(std::atoi(argv[2])) } };
	const char *ipAddress { argv[3] };
	// Keep reconnecting forever
	for (;;)
	{
		//////////////////////////////////////////////////
		// Establish the connection
		
		// Try to connect
		std::cout << "Initiating connection..." << std::endl;
		auto connectionError = AdsAddRoute(amsAddress.netId, ipAddress);
		// Check for error
		if (connectionError != ADSERR_NOERR)
		{
			std::cout << "Connection failed: 0x" << std::hex << connectionError << std::dec << std::endl;
			// Sleep for 1s and retry
			std::this_thread::sleep_for(1s);
			continue;
		}
		// Open a port
		auto port = AdsPortOpenEx();
		//////////////////////////////////////////////////
		// Add handlers and service the connection
		
		// Add a handler for the connection loss notification
		std::uint32_t connectionLossNotification;
		AdsAddSyntheticDeviceNotificationReqEx(
			port, &amsAddress, NOTIFY_CONNECTION_LOST, connectionLostCallback, 0, &connectionLossNotification);
		// Add a handler for the PLC state
		const AdsNotificationAttrib deviceStateNotificationAttrib { .cbLength = sizeof(std::uint16_t), .nTransMode = ADSTRANS_SERVERONCHA };
		std::uint32_t deviceStateNotification;
		auto addNotificationError = AdsSyncAddDeviceNotificationReqEx(port,
			&amsAddress,
			ADSIGRP_DEVICE_DATA,
			ADSIOFFS_DEVDATA_ADSSTATE,
			&deviceStateNotificationAttrib,
			deviceStateCallback,
			0,
			&deviceStateNotification);
		// The connection might have failed before the call to AdsAddSyntheticDeviceNotificationReqEx, so check for an error here as well
		if (addNotificationError == ADSERR_NOERR)
		{
			std::cout << "Connected." << std::endl;
			// Wait for the connection to terminate
			connectionLostSemaphore.acquire();
		}
		else
		{
			std::cout << "AdsSyncAddDeviceNotificationReqEx failed: 0x" << std::hex << addNotificationError << std::dec << std::endl;
		}
		//////////////////////////////////////////////////
		// Shut down the connection and clean up
		std::cout << "Shutting down connection." << std::endl;
		// Clean everything up before trying to re-add the route
		AdsSyncDelDeviceNotificationReqEx(port, &amsAddress, deviceStateNotification);
		AdsDelSyntheticDeviceNotificationReqEx(port, &amsAddress, connectionLossNotification);
		AdsPortCloseEx(port);
		AdsDelRoute(amsAddress.netId);
		// Clean up any dangling connection loss notifications
		void(connectionLostSemaphore.try_acquire());
			
		// Sleep for 1s before reconnecting
		std::this_thread::sleep_for(1s);
	}
}

// This is a sample application demonstarting the use of the proposed NOTIFY_NOTIFICATION_RCV synthetic notification
// 
// This sample requires C++23
//
// This application will connect to a TwinCAT PLC and register notifications for symbols specified on the command
// line. It will then group change notifications into transactions, where each transaction contains all the changes
// from a single DEVICE_NOTIFICATION AoE frame.
// 
// To simplify the code, error handling has been largely omitted.
//
// Without the NOTIFY_NOTIFICATION_RCV, it would not be possible to group the change notifications together. This
// could introduce a critical bottleneck in situations where a lot of PLC variables change at the same time.
//
// To test:
//
// - Start the application and connect to a TwinCAT PLC instance.
// - Perform an action in the PLC that will change multiple of the watched symbols within the same cycle
// - Verify that the changes are grouped into a single transaction.
#include <AdsLib.h>
#include <compare>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <span>
#include <string>
#include <utility>
#include <vector>
// The symbol names, in the order they were specified on the command line
std::vector<std::string> symbolNames;
// Information about a symbol change
struct ChangeInfo
{
	std::size_t symbolIndex;
	std::vector<std::byte> data;
};
// The list of changes since the last transaction
std::vector<ChangeInfo> changeLog;
// Callback for change notifications
void symbolChangeCallback(const AmsAddr *amsAddress, const AdsNotificationHeader *header, std::uint32_t index)
{
	// Sanity check
	if (std::cmp_greater_equal(index, symbolNames.size()))
	{
		std::cout << "Received invalid notification with index " << index << std::endl;
		return;
	}
	
	// Extract the data
	std::span data { reinterpret_cast<const std::byte *>(header + 1), std::size_t(header->cbSampleSize) };
	// Add an entry to the log
	changeLog.push_back({ .symbolIndex { std::size_t(index) }, .data { std::from_range, data } });
}
// Callback for notification received notifications
void notificationReceivedCallback(const AmsAddr *amsAddress, std::uint32_t type, std::uint32_t userValue)
{
	// This callback just outputs the list of changes to std::cout. A real-life application could do
	// any of the following action, e.g.:
	// 
	// - Write the changes to a database using a single database transaction
	// - Send the changes to a REST interface using a single HTTP POST request
	// - Send the changes to a UI thread using a single event
	// - etc. etc. etc.
	//
	// Each of these actions benefit heavily from batching together multiple changes. When dealing with a
	// large number of symbols, having to process each change individually could introduce a critical
	// performance bottleneck.
	std::cout << "BEGIN NOTIFICATION FRAME\n[";
	for (bool isFirst = true; auto &&[symbolIndex, data] : changeLog)
	{
		if (!std::exchange(isFirst, false))
		{
			std::cout << ",";
		}
		std::cout << "\n {\n \"symbol\": \"" << symbolNames[symbolIndex] << "\",\n \"data\": ";
		char prefix { '"' };
		for (auto &&byte : data)
		{
			std::cout << std::exchange(prefix, ':') << std::hex << std::setfill('0') << std::setw(2) << static_cast<unsigned int>(byte) << std::dec << std::setfill(' ');
		}
		std::cout << "\"\n }";
	}
	std::cout <<"\n]\nEND NOTIFICATION FRAME" << std::endl;
	changeLog.clear();
}
auto main(int argc, char *argv[]) -> int
{
	// Decode the parameters
	if (argc < 5)
	{
		std::cerr << "Usage: <AMS Net-ID> <AMS Port> <IP address> <symbol name>..." << std::endl;
		return EXIT_FAILURE;
	}
	AmsAddr amsAddress { .netId { argv[1] }, .port { std::uint16_t(std::atoi(argv[2])) } };
	const char *ipAddress { argv[3] };
	for (int index = 4; index < argc; ++index)
	{
		symbolNames.emplace_back(argv[index]);
	}
	std::cout << "Press Enter to exit.\nLog:" << std::endl;
	// Establish the connection
	AdsAddRoute(amsAddress.netId, ipAddress);
	// Open a port and add the notification received callback
	auto port = AdsPortOpenEx();
	// Add a handler for the notification received notification
	std::uint32_t notificationReceivedNotification;
	AdsAddSyntheticDeviceNotificationReqEx(
		port, &amsAddress, NOTIFY_NOTIFICATION_RCV, notificationReceivedCallback, 0, &notificationReceivedNotification);
	// Remember all the notifications and handles, so we can release them
	struct SymbolInfo
	{
		std::uint32_t handle;
		std::uint32_t notification;
	};
	std::vector<SymbolInfo> symbolInfos;
	
	// Add notifications for all the symbols
	for (std::size_t index = 0; index < symbolNames.size(); ++index)
	{
		SymbolInfo symbolInfo;
		// Get a handle
		auto &&symbolName { symbolNames[index] };
		std::uint32_t bytesRead;
		auto lookupError = AdsSyncReadWriteReqEx2(port,
			&amsAddress,
			ADSIGRP_SYM_HNDBYNAME,
			0,
			sizeof(symbolInfo.handle),
			&symbolInfo.handle,
			std::uint32_t(symbolName.size()),
			symbolName.data(),
			&bytesRead);
		if (lookupError != ADSERR_NOERR)
		{
			std::cerr << "Error looking up symbol \"" << symbolName << "\": 0x" << std::hex << lookupError << std::dec << std::endl;
			continue;
		}
		// Add a notification for it
		const AdsNotificationAttrib attrib { .cbLength = sizeof(std::uint16_t), .nTransMode = ADSTRANS_SERVERONCHA };
		AdsSyncAddDeviceNotificationReqEx(port,
			&amsAddress,
			ADSIGRP_SYM_VALBYHND,
			symbolInfo.handle,
			&attrib,
			symbolChangeCallback,
			std::uint32_t(index),
			&symbolInfo.notification);
		symbolInfos.push_back(symbolInfo);
	}
	// Wait for a key press
	std::cin.ignore();
	// Clean everything up before exiting
	for (auto &&[handle, notification] : symbolInfos)
	{
		AdsSyncDelDeviceNotificationReqEx(port, &amsAddress, notification);
		AdsSyncWriteReqEx(port,
			&amsAddress,
			ADSIGRP_SYM_RELEASEHND,
			0,
			sizeof(handle),
			&handle);
	}
	AdsDelSyntheticDeviceNotificationReqEx(port, &amsAddress, notificationReceivedNotification);
	AdsPortCloseEx(port);
	AdsDelRoute(amsAddress.netId);
	return EXIT_SUCCESS;
}