MagnetDataProcessorFESA_25052018.java

package de.gsi.cs.co.ap.my_test_project.utils;

import java.util.ArrayList;
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.japc.factory.SelectorFactory;
import cern.japc.group.support.SysoutFailSafeParameterValueListener;
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.BeamProcess;
import cern.lsa.domain.settings.BeamProductionChain;
import cern.lsa.domain.settings.Contexts;
import cern.lsa.domain.settings.DrivableBeamProcess;
import cern.lsa.domain.settings.factory.ParametersRequestBuilder;
import cern.lsa.domain.settings.type.BeamProcessTypeCategory;
import de.gsi.aco.sv.japc.FAIRSelectorBuilder;
import de.gsi.cs.co.lsa.domain.GsiTimingDomain;

public class MagnetDataProcessorFESA {

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

    private final MagnetDataProcessorLSA mdpLSA = MagnetDataProcessorLSA.getInstance();
    private Set<Device> frsDevices;

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

    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<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 boolean isDeviceOn;

    // private DeviceUpdateFESA duf;

    // private final String magData[][] = getMagnetData();

    // String temp_magData[][];

    MagnetDataProcessorFESA() {

    }

    public static MagnetDataProcessorFESA getInstance() {

        return INSTANCE;
    }

    public void setBeamChain(final BeamProductionChain chain) {

        this.chain = chain;

        // System.out.println(chain.getDrivableBeamProcesses());
        // System.out.println(chain.getDrivableBeamProcesses().get(0).getUser());
        // System.exit(0);
        // setDevices();
        // setFrsDevices();
    }

    public void setFrsDevices() {

        System.out.println("*********");
        System.out.println("*********");
        myDevices = mdpLSA.getStaticDevices();
        // System.out.println("frsDevices Dim: " + frsDevices.size());
        System.out.println(myDevices.size());

        System.out.println(myDevices);

        getDevicesData();
    }

    public void setDevices() {

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

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

        System.out.println("*********");
        System.out.println(myDevices);

        System.out.println("*********");

        System.out.println("FESA myDevice DIM " + myDevices.size());

        getDevicesData();
    }

