DeviceUpdateFESA_Magstat_22032019.java

package de.gsi.cs.co.ap.app.magstat.utils;

import cern.japc.AcquiredParameterValue;
import cern.japc.ParameterException;
import cern.japc.ParameterValueListener;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import cern.japc.MapParameterValue;
import cern.japc.Parameter;
import cern.japc.Parameters;
import cern.japc.Selector;
import cern.japc.SubscriptionHandle;
import cern.japc.factory.ParameterFactory;
import cern.japc.group.support.SysoutFailSafeParameterValueListener;
import cern.lsa.domain.devices.Device;

// for library loggers
// import org.slf4j.Logger;
// import org.slf4j.LoggerFactory;

// for application loggers
// import de.gsi.cs.co.ap.common.gui.elements.logger.AppLogger;

/**
 * @author fschirru
 */
public class DeviceUpdateFESA implements ParameterValueListener {

	// You can choose a logger (needed imports are given in the import section
	// as comments):
	// for libraries:
	// private static final Logger LOGGER =
	// LoggerFactory.getLogger(DeviceUpdateFESA.class);
	// for applications:
	// private static final AppLogger LOGGER = AppLogger.getLogger();

	private static final DeviceUpdateFESA INSTANCE = new DeviceUpdateFESA();
	private final RetrieveDeviceSelector rdSel = RetrieveDeviceSelector.getInstance();
	private final DeviceCalibrationCurveConverter dccc = DeviceCalibrationCurveConverter.getInstance();
	private final static MagnetDataProcessorLSA mdpLSA = MagnetDataProcessorLSA.getInstance();

	private static final Logger LOGGER = LoggerFactory.getLogger(DeviceUpdateFESA.class);

	private final static String[] propertyName = { "Acquisition", "DCValue", "DCMode", "Status", "DCValueAcq" };

	private final static Set<Device> myDevices = mdpLSA.getStaticDevices();

	// private static final Selector NULL_SELECTOR = null;
	// private static final Selector MULTIPLEXED_SELECTOR =
	// SelectorFactory.newSelector(""); //
	// SelectorFactory.newSelector("FAIR.BP.3");
	private final AcquiredParameterValue parameterValue = null;

	private String devicename;

	// private double currentVal; // related to DCMode "true"
	private final double currentValAcq = 99.99; // related to DCMode "false"
	// private boolean dcMode;
	private double voltageValAcq;
	// private Double bFieldConverted;
	// private Double bFieldConverted_v;

	private List<Boolean> listOfBooleans = new ArrayList<>();
	private List<String> listOfLabels = new ArrayList<>();

	// private final AcquiredParameterValue parameterValue = null;
	private ParameterException parameterException;
	private SubscriptionHandle subscriptionHandle;

	private static List<SubscriptionHandle> subscriptionHandlers = new ArrayList<>();
	private static boolean existing_subscription = false;

	private final MagnetDataJoiner mdpj = MagnetDataJoiner.getInstance();

	/**
	*
	*/
	public DeviceUpdateFESA() {

	}

	public static DeviceUpdateFESA getInstance() {

		return INSTANCE;
	}

	public AcquiredParameterValue getParameterValue(final Selector selector, final String propertyname) {
		try {
			final String parametername = Parameters.buildParameterName(devicename, propertyname);
			final Parameter parameter = ParameterFactory.newInstance().newParameter(parametername);

			// final AcquiredParameterValue parameterValue =
			// parameter.getValue(NULL_SELECTOR); // commented on
			// 25/5/2018
			final AcquiredParameterValue parameterValue = parameter.getValue(selector); // placed
																						// on
																						// 25/5/2018

			final MapParameterValue mapParameterValue = (MapParameterValue) parameterValue.getValue();
			final int powerState = mapParameterValue.getInt("powerState");
			LOGGER.info("Parameter value for " + devicename + ", " + propertyname + ", " + " received : " + powerState);
		} catch (final ParameterException e) {
			LOGGER.error(e.getMessage());
		}
		return parameterValue;
	}

