MagnetDataProcessorFESA_magstat_04042019.java

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

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

import cern.accsoft.commons.domain.particletransfers.ParticleTransfer;
import cern.colt.Arrays;
import cern.japc.AcquiredParameterValue;
import cern.japc.MapParameterValue;
import cern.japc.Parameter;
import cern.japc.ParameterException;
import cern.japc.Parameters;
import cern.japc.Selector;
import cern.japc.SubscriptionHandle;
import cern.japc.factory.ParameterFactory;
import cern.lsa.client.DeviceService;
import cern.lsa.client.Services;
import cern.lsa.domain.devices.Device;
import cern.lsa.domain.devices.DeviceMetaTypeEnum;
import cern.lsa.domain.devices.factory.DevicesRequestBuilder;
import cern.lsa.domain.settings.BeamProductionChain;
import cern.lsa.domain.settings.Contexts;

public class MagnetDataProcessorFESA {

	/**
	 * @author fschirru
	 */
	private static final MagnetDataProcessorFESA INSTANCE = new MagnetDataProcessorFESA();

	private final MagnetDataProcessorLSA mdpLSA = MagnetDataProcessorLSA.getInstance();
	private final RetrieveDeviceSelector rdSel = RetrieveDeviceSelector.getInstance();

	private static final String[] MAGNET_TYPES = new String[] { "BasicPS", "BasicHvPS" };

	// private Set<Device> frsDevices;

	private final static String[] propertynameSelector = { "Acquisition", "DCValue", "DCMode", "Status", "DCValueAcq" };
	private final static String[] propertyname = { "Acquisition", "Acquisition", "DCValue", "DCMode", "Status",
			"Status", "Status", "DCValueAcq", "DCValueAcq" };
	private final static String[] propertyfield = { "current", "voltage", "current", "mode", "status", "detailedStatus",
			"detailedStatus_labels", "current", "voltage" };

	// private static final Selector MULTIPLEXED_SELECTOR =
	// SelectorFactory.newSelector("FAIR.SELECTOR.ALL");
	// private static String devicename = "GTH4QD21";
	private static String parameterName;
	private static Parameter parameter;
	private static AcquiredParameterValue ParameterValue;
	private static MapParameterValue mapParameterValue;
	private static Object[] fieldValue = new Object[propertyname.length]; // to
																			// be
																			// changed
																			// into
																			// generic
																			// object

	// private static String[] fieldValue_labels = new String[24];

	// private final static ObservableList<Magnet> magnetData =
	// FXCollections.observableArrayList();

	private final List<Device> mySortedDevices = new ArrayList<>();
	private final List<Object[]> magDataList = new ArrayList<>(); // to be
																	// changed
																	// into
																	// generic
																	// object

	private BeamProductionChain chain;
	private final DeviceService deviceService = Services.getDeviceService();

	private final DevicesRequestBuilder builder = new DevicesRequestBuilder();

	private Set<Device> myDevices;
	private Set<ParticleTransfer> particleTransfers;

	private List<SubscriptionHandle> list_of_subscriptions = new ArrayList<>();

	private boolean subscription_exists;

	// private final DeviceUpdateFESA duFESA = DeviceUpdateFESA.getInstance();

	public MagnetDataProcessorFESA() {

	}

	public static MagnetDataProcessorFESA getInstance() {

		return INSTANCE;
	}

	public void setBeamChain(final BeamProductionChain chain) {

		this.chain = chain;
	}

	public void setFrsDevices() {

		myDevices = mdpLSA.getStaticDevices();
		getDevicesData();
	}

	public void setDevices() {
		// If we use this method from the main controller
		// it has to be used later without .substring(8)
		// in the for loop (parameterName) because
		// devices from FESA are not LOGICAL type!!!!
		// Otherwise app can not run
		// I need to think for a generic solution both for
		// setDevices and setFrsDevices

		final Set<String> magnet_Types = new HashSet<>();
		Collections.addAll(magnet_Types, MAGNET_TYPES);

		particleTransfers = Contexts.getParticleTransfersFromBeamProcesses(chain.getDrivableBeamProcesses());
		builder.setParticleTransfers(particleTransfers);
		builder.setMetaType(DeviceMetaTypeEnum.ACTUAL);
		// builder.setDeviceTypeName("BasicPS");
		builder.setDeviceTypeNames(magnet_Types);

		myDevices = deviceService.findDevices(builder.build());
		getDevicesData();
	}

