MagnetDataProcessorLSA31082018_MS.java

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

import java.util.ArrayList;
import java.util.Arrays;
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.accsoft.commons.domain.zones.AcceleratorZone;
import cern.accsoft.commons.util.Nameds;
import cern.japc.group.support.SysoutFailSafeParameterValueListener;
import cern.lsa.client.ContextService;
import cern.lsa.client.DeviceService;
import cern.lsa.client.ParameterService;
import cern.lsa.client.ServiceLocator;
import cern.lsa.client.Services;
import cern.lsa.client.SettingService;
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.ContextSettings;
import cern.lsa.domain.settings.Contexts;
import cern.lsa.domain.settings.DrivableBeamProcess;
import cern.lsa.domain.settings.Parameter;
import cern.lsa.domain.settings.ParameterSettings;
import cern.lsa.domain.settings.ParameterType;
import cern.lsa.domain.settings.Parameters;
import cern.lsa.domain.settings.Pattern;
import cern.lsa.domain.settings.Setting;
import cern.lsa.domain.settings.StandAloneCycle;
import cern.lsa.domain.settings.factory.ParameterTypesRequestBuilder;
import cern.lsa.domain.settings.factory.ParametersRequestBuilder;
import cern.lsa.domain.settings.type.BeamProcessTypeCategory;
import de.gsi.cs.co.lsa.domain.particletransfers.Gsi_hebtParticleTransfer;
import javafx.collections.FXCollections;

/**
 * @author fschirru
 */
public class MagnetDataProcessorLSA {

    private static final ParticleTransfer[] FRS_PARTICLE_TRANSFERS = new ParticleTransfer[] {
            Gsi_hebtParticleTransfer.SIS18_TO_GTS1MU1, Gsi_hebtParticleTransfer.GTS1MU1_TO_GTS3MU1,
            Gsi_hebtParticleTransfer.GTS3MU1_TO_GHFSMU1, Gsi_hebtParticleTransfer.GHFSMU1_TO_GTS6MU1,
            Gsi_hebtParticleTransfer.GTS6MU1_TO_GTS6MU1, Gsi_hebtParticleTransfer.GTS6MU1_TO_GTS7MU1,
            Gsi_hebtParticleTransfer.GTS7MU1_TO_GTH4MU1, Gsi_hebtParticleTransfer.GTH4MU1_TO_GTH4MU2,
            Gsi_hebtParticleTransfer.GTH4MU2_TO_GTV1MU1, Gsi_hebtParticleTransfer.GTV1MU1_TO_GHTDMU1,
            Gsi_hebtParticleTransfer.GHTDMU1_TO_HTC, Gsi_hebtParticleTransfer.GHFSMU1_TO_HFS,
            Gsi_hebtParticleTransfer.GTS6MU1_TO_ESR };

    private static final String[] PARAMETER_TYPES = new String[] { "I", "B0L", "B1L", "B2L", "K0L" };

    private static final String LSA_PREFIX_LOGICAL_DEVICES = "LOGICAL.";

    private static final MagnetDataProcessorLSA INSTANCE = new MagnetDataProcessorLSA();

    List<Object[]> magDataList = new ArrayList<>();

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

    private final DevicesRequestBuilder builder = new DevicesRequestBuilder();
    private Set<Device> myDevices;
    // private Set<Device> frsDevices;
    private Set<ParticleTransfer> particleTransfers;
    private Pattern pattern;

    final Set<Parameter> staticParameterList = new HashSet<>();

    final SettingService settingService = Services.getSettingsService();

    // private double myValueI;
    // private double myValueBL;

    private final Set<Device> filteredFrsDeviceNames = new HashSet<>();

    final ParameterService parameterService = Services.getParameterService();

    // final Parameter parameter_optics_name = parameterService
    // .findParameterByName("GTS1MU1_TO_GTS3MU1_OPTICS/OPTIC_NAME");

    // private String optics_name = "";

    private final List<Device> myFrsSortedDevices = new ArrayList<>();

    // private AcceleratorZone deviceAcceleratorZone;

    MagnetDataProcessorLSA() {

    }

    public static MagnetDataProcessorLSA getInstance() {

        return INSTANCE;
    }

    public void setPattern(final Pattern pattern) {

        this.pattern = pattern;
    }

    public void setBeamChain(final BeamProductionChain chain) {

        this.chain = chain;

        // setDevices();
        // setStaticDevices();
    }