	public void subscribe(final Selector selector, final String propertyname) {
		final String parametername = Parameters.buildParameterName(devicename, propertyname);
		try {
			final Parameter parameter = ParameterFactory.newInstance().newParameter(parametername);

			// SubscriptionHandle conn =
			// parameter.createSubscription(MULTIPLEXED_SELECTOR, this);

			// Check if the subscription for a certain parameter is already
			// created
			// If so, use that one in the case of re-starting monitoring of the
			// same parameter

			existing_subscription = false;

			// System.out.println("*****************************************" +
			// subscriptionHandlers.size());

			for (int s = 0; s < subscriptionHandlers.size(); s++) {

				if (subscriptionHandlers.get(s).getParameter().equals(parameter)) {

					if (subscriptionHandlers.get(s).getSelector().equals(selector)) {

						// System.out.println(subscriptionHandlers.get(s).getParameter());
						// System.out.println(parameter);
						// System.out.println(subscriptionHandlers.get(s).getSelector());
						// System.out.println(selector);

						subscriptionHandlers.get(s).startMonitoring();
						existing_subscription = true;

						s = subscriptionHandlers.size(); // loop interruption
					}
				}
			}
			// System.out.println("*****************************************" +
			// subscriptionHandlers.size());
			if (!existing_subscription) {

				subscriptionHandle = parameter.createSubscription(selector, this);
				subscriptionHandlers.add(subscriptionHandle);
				// System.out.println(subscriptionHandlers.size());

				subscriptionHandle.startMonitoring();

				LOGGER.info("Subscription for '" + propertyname + "' started");

			}

		} catch (final ParameterException e) {

			LOGGER.error(e.getMessage());
		}
	}