    public void getDevicesData() {

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

        // final Set<Parameter> parameters = new HashSet<>();

        for (final Device device : myDevices) {

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

            // final ParametersRequestBuilder builder_ = new ParametersRequestBuilder();
            // builder_.setDevices(frsDevices);
            // builder_.setParameterTypeNames(Arrays.asList(new String[] { "I", "BL" }));

            // System.out.println("*** Device Properties ***");
            // System.out.println(device.getName());

            // to be removed
            if (device.getName().equals("LOGICAL.GTS3MU1")) {

                // System.exit(0);

                // Set<cern.lsa.domain.settings.Parameter> parameterNames = Services.getParameterService()
                // .findParameters(ParametersRequestBuilder.byDeviceName(device.getName().substring(8)));
                //
                // Contexts.filterBeamProcessesByParticleTransfers(chain.getDrivableBeamProcesses(),
                // parameterNames.iterator().next().getParticleTransfers());

                parameterName = Parameters.buildParameterName(device.getName().substring(8), "Acquisition");

                final Set<ParticleTransfer> particleTransfersForDevice = device.getAcceleratorZone()
                        .getParticleTransfers();
                if (particleTransfersForDevice.size() > 1) {
                    throw new IllegalStateException("There was more then one particle transfer found for device "
                            + device.getName() + " but it should be only one.");
                }
                final List<DrivableBeamProcess> chainBeamProcesses = chain.getDrivableBeamProcesses();
                final ParticleTransfer particleTransferForDevice = particleTransfersForDevice.iterator().next();
                final List<DrivableBeamProcess> beamProcessesForDevice = Contexts.filterBeamProcesses(
                        chainBeamProcesses, particleTransferForDevice, BeamProcessTypeCategory.FUNCTION_BEAM_IN);

                for (int d = 0; d < beamProcessesForDevice.size(); d++) {

                    System.out.println("CHAIN: " + beamProcessesForDevice.get(d).getName());
                    System.out.println("SELECTOR: " + beamProcessesForDevice.get(d).getUser());

                    try {

                        final Parameter parameter = ParameterFactory.newInstance().newParameter(parameterName);

                        System.out.println("Parameter " + parameter);

                        final Selector newMULTIPLEXED_SELECTOR = FAIRSelectorBuilder
                                .parse(beamProcessesForDevice.get(d).getUser()).build();

                        System.out.println(newMULTIPLEXED_SELECTOR);

                        // final Selector newMULTIPLEXED_SELECTOR = SelectorFactory.newSelector("FAIR.SELECTOR.ALL");

                        ParameterValue = parameter.getValue(newMULTIPLEXED_SELECTOR); // point of exception for property
                                                                                      // "Acquisition"
                        // ParameterValue = parameter.getValue(NULL_SELECTOR);

                        System.out.println(ParameterValue);

                        // System.exit(0);

                        mapParameterValue = (MapParameterValue) ParameterValue.getValue();
                        System.out.println(mapParameterValue.getNames());

                        System.out.println("***MAP PARAMETER VALUE***");
                        System.out.println(mapParameterValue);

                        // System.out.println("VALUE:" + mapParameterValue.getString("status"));

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

                    }

                } // end for

                System.exit(0);
            } // to be removed

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

                try {

                    parameterName = Parameters.buildParameterName(device.getName().substring(8), propertyname[p]);

                    System.out.println("Parameter Name " + parameterName);

                    // final String parameterName = device.getName().substring(8) + "/Acquisition";

                    // System.out.println(par);

                    // System.exit(0);

                    parameter = ParameterFactory.newInstance().newParameter(parameterName);

                    System.out.println("Parameter " + parameter);

                    ParameterValue = parameter.getValue(MULTIPLEXED_SELECTOR);
                    // ParameterValue = parameter.getValue(NULL_SELECTOR);

                    System.out.println(ParameterValue);

                    // System.exit(0);

                    mapParameterValue = (MapParameterValue) ParameterValue.getValue();
                    System.out.println(mapParameterValue.getNames());

                    System.out.println("***MAP PARAMETER VALUE***");
                    System.out.println(mapParameterValue);

                    // System.exit(0);

                    if (p < 5) {

                        fieldValue[p] = mapParameterValue.getString(propertyfield[p]);
                        // System.out.println("Property: " + propertyname[p] + " " + "Field Value: " + fieldValue);

                    } else {

                        // Implement boolean part
                        // fieldValue[p] = mapParameterValue.getBooleans(propertyfield[p]);
                    }

                    if (p == 5) {

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

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

                    }

                    if (p == 6) {

                        // fieldValue_labels.addAll(new String[] {mapParameterValue.getStrings(propertyfield[p])});
                        fieldValue[p] = mapParameterValue.getStrings(propertyfield[p]);
                        // System.out.println(Arrays.toString((String[])fieldValue[p]));
                        // System.out.println(Arrays.toString(fieldValue[p]));
                        // System.out.println("ARRAY**** " + mapParameterValue.getString(propertyfield[p]));
                        // System.out.println(fieldValue_labels[1]);

                    }

                    // temp_magData[deviceCounter][p] = fieldValue[p];

                    ////
                    // duf.getParameterValue(MULTIPLEXED_SELECTOR, propertyname[p]);

                    // duf.subscribe(MULTIPLEXED_SELECTOR, propertyname[p]);

                } catch (final ParameterException e) {

                    // System.out.println("PROGRAM STOPPED");
                    // System.exit(p);

                    setDeviceOn(false);

                    // Acquisition/current get null value if magnets are off or BeamProductionChain is not running
                    // See Jutta's mail 23/4/2018 - 12:54
                    // if (p == 0) {
                    if (p == 0 && fieldValue[p] == null) {

                        fieldValue[0] = "99.99";

                    }

                    // Acquisition/voltage (Hall Probe) get null value if magnets are off or BeamProductionChain is not

                    if (p == 1 && fieldValue[p] == null) {

                        fieldValue[1] = "99.99";
                    }
                    // LOGGER.error(e.getMessage());
                    // System.out.println("ERROR************************************************");
                }

            }

            // Check if dcMode is false. If so, then assign values related to Acquisition, otherwise related to DaqVal
            if (fieldValue[3].equals("false")) {

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

            } else {

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

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

                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]));

            }

            // magnetData.add(new Magnet(device.getName(), Integer.parseInt(fieldValue[2]),
            // Boolean.valueOf(fieldValue[1]),
            // Double.parseDouble(fieldValue[0]), 0.0, 0.0, 0.0, 0.0, false));
            // System.out.println("*** End of Decvie Properties ***");
        }

        // System.out.println(magData.length);
        // System.out.println("************DATA");
        // System.out.println(magDataList.get(0)[0]);
        // System.out.println(magData.length);
        // System.out.println("************DATA");

        // getParameterValue(propertyname1, MULTIPLEXED_SELECTOR);

        // System.exit(0);
    }

    public void startDeviceSubscriptions() {

        // Start all subscriptions
        for (final Device device : myDevices) {

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

                if (p == 0 || p == 1) {

                    if (isDeviceOn) {

                        final DeviceUpdateFESA duf = new DeviceUpdateFESA(device.getName().substring(8));
                        duf.subscribe(MULTIPLEXED_SELECTOR, propertyname[p]);

                    }
                }

                if (p > 1) {

                    final DeviceUpdateFESA duf = new DeviceUpdateFESA(device.getName().substring(8));
                    duf.subscribe(MULTIPLEXED_SELECTOR, propertyname[p]);
                }

            }

        }

    }

    public List<Object[]> getMagnetData() {

        return magDataList;
    }

    /**
     * @return the isDeviceOn
     */
    public boolean isDeviceOn() {

        return isDeviceOn;
    }

    /**
     * @param isDeviceOn the isDeviceOn to set
     */
    public void setDeviceOn(final boolean isDeviceOn) {

        this.isDeviceOn = isDeviceOn;
    }

    // public ObservableList<Magnet> getMagnetData() {

    // return magnetData;
    // }

}