	public void getDevicesData() {

		// Clear list to avoid summing up of items while changing the chain
		magDataList.clear();

		System.out.println("Chain selected: " + chain.getName());
		rdSel.setBeamChain(chain);

		for (final Device device : myDevices) {

			final Selector newMULTIPLEXED_SELECTOR = rdSel.getSelector(device);

			/*- set temporary values to avoid app from crashing due to lack of  data */
			fieldValue[0] = "-0.0";
			fieldValue[1] = "-0.0";
			// fieldValue[2] = "
			fieldValue[3] = "false";
			fieldValue[4] = "-0.0";
			// fieldValue[5] =
			// fieldValue[6] =
			fieldValue[7] = "-0.0";
			fieldValue[8] = "-0.0";

			/*- temporary to propertyname.length-2 to deal with the DCValueAcq separately */
			for (int p = 0; p < propertyname.length - 2; p++) {

				System.out.println("P VALUE " + p);

				// if (p != 1) {

				try {

					parameterName = Parameters.buildParameterName(device.getName().substring(8), propertyname[p]);
					// System.out.println("**** " + parameterName);
					parameter = ParameterFactory.newInstance().newParameter(parameterName);
					System.out.println(parameter);
					System.out.println(newMULTIPLEXED_SELECTOR);

					// To get data from real hardware and not test devices, on
					// the
					// Run Configurations we need to specify
					// "cmwpro00a.acc.gsi.de:5021"
					// By chance may work with "cmwdev00a.acc.gsi.de:5021" but
					// pro should be used.
					// Applications which are deployed look directly into
					// "cmwpro00a.acc.gsi.de:5021"
					// Since this application is not yet deployed we need to
					// give the link manually
					// in the "Run Configurations"
					// Otherwise, an error (null value) leads to SetOnFAIL in
					// the app.

					// The next line gives setOnFail and to solve it
					// the pom file must be resaved.
					// Otherwise it should cleaned the maven repository
					// with rm -rf .m2/repository
					// eclipse will load all again automatically
					// Also better Maven->Update Project

					/*- If the selector is wrong, this line throws an exception */
					ParameterValue = parameter.getValue(newMULTIPLEXED_SELECTOR);

					mapParameterValue = (MapParameterValue) ParameterValue.getValue();

					// acquire the value of the considered property of the
					// related device.
					// The first five properties are numbers and retrieved as
					// strings
					if (p < 5) {

						if (p != 1) {

							fieldValue[p] = mapParameterValue.getString(propertyfield[p]);

							// System.out.println(fieldValue[p]);
							// System.out.println(p);

						} else { // voltage treated only for Dipoles!

							if (device.getName().substring(8).equals("GTS3MU1")
									|| device.getName().substring(8).equals("GTS3MU2")
									|| device.getName().substring(8).equals("GTS4MU1")
									|| device.getName().substring(8).equals("GHFSMU1")
									|| device.getName().substring(8).equals("GTS5MU1")
									|| device.getName().substring(8).equals("GTS6MU1")
									|| device.getName().substring(8).equals("GTS7MU1")) {

								fieldValue[p] = mapParameterValue.getString(propertyfield[p]);

								// System.out.println(fieldValue[p]);
								// System.out.println(p);

							} else {

								/*- Assign null value to all other devices (quadrupoles ect) */
								fieldValue[p] = 0.0;
							}
						}
					}

					if (p == 5) {

						fieldValue[p] = mapParameterValue.getBooleans(propertyfield[p]);
					}

					if (p == 6) {

						fieldValue[p] = mapParameterValue.getStrings(propertyfield[p]);
					}

					if (p == 7) { // DCValueAcq current

						fieldValue[p] = mapParameterValue.getString("current");
					}

					if (p == 8) { // DCValueAcq voltage

						fieldValue[p] = mapParameterValue.getStrings(propertyfield[p]);
					}

				} catch (final ParameterException e) {

					System.out.println(e);
				}
			} // End for property

			// Add processed device to the list
			try {

				magDataList.add(new Object[] { device.getName().substring(8), fieldValue[0], fieldValue[1],
						fieldValue[7/* 2 */], fieldValue[3], fieldValue[4], fieldValue[5], fieldValue[6] });

				// DCModeValAcq blocked
				// magDataList.add(new Object[] { device.getName().substring(8),
				// fieldValue[0], fieldValue[1], 0.0,
				// fieldValue[3], fieldValue[4], fieldValue[5], fieldValue[6]
				// });

			} catch (final Exception e) {

				System.out.println(e);
				System.exit(0);
			}
		} // End for Device
			// retrieveDataFromFESA();
	}