	@Override
	public void valueReceived(final String parameterName, final AcquiredParameterValue value) {

		final String propertyname = parameterName.substring(parameterName.indexOf("/") + 1);
		final AcquiredParameterValue parameterValue_ = value;
		final MapParameterValue mapParameterValue = (MapParameterValue) parameterValue_.getValue();
		final String device_name = parameterName.substring(0, parameterName.indexOf("/"));

		/*
		 * if (propertyname.equals("Acquisition") && parameterName.substring(0,
		 * parameterName.indexOf("/")).equals("GTS2QT12")) {
		 *
		 * System.out.println(); System.out.println(propertyname);
		 * System.out.println(parameterName.substring(0,
		 * parameterName.indexOf("/"))); // System.out.println(parameterValue_);
		 * System.out.println(mapParameterValue);
		 * System.out.println("Extracted current:" +
		 * mapParameterValue.getString("current"));
		 *
		 * }
		 */

		/*
		 * for (int i = 0; i < mapParameterValue.getNames().length; i++) {
		 *
		 * // LOGGER.info(i + ". Fieldname of " + propertyname + ": " +
		 * mapParameterValue.getNames()[i]); }
		 */

		if (propertyname.equals("Acquisition")) {

			final double acquisitionCurrentValue = Double.parseDouble(mapParameterValue.getString("current"));
			final double bFieldConverted = dccc.getValueFromCalibrationCurve("LOGICAL." + device_name,
					acquisitionCurrentValue, "current");

			// Attempt to retrieve voltage value for all the devices
			double acquisitionVoltageValue;
			double currentConverted_v = 0.0;
			double bFieldConverted_v = 0.0;

			try {

				// Hall Probe value treatment

				// 1) get the value in voltage from the Hall probe
				// 2) convert this value into a current value
				// 3) convert the current value into magnetic field value

				acquisitionVoltageValue = Double.parseDouble(mapParameterValue.getString("voltage"));
				// acquisitionVoltageValue = 0.0; change this value to test the
				// voltage conversion

				currentConverted_v = dccc.getValueFromCalibrationCurve("LOGICAL." + device_name,
						acquisitionVoltageValue, "voltage");

				bFieldConverted_v = dccc.getValueFromCalibrationCurve("LOGICAL." + device_name, currentConverted_v,
						"current");

				// bFieldConverted_v = acquisitionVoltageValue;

				// bFieldConverted_v =
				// dccc.getValueFromCalibrationCurve("LOGICAL." + device_name,
				// acquisitionCurrentValue,
				// "voltage"); // it looks like that the calibration function
				// Bfield -> Voltage is missing.

			} catch (final Exception e) {

				acquisitionVoltageValue = 0.0;
				bFieldConverted_v = acquisitionVoltageValue;
			}

			for (int k = 0; k < mdpj.getData().size(); k++) {

				if (device_name.equals(mdpj.getData().get(k).getId())) {

					mdpj.getData().get(k).setCurrent_meas(acquisitionCurrentValue);
					// Update current difference for the device
					mdpj.getData().get(k).setCurrent_diff(
							-mdpj.getData().get(k).getCurrent_exp() + mdpj.getData().get(k).getCurrent_meas());
					mdpj.getData().get(k).setBfield_meas(bFieldConverted);
					// mdpj.getData().get(k).setBfield_meas(100.10);
					mdpj.getData().get(k).setHallprobe(bFieldConverted_v);

					k = mdpj.getData().size(); // exit for-loop
				}
			}
		}

		if (propertyname.equals("DCValueAcq")) {

			final double acquisitionCurrentValueDC = Double.parseDouble(mapParameterValue.getString("current"));

			/*
			 * // HallProbe will not be updated while DC mode is on because we
			 * have only one column // We can anyway see the changing in the
			 * magnet current (which is updated, see below)
			 *
			 * // final String device_name = parameterName.substring(0,
			 * parameterName.indexOf("/"));
			 *
			 * final String str = mapParameterValue.getString("current");
			 * currentValAcq = Double.parseDouble(str);
			 *
			 * // Treat the update of the HallProbes related only to dipoles if
			 * (device_name.equals("GTS3MU1") || device_name.equals("GTS3MU2")
			 * || device_name.equals("GTS4MU1") || device_name.equals("GHFSMU1")
			 * || device_name.equals("GTS5MU1") || device_name.equals("GTS6MU1")
			 * || device_name.equals("GTS7MU1")) {
			 *
			 * final String str_v = mapParameterValue.getString("voltage");
			 * voltageValAcq = Double.parseDouble(str_v);
			 *
			 * bFieldConverted_v = voltageValAcq;
			 *
			 * // System.out.println("HALLPROBE: " + bFieldConverted_v);
			 *
			 * } else {
			 *
			 * bFieldConverted_v = 0.0; }
			 */

			for (int k = 0; k < mdpj.getData().size(); k++) {

				if (device_name.equals(mdpj.getData().get(k).getId())) {

					mdpj.getData().get(k).setCurrent_meas_DC(acquisitionCurrentValueDC);
					// mdpj.getData().get(k).setHallprobe(voltageValAcq);
					// Add setting for DCVoltage
					k = mdpj.getData().size(); // exit for-loop
				}
			}
		}

		if (propertyname.equals("DCMode")) {

			// final String device_name = parameterName.substring(0,
			// parameterName.indexOf("/"));
			final String str = mapParameterValue.getString("mode");

			for (int k = 0; k < mdpj.getData().size(); k++) {

				if (device_name.equals(mdpj.getData().get(k).getId())) {

					mdpj.getData().get(k).setDcmode(Boolean.valueOf(str));

					k = mdpj.getData().size(); // exit for-loop
				}
			}
		}

		if (propertyname.equals("Status")) {

			// final String device_name = parameterName.substring(0,
			// parameterName.indexOf("/"));
			final String str = mapParameterValue.getString("status");

			final boolean[] arrayOfBooleans = mapParameterValue.getBooleans("detailedStatus");
			listOfBooleans = toListBooleanArray(arrayOfBooleans);

			final String[] arrayOfLabels = mapParameterValue.getStrings("detailedStatus_labels");
			listOfLabels = toListStringArray(arrayOfLabels);

			for (int k = 0; k < mdpj.getData().size(); k++) {

				if (device_name.equals(mdpj.getData().get(k).getId())) {

					mdpj.getData().get(k).setStatus(Integer.valueOf(str));
					mdpj.getData().get(k).setListOfBooleans(listOfBooleans);
					mdpj.getData().get(k).setListOfLabels(listOfLabels);

					k = mdpj.getData().size(); // exit for-loop
				}
			}
		}
		// stopSubscription();
	}