    public void setDevices() {

        particleTransfers = Contexts.getParticleTransfersFromBeamProcesses(chain.getDrivableBeamProcesses());

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

        builder.setParticleTransfers(particleTransfers);
        builder.setMetaType(DeviceMetaTypeEnum.ACTUAL);
        builder.setDeviceTypeName("BasicPS");

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

        // getDevicesData(myDevices);
        getDevicesData();
    }

    public void setStaticDevices() {

        // Find static list of FRS devices
        final DevicesRequestBuilder devicesRequestBuilder = new DevicesRequestBuilder();
        final Set<ParticleTransfer> frsParticleTransfers = new HashSet<>();

        Collections.addAll(frsParticleTransfers, FRS_PARTICLE_TRANSFERS);
        devicesRequestBuilder.setParticleTransfers(frsParticleTransfers);
        devicesRequestBuilder.setMetaType(DeviceMetaTypeEnum.ACTUAL);
        devicesRequestBuilder.setDeviceTypeName("BasicPS");

        // frsDevices = deviceService.findDevices(devicesRequestBuilder.build());
        myDevices = deviceService.findDevices(devicesRequestBuilder.build());

        System.out.println("*** THE FULL LIST OF FRS DEVICES ***");
        for (final Device device : myDevices) {

            System.out.println(device.getName() + " , " + device.getDeviceType().getName() + " , "
                    + device.getPosition() + " , " + device.getSortOrder());

        }
        // System.exit(0);

        System.out.println("Number of FRS devices " + myDevices.size());
        // getDevicesData(frsDevices);
        // getDevicesData(myDevices);

        myFrsSortedDevices.clear();
        // Sort (position wise) the full list of devices. Later the list will be filtered out for the selected Chain
        for (final Device device : myDevices) {

            // System.out.println(device.getName() + " " + device.getPosition() + " " + device.getSortOrder());

            myFrsSortedDevices.add(device);
        }
        final DeviceComparator dc = new DeviceComparator();
        myFrsSortedDevices.sort(dc);

        for (int m = 0; m < myFrsSortedDevices.size(); m++) {

            System.out.println(myFrsSortedDevices.get(m).getName() + " , "
                    + myFrsSortedDevices.get(m).getDeviceType().getName() + " , "
                    + myFrsSortedDevices.get(m).getPosition() + " , " + myFrsSortedDevices.get(m).getSortOrder());

        }
        // System.exit(0);

        getDevicesData();
    }

    public Set<Device> getStaticDevices() {

        // return myDevices;
        // return frsDevices;
        return filteredFrsDeviceNames;
    }