	public List<Object[]> getMagnetData() {

		return magDataList;
	}

	public List<Device> getSortedDevices() {

		return mySortedDevices;
	}

	public void setListOfSubscriptions(final List<SubscriptionHandle> subscriptions) {

		list_of_subscriptions = subscriptions;
	}

	// test method to check all devices processed within the getDeviceData
	// method
	public void retrieveDataFromFESA() {

		System.out.println("******FESA DATA******");
		System.out.println(magDataList.get(0)[5]);
		System.out.println(magDataList.size());
		for (int i = 0; i < magDataList.size(); i++) {

			try {
				System.out.println(magDataList.get(i)[0] + " - " + magDataList.get(i)[1] + " - " + magDataList.get(i)[2]
						+ " - " + magDataList.get(i)[3] + " - " + magDataList.get(i)[4] + " - " + " - "
						+ Arrays.toString((boolean[]) fieldValue[5]) + Arrays.toString((String[]) fieldValue[6]));

			} catch (final Exception e) {

				System.out.println(e);
				System.exit(0);

			}
		}
		// System.exit(0);
	}

	public void generateDeviceSubscriptions() {

		/*
		 * System.out.println("List Sub " + list_of_subscriptions.size());
		 *
		 * for (int s = 0; s < list_of_subscriptions.size(); s++) {
		 *
		 * System.out.println( list_of_subscriptions.get(s).getParameter() + " "
		 * + list_of_subscriptions.get(s).getSelector());
		 *
		 * }
		 */

		rdSel.setBeamChain(chain);

		for (final Device device : myDevices) {

			final Selector newMULTIPLEXED_SELECTOR = rdSel.getSelector(device);

			/*- temporary to propertynameSelector.length-1 to deal with the DCValueAcq separately */
			for (int p = 0; p < propertynameSelector.length; p++) {

				subscription_exists = false;

				final String parametername = Parameters.buildParameterName(device.getName().substring(8),
						propertynameSelector[p]);
				Parameter parameter = null;

				try {
					parameter = ParameterFactory.newInstance().newParameter(parametername);
				} catch (final ParameterException e1) {
					// TODO Auto-generated catch block
					e1.printStackTrace();
				}

				/*- Check if subscription is already initialized for a particular parameter and selector */

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

					// System.out.println(s);

					// System.out.println("Current parameter: " + parameter);
					// System.out.println("Current Selector: " +
					// newMULTIPLEXED_SELECTOR);

					// System.out.println(list_of_subscriptions.get(s).getParameter());
					// System.out.println(list_of_subscriptions.get(s).getSelector());

					if (list_of_subscriptions.get(s).getParameter() == parameter) {

						if (list_of_subscriptions.get(s).getSelector().equals(newMULTIPLEXED_SELECTOR)) {

							System.out.println("Subscription already initialized! Index: " + s);
							System.out.println(
									"Restarting monitoring..." + "Parameter " + parameter.getName() + " Index: " + s);

							subscription_exists = true;

							try {

								list_of_subscriptions.get(s).startMonitoring();

							} catch (final ParameterException e) {
								// TODO Auto-generated catch block
								e.printStackTrace();
							}

							break;
						}
					}
				}

				if (!subscription_exists) {

					System.out.println("A new instance has been created for " + device.getName());
					// final DeviceUpdateFESA duf = new
					// DeviceUpdateFESA(device.getName().substring(8));

					final DeviceUpdateFESA duf = new DeviceUpdateFESA(device.getName().substring(8));
					// duf.setDeviceName(device.getName().substring(8));

					try {

						duf.subscribe(newMULTIPLEXED_SELECTOR, propertynameSelector[p]);

					} catch (final Exception e) {

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

	public void closeDeviceSubscriptions() {

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

			list_of_subscriptions.get(s).stopMonitoring();

			System.out.println("Subscription stopped. Index " + s);
		}
	}
}