	@Override
	public void exceptionOccured(final String parameterName, final String description,
			final ParameterException exception) {

		String message;

		if (exception == null) {
			parameterException = new ParameterException(description);
			message = parameterException.getMessage();

		} else {

			message = exception.getMessage();
		}

		LOGGER.error(message);
		stopSubscription();
	}

	private void stopSubscription() {

		subscriptionHandle.stopMonitoring();

		LOGGER.info("subscription stopped");
	}

	/*
	 * close the logical channel of subscription
	 *
	 * @param conn logical channel of subscription
	 */
	public static void stopSubscriptions(final SubscriptionHandle subscriptionHandle) {
		if (subscriptionHandle != null) {

			// System.out.println("STOPPED!!!!!!!");
			subscriptionHandle.stopMonitoring();
		}
	}

	public List<SubscriptionHandle> get_subscriptionHandle() {

		return subscriptionHandlers;
	}

	private List<Boolean> toListBooleanArray(final boolean[] booleanArray) {

		final int arraySize = booleanArray.length;

		for (int i = 0; i < arraySize; i++) {

			listOfBooleans.add(booleanArray[i]);
		}

		return listOfBooleans;
	}

	private List<String> toListStringArray(final String[] stringArray) {

		final int arraySize = stringArray.length;

		for (int i = 0; i < arraySize; i++) {

			listOfLabels.add(stringArray[i]);
		}

		return listOfLabels;
	}

	private void setDeviceName(final String deviceName) {

		devicename = deviceName;
	}

	public void generateDeviceSubscriptions() {

		for (final Device device : myDevices) {

			// System.out.println("***SUBSTRIPTION GENERATION***");
			// System.out.println(device.getName().substring(8));
			setDeviceName(device.getName().substring(8));

			final Selector newMULTIPLEXED_SELECTOR = rdSel.getSelector(device);

			for (int p = 0; p < propertyName.length; p++) {

				try {

					subscribe(newMULTIPLEXED_SELECTOR, propertyName[p]);

				} catch (final Exception e) {

					System.out.println("Exception: " + e);
					System.exit(0);
				}
			} // for property
		}
	}

	public void closeAllSubscriptions() {

		int sum = 0;
		int size = 0;

		if (get_subscriptionHandle().size() != 0) {

			size = get_subscriptionHandle().size();

			for (int i = 0; i < get_subscriptionHandle().size(); i++) {

				if (get_subscriptionHandle().get(i).isMonitoring()) {
					sum++;
				}

				System.out.println(i);
				// System.out.println(duf.get_subscriptionHandle().get(i).toString());
				System.out.println(get_subscriptionHandle().get(i).getSelector());
				System.out.println(get_subscriptionHandle().get(i).getParameter());
				stopSubscriptions(get_subscriptionHandle().get(i));
				System.out.println();
			}
		}

		System.out.println("SUM: " + sum);
		System.out.println("SIZE: " + size);
		// DeviceUpdateFESA.stopSubscriptions(duf.get_subscriptionHandle().get(5));
		// System.out.println(duf.get_subscriptionHandle().size());
	}
}