    // public void getDevicesData(final Set<Device> myDevices) {
    public void getDevicesData() {

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

        // Look for parameter types that we are interested in
        final ParameterTypesRequestBuilder parameterTypesRequestBuilder = new ParameterTypesRequestBuilder();
        parameterTypesRequestBuilder.setParameterTypeNames(Arrays.asList(PARAMETER_TYPES));
        final Set<ParameterType> parameterTypes = parameterService
                .findParameterTypes(parameterTypesRequestBuilder.build());
        System.out.println("*** LIST OF PARAMETER TYPE ***");
        for (final ParameterType parameterType : parameterTypes) {
            System.out.println(parameterType);
        }

        final ParametersRequestBuilder parametersRequestBuilder = new ParametersRequestBuilder();
        final Set<String> lsaDeviceNames = new HashSet<>();

        // Surround by Try/Catch statement in the case the list of devices is empty!!!!!!

        if (!myDevices.isEmpty()) {

            final List<AcceleratorZone> deviceAcceleratorZone = new ArrayList<>();
            deviceAcceleratorZone.clear();

            final List<String[]> deviceParameters = new ArrayList<>();
            deviceParameters.clear();

            filteredFrsDeviceNames.clear();
            staticParameterList.clear();

            for (final Device device : myDevices) {

                // System.out.println(device.getName());
                // for (final Device device : frsDevices) {
                lsaDeviceNames.add(LSA_PREFIX_LOGICAL_DEVICES + device.getName());
                // System.out.println(LSA_PREFIX_LOGICAL_DEVICES + device.getName());

                System.out.println(device.getName() + " , " + device.getDeviceType().getName() + " , "
                        + device.getPosition() + " , " + device.getSortOrder());

            }

            parametersRequestBuilder.setDeviceNames(lsaDeviceNames);
            parametersRequestBuilder.setParameterTypeNames(Nameds.getNames(parameterTypes));
            final Set<Parameter> parameters = parameterService.findParameters(parametersRequestBuilder.build());

            System.out.println("*** THE LIST OF PARAMETERS ***");
            for (final Parameter parameter : parameters) {
                staticParameterList.add(parameter);
                System.out.println(parameter);
                // System.out.println(parameter.getParameterType());

            }

            System.out.println("Number of Parameters " + parameters.size());

            pattern = (Pattern) chain.getParent();

            final List<DrivableBeamProcess> allChainBeamProcesses = chain.getDrivableBeamProcesses();
            final List<DrivableBeamProcess> beamInBeamProcesses = Contexts.filterBeamProcesses(allChainBeamProcesses,
                    null, BeamProcessTypeCategory.FUNCTION_BEAM_IN);

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

            // final List<DrivableBeamProcess> beamInBeamProcesses = Contexts.filterBeamProcesses(allChainBeamProcesses,
            // Gsi_hebtParticleTransfer.GTS1MU1_TO_GTS3MU1, BeamProcessTypeCategory.FUNCTION_BEAM_IN);

            final Set<Parameter> parametersFilteredOnChain = Parameters.filterParametersByParticleTransfers(
                    staticParameterList, Contexts.getParticleTransfersFromBeamProcesses(beamInBeamProcesses));

            // parametersFilteredOnChain.add(par); // to do 4/4/2018

            System.out.println(parametersFilteredOnChain.size());

            System.out.println("*** THE LIST OF PARAMETERS FILTERED ON CHAIN ***");

            for (final Parameter parameter : parametersFilteredOnChain) {

                // System.out.println(parameter.getDevice().getPosition());
                filteredFrsDeviceNames.add(parameter.getDevice());

            }

            /*
             *
             * // This is the part relating to sorting topographycally all devices.
             * // It is a temporary solution which could be improved later directly on the column of the table
             * final List<Device> sortedfilteredFrsDeviceNames = new ArrayList<>();
             * for (final Device device : filteredFrsDeviceNames) {
             *
             * System.out.println(device.getName() + " " + device.getPosition() + " " + device.getSortOrder());
             *
             * sortedfilteredFrsDeviceNames.add(device);
             * }
             *
             * // System.exit(0);
             *
             * final DeviceComparator dc = new DeviceComparator();
             * sortedfilteredFrsDeviceNames.sort(dc);
             *
             * for (int i = 0; i < sortedfilteredFrsDeviceNames.size(); i++) {
             *
             * System.out.println(
             * sortedfilteredFrsDeviceNames.get(i) + " " + sortedfilteredFrsDeviceNames.get(i).getPosition()
             * + " " + sortedfilteredFrsDeviceNames.get(i).getSortOrder());
             *
             * }
             *
             * // System.exit(0);
             *
             * System.out.println(filteredFrsDeviceNames);
             *
             * System.out.println(sortedfilteredFrsDeviceNames.size());
             * System.out.println(filteredFrsDeviceNames.size());
             *
             */

            System.out.println("Number of Parametzers filtered on Chain " + parametersFilteredOnChain.size());

            /*
             * // Initialize the deviceParameters list for later usage using the sorted device list
             * for (final Device device : sortedfilteredFrsDeviceNames) {
             * // for (final Device device : filteredFrsDeviceNames) {
             *
             * deviceParameters.add(new String[] { device.getName(), "0.0", "0.0" }); // double values for I and BL //
             * // respectively
             * }
             */

            // Initialize the deviceParameters list for later usage using the sorted device list
            for (int m = 0; m < myFrsSortedDevices.size(); m++) {
                for (final Device device : filteredFrsDeviceNames) {

                    if (myFrsSortedDevices.get(m).getName().equals(device.getName().substring(8))) {

                        deviceParameters.add(new String[] { device.getName(), "0.0", "0.0", "0.0" }); // double values
                                                                                                      // for I, BL and
                                                                                                      // K0L
                                                                                                      // respectively

                        deviceAcceleratorZone.add(myFrsSortedDevices.get(m).getAcceleratorZone());
                    }
                }
            }
            System.out.println(deviceParameters.size()); // must coincide with parametersFilteredOnChain.size()

            final ContextSettings contextSettings = settingService.findContextSettings(pattern,
                    parametersFilteredOnChain);

            // Jutta sends something more nicely
            for (final DrivableBeamProcess beamInBeamProcess : beamInBeamProcesses) {

                // System.out.println(beamInBeamProcess.getUser());
                // System.exit(0);

                // System.out.println(beamInBeamProcess.getName());
                for (final Parameter parameter : parametersFilteredOnChain) {

                    // System.out.println(parameter);
                    // System.out.println(beamInBeamProcess.getUser());
                    // System.exit(0);

                    // contextSettings.getCurrentSetting(beamInBeamProcess, parameter); // might be NULL !!!! Need to
                    // implement
                    // if or try/catch block!!!!

                    // System.out.println(contextSettings.getCurrentSetting(beamInBeamProcess, parameter));

                    if (contextSettings.getCurrentSetting(beamInBeamProcess, parameter) != null) {

                        // if (parameter != parameter_optics_name) {

                        final double value = contextSettings.getCurrentSetting(beamInBeamProcess, parameter)
                                .getScalarValue().getDouble();
                        // System.out.println(value);
                        // Update the deviceParameters values
                        for (int i = 0; i < deviceParameters.size(); i++) {

                            // System.out.println(deviceParameters.get(i)[0] + "-" +
                            // parameter.getDevice().getName());

                            if (deviceParameters.get(i)[0].equals(parameter.getDevice().getName())) {

                                if (parameter.getParameterType().toString().equals("I")) {

                                    deviceParameters.get(i)[1] = Double.toString(value);

                                }

                                if (parameter.getParameterType().toString().equals("B0L")) {

                                    deviceParameters.get(i)[2] = Double.toString(value);

                                }

                                if (parameter.getParameterType().toString().equals("K0L")) {

                                    deviceParameters.get(i)[3] = Double.toString(value);

                                }

                                // else {

                                // deviceParameters.get(i)[2] = Double.toString(value);
                                // }
                            }
                        }

                        // } else {

                        // optics_name = contextSettings.getCurrentSetting(beamInBeamProcess, parameter)
                        // .getScalarValue().getString();
                        // }
                    }
                }
            }

            /*
             * // Add the Accelerator Zone to the corresponding device
             * for (final Device device : sortedfilteredFrsDeviceNames) {
             *
             * deviceAcceleratorZone.add(device.getAcceleratorZone());
             * }
             */

            System.out.println("*** DISPLAY 'deviceParameters' content ***");
            for (int i = 0; i < deviceParameters.size(); i++) {

                System.out.println("Parameter Name: " + deviceParameters.get(i)[0] + "I: " + deviceParameters.get(i)[1]
                        + " BL: " + deviceParameters.get(i)[2] + " KL: " + deviceParameters.get(i)[3]);
            }

            // Fill the magDataList -> Name, Current, BField

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

                magDataList.add(new Object[] { deviceParameters.get(i)[0], deviceParameters.get(i)[2],
                        deviceParameters.get(i)[1], deviceAcceleratorZone.get(i), deviceParameters.get(i)[3] });

                // magDataList.add(new Object[] { deviceParameters.get(i)[0], deviceParameters.get(i)[2],
                // deviceParameters.get(i)[1], deviceAcceleratorZone });
            }

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

                System.out.println(((String) magDataList.get(i)[0]).substring(8) + " - " + magDataList.get(i)[2] + " - "
                        + magDataList.get(i)[1] + " - " + deviceAcceleratorZone.get(i) + " - " + magDataList.get(i)[4]);
            }

