/*
 * OpaSensorGroup.cpp
 *
 *  Created on: 10.09.2018
 *      Author: Micha Mueller
 */

#include "OpaSensorGroup.h"

OpaSensorGroup::OpaSensorGroup(const std::string name) :
	SensorGroupTemplate(name),
	_hfiNum(0),
	_portNum(0),
	_port(nullptr) {
	_imageId = {0};
	_imageInfo = {0};
}

OpaSensorGroup::OpaSensorGroup(const OpaSensorGroup& other) :
    SensorGroupTemplate(other),
    _hfiNum(other._hfiNum),
    _portNum(other._portNum),
    _port(nullptr) {
  _imageId = {0};
  _imageInfo = {0};
}

OpaSensorGroup::~OpaSensorGroup() {
	if(_port) {
		omgt_close_port(_port);
	}
}

OpaSensorGroup& OpaSensorGroup::operator=(const OpaSensorGroup& other) {
  SensorGroupTemplate::operator =(other);
  _hfiNum = other._hfiNum;
  _portNum = other._portNum;
  _port = nullptr;
  _imageId = {0};
  _imageInfo = {0};

  return *this;
}

void OpaSensorGroup::start() {
	if (_keepRunning) {
		//we have been started already
		LOG(info) << "Sensorgroup " << _groupName << " already running.";
		return;
	}

	if (omgt_open_port_by_num(&_port, _hfiNum, _portNum, NULL) != OMGT_STATUS_SUCCESS) {
		LOG(error) << "Sensorgroup " << _groupName << " failed to open port or initialize PA connection";
		_port = nullptr;
		return;
	}

	if (omgt_pa_get_image_info(_port, _imageId, &_imageInfo)) {
		LOG(error) << "Sensorgroup " << _groupName << " failed to get PA image";
		omgt_close_port(_port);
		_port = nullptr;
		return;
	}

	_keepRunning = 1;
	_pendingTasks++;
	_timer->async_wait(std::bind(&OpaSensorGroup::readAsync, this));
	LOG(info) << "Sensorgroup " << _groupName << " started.";
}

void OpaSensorGroup::stop() {
	_keepRunning = 0;
	
	if (_port) {
		omgt_close_port(_port);
		_port = nullptr;
	}
	 
	LOG(info) << "Sensorgroup " << _groupName << " stopped.";
}

void OpaSensorGroup::read() {
	ureading_t reading;
	reading.timestamp = getTimestamp();

	STL_PORT_COUNTERS_DATA portCounters;
	try {
		if (omgt_pa_get_port_stats(_port, _imageId, 1, _portNum, &_imageId, &portCounters, NULL, 0, 1)) {
			throw std::runtime_error("Failed to get port counters");
		}
	} catch (const std::exception& e) {
		LOG(error) << "Sensorgroup" << _groupName << " could not read value: " << e.what();
		return;
	}

	for(const auto& s : _sensors) {
		switch(s->getCounterData()) {
		case(portXmitData) :
			reading.value = portCounters.portXmitData;
			break;
		case(portRcvData) :
			reading.value = portCounters.portRcvData;
			break;
		case(portXmitPkts) :
			reading.value = portCounters.portXmitPkts;
			break;
		case(portRcvPkts) :
			reading.value = portCounters.portRcvPkts;
			break;
		case(portMulticastXmitPkts) :
			reading.value = portCounters.portMulticastXmitPkts;
			break;
		case(portMulticastRcvPkts) :
			reading.value = portCounters.portMulticastRcvPkts;
			break;
		case(localLinkIntegrityErrors) :
			reading.value = portCounters.localLinkIntegrityErrors;
			break;
		case(fmConfigErrors) :
			reading.value = portCounters.fmConfigErrors;
			break;
		case(portRcvErrors) :
			reading.value = portCounters.portRcvErrors;
			break;
		case(excessiveBufferOverruns) :
			reading.value = portCounters.excessiveBufferOverruns;
			break;
		case(portRcvConstraintErrors) :
			reading.value = portCounters.portRcvConstraintErrors;
			break;
		case(portRcvSwitchRelayErrors) :
			reading.value = portCounters.portRcvSwitchRelayErrors;
			break;
		case(portXmitDiscards) :
			reading.value = portCounters.portXmitDiscards;
			break;
		case(portXmitConstraintErrors) :
			reading.value = portCounters.portXmitConstraintErrors;
			break;
		case(portRcvRemotePhysicalErrors) :
			reading.value = portCounters.portRcvRemotePhysicalErrors;
			break;
		case(swPortCongestion) :
			reading.value = portCounters.swPortCongestion;
			break;
		case(portXmitWait) :
			reading.value = portCounters.portXmitWait;
			break;
		case(portRcvFECN) :
			reading.value = portCounters.portRcvFECN;
			break;
		case(portRcvBECN) :
			reading.value = portCounters.portRcvBECN;
			break;
		case(portXmitTimeCong) :
			reading.value = portCounters.portXmitTimeCong;
			break;
		case(portXmitWastedBW) :
			reading.value = portCounters.portXmitWastedBW;
			break;
		case(portXmitWaitData) :
			reading.value = portCounters.portXmitWaitData;
			break;
		case(portRcvBubble) :
			reading.value = portCounters.portRcvBubble;
			break;
		case(portMarkFECN) :
			reading.value = portCounters.portMarkFECN;
			break;
		case(linkErrorRecovery) :
			reading.value = portCounters.linkErrorRecovery;
			break;
		case(linkDowned) :
			reading.value = portCounters.linkDowned;
			break;
		case(uncorrectableErrors) :
			reading.value = portCounters.uncorrectableErrors;
			break;
		default:
			LOG(error) << _groupName << "::" << s->getName() << " could not read value!";
			continue;
			break;
		}
		s->storeReading(reading);
#ifdef DEBUG
		LOG(debug) << _groupName << "::" << s->getName() << " raw reading: \"" << reading.value << "\"";
#endif
	}
}

void OpaSensorGroup::readAsync() {
	read();
	if (_timer && _keepRunning) {
		_timer->expires_at(timestamp2ptime(nextReadingTime()));
		_pendingTasks++;
		_timer->async_wait(std::bind(&OpaSensorGroup::readAsync, this));
	}
	_pendingTasks--;
}

void OpaSensorGroup::printConfig(LOG_LEVEL ll) {
    LOG_VAR(ll) << "            HFI Num:  " << _hfiNum;
    LOG_VAR(ll) << "            Port Num: " << _portNum;
}