            // System.exit(0);

        } // endif (!myDevice.isEmpty())

    }

    /*
     * public String getOpticsName() {
     * 
     * return optics_name;
     * }
     */

    /*
     *
     *
     *
     * for (final Setting setting : parameterSettings.getSettings()) {
     * if (setting.getBeamProcess().getCategory().isBeamIn()) {
     * // take the double value and fill it into internal table structure
     * final double myValue = setting.getScalarValue().getDouble();
     * System.out.println(myValue);
     * break;
     * }
     * }
     *
     *
     *
     *
     *
     * final Parameter parameter1 = parameterService.findParameterByName("GHTYQD42/I");
     *
     * // read settings
     * final ContextSettings contextSettings = settingService.findContextSettings(pattern);
     * final ParameterSettings parameterSettings = contextSettings.getParameterSettings(parameter1);
     * System.out.println(parameterSettings.getCurrentSettings());
     * for (final Setting setting : parameterSettings.getSettings()) {
     * if (setting.getBeamProcess().getCategory().isBeamIn()) {
     * // take the double value and fill it into internal table structure
     * final double myValue = setting.getScalarValue().getDouble();
     * System.out.println(myValue);
     * break;
     * }
     * }
     *
     *
     * // read parameter
     * final Set<Parameter> parameters = new HashSet<>();
     * // loop over all device types
     * // once per device type (for all devices of that type)
     * final ParametersRequestBuilder builder_ = new ParametersRequestBuilder();
     * builder_.setDevices(myDevices);
     * builder_.setParameterTypeNames(Arrays.asList(new String[] { "I", "BL" }));
     * // endloop
     * parameters.addAll(parameterService.findParameters(builder_.build()));
     */

    public List<Object[]> getMagnetData() {

        return magDataList;
    }

}