package art.servers.etdserver.controller;


import art.library.model.devices.DeviceStatus;
import art.library.model.devices.etd.Etd;
import art.library.model.devices.etd.EtdInformation;
import art.library.model.devices.etd.information.EtdClassification;
import art.library.interop.serialization.Serialization;
import art.library.model.transactions.traces.Trace;
import art.servers.etdserver.Shared;
import art.servers.etdserver.protocols.diamond.Diamond_Message;
import art.servers.etdserver.protocols.diamond.Diamond_ProtocolAnalyser;
import art.servers.etdserver.protocols.diamond.Diamond_ProtocolConstructor;
import art.servers.etdserver.protocols.diamond.configuration.DIAMOND_LengthBinnedData;
import art.servers.etdserver.protocols.diamond.configuration.DIAMOND_SpeedBinnedData;
import art.servers.etdserver.protocols.diamond.file.DIAMOND_File;
import art.servers.etdserver.protocols.diamond.files.DIAMOND_Directory;
import art.servers.etdserver.protocols.diamond.files.DIAMOND_Subdirectory;
import java.io.InputStream;
import java.io.OutputStream;
import static java.lang.Thread.sleep;
import java.net.Socket;
import java.net.SocketTimeoutException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;


public class ControllerDiamond extends ControllerEtd
{
    private SimpleDateFormat sdh = new SimpleDateFormat("HH:mm");
    private boolean connected = false;
    private Socket socket = null;
    private InputStream is = null;
    private OutputStream os = null;
    private long lastTimestamp = 0;
    private int status = DeviceStatus.STATUS_ALARM;
    private boolean firstTime = true;
    private long lastOffline = System.currentTimeMillis();


    public ControllerDiamond(Etd etd)
    {
        super(etd);
        this.device = etd;
        this.name = Shared.getMessage("Controller etd") + " " + etd.information.name;
        super.setName(this.name);
    }
    
    
    
    
    public void run()
    {
        // <editor-fold defaultstate="collapsed" desc="Trace">
        art.servers.Shared.println(Trace.getTraceInformation(art.servers.Shared.getApplicationName(), name, art.servers.Shared.getMessage("Starting"), art.servers.Shared.getMessage("Success")), true);
        // </editor-fold>      
        status = DeviceStatus.STATUS_ONLINE;

        while ((isInterrupted() == false) && (exit == false))
        {
            long startTimestamp = System.currentTimeMillis();

            try
            {
                if (art.servers.Shared.isServerEnabled() == true)
                {
                    if (connected == false) 
                    {
                        connect();
                    }

                    update();
                }
            }
            catch (Exception e)
            {
                e.printStackTrace();
            }

            if (startTimestamp > System.currentTimeMillis())
            {
                startTimestamp = System.currentTimeMillis();
            }

            long stopTimestamp = startTimestamp + (device.getDeviceInformation().polling * 1000);

            while ((System.currentTimeMillis() < stopTimestamp) && (exit == false))
            {
                try
                {
                    sleep(50);
                }
                catch (Exception e)
                {
                }
            }
           
            if (art.servers.Shared.model.existsDevice(device.getIdentifier()) == false)
            {
                art.servers.Shared.println(name, art.servers.Shared.getMessage("Device no longer exists"));
                exit = true;
            }
        }
        
        // <editor-fold defaultstate="collapsed" desc="Trace">
        art.servers.Shared.println(Trace.getTraceInformation(art.servers.Shared.getApplicationName(), name, art.servers.Shared.getMessage("Finishing"), art.servers.Shared.getMessage("Success")), true);
        // </editor-fold>      
    }




    /*
        Private controller functions
    */

    private void update() throws Exception
    {
        Etd etdclone = (Etd)Serialization.clone(device);

        try
        {
            sleep(15000);

            EtdInformation etdInformation = (EtdInformation)etdclone.getDeviceInformation();

            // Connect with Counter
            disconnectCounter();
            connectCounter(etdclone);
            sendPassword(etdInformation.connection.password);
            startCollecting(etdclone);

            // Get Length and Speed bin tables
            DIAMOND_LengthBinnedData lengthBinnedData = getLengthBinTable(etdclone);
            DIAMOND_SpeedBinnedData speedBinnedData = getSpeedBinTable(etdclone);

            // Get File open data
            retrieveFileOpenData(etdclone, lengthBinnedData, speedBinnedData);

            // Get system status and check datetime
            checkDatetime(etdclone);

            // Disconnect from Counter
            disconnectCounter();

            return;
        }
        catch (Exception exception)
        {
            if ((etdclone.alarms.alarm_offline <= 0) || (firstTime == true))
            {
                firstTime = false;
                art.servers.Shared.println(name, exception);
            }

            offline(etdclone);
        }
        finally
        {
            try{disconnect();} catch (Exception ex){};
        }
    }




    private boolean isError()
    {
        errorsNumber = errorsNumber + 1;
        if (errorsNumber >= maxErrorsNumber)
            return(true);
        return(false);
    }




    private void offline(Etd etdclone)throws Exception
    {
        System.out.println(this.device.getIdentifier() + " 1.Offline " + this.device.getAlarm("alarm_offline") + " - " + this.device.getDeviceStatus().status);
        if ((isError() == true) || 
            (
                (this.device.getAlarm("alarm_offline") > 0) || 
                (this.device.getDeviceStatus().status == DeviceStatus.STATUS_DISABLE) || 
                (this.device.getDeviceStatus().status == DeviceStatus.STATUS_UNKNOWN) || 
                (this.device.getDeviceStatus().status == DeviceStatus.STATUS_SIMULATION) || 
                (this.device.getDeviceStatus().status == DeviceStatus.STATUS_INVALID)
            )
           )
        {
            if (etdclone.getAlarm("alarm_offline") <= 0)
            {
                etdclone.getDeviceAlarms().clear();
            }
            etdclone.setAlarm("alarm_offline", true);
            System.out.println(this.device.getIdentifier() + " 2.Offline " + etdclone.getAlarm("alarm_offline") + " - " + etdclone.getDeviceStatus().status);
            Shared.model.updateDevice(device, etdclone);
            System.out.println(this.device.getIdentifier() + " 3.Offline " + this.device.getAlarm("alarm_offline") + " - " + this.device.getDeviceStatus().status);
        }
    }


    private void online(Etd etdclone) throws Exception
    {
        errorsNumber = 0;
        if ((etdclone.alarms.alarm_offline > 0) || (firstTime == true))
        {
            firstTime = false;
            String message = art.servers.Shared.getMessage("Etd online");
            art.servers.Shared.println(name, message);
        }

        System.out.println(this.device.getIdentifier() + " 1.Online " + this.device.getAlarm("alarm_offline") + " - " + this.device.getDeviceStatus().status);
        etdclone.setAlarm("alarm_offline", false);
        etdclone.setAlarm("alarm_invalid", false);
        System.out.println(this.device.getIdentifier() + " 2.Online " + etdclone.getAlarm("alarm_offline") + " - " + etdclone.getDeviceStatus().status);
        Shared.model.updateDevice(device, etdclone);
        System.out.println(this.device.getIdentifier() + " 3.Online " + this.device.getAlarm("alarm_offline") + " - " + this.device.getDeviceStatus().status);
    }





    private void connectCounter (Etd etdclone) throws Exception
    {
        byte[] command = Diamond_ProtocolConstructor.connectCounter();
        Diamond_Message response = read(command);

        try
        {
            updateVersion(etdclone, response.getResponseString());
        }
        catch (Exception e)
        {
            
        }
    }


    private void disconnectCounter ()
    {
        try
        {
            byte[] command = Diamond_ProtocolConstructor.disconnectCounter();
            Diamond_Message response = read(command);
        }
        catch (Exception e)
        {
            
        }
        try
        {
            byte[] XMODEMEND = Diamond_ProtocolConstructor.XMODEMEND();
            Diamond_Message response = read(XMODEMEND);
        }
        catch (Exception e)
        {
            
        }
        try
        {
            byte[] CR = Diamond_ProtocolConstructor.CR();
            Diamond_Message response = read(CR);
        }
        catch (Exception e)
        {
            
        }
    }


    private void sendPassword (String password) throws Exception
    {
        byte[] command = Diamond_ProtocolConstructor.sendPasswordCounter(password);
        Diamond_Message response = read(command);
        response.checkError();
        Diamond_ProtocolAnalyser.analyseSendPasswordResponse(response);
    }


    private DIAMOND_LengthBinnedData getLengthBinTable (Etd etdclone) throws Exception
    {
        byte[] command = Diamond_ProtocolConstructor.getLengthBinTable();
        Diamond_Message response = read(command);
        response.checkError();
        response.checkCommand(response.getResponseString().getBytes(), command);

        Diamond_Message message = new Diamond_Message();
        message.setData(response.getDataByte(), command);
        DIAMOND_LengthBinnedData lengthBinnedData = Diamond_ProtocolAnalyser.analyseGetLengthBinTableResponse(etdclone.getDeviceInformation().firmwareVersion, message);
        return(lengthBinnedData);
    }


    private DIAMOND_SpeedBinnedData getSpeedBinTable (Etd etdclone) throws Exception
    {
        byte[] command = Diamond_ProtocolConstructor.getSpeedBinTable();
        Diamond_Message response = read(command);
        response.checkError();
        response.checkCommand(response.getResponseString().getBytes(), command);

        Diamond_Message message = new Diamond_Message();
        message.setData(response.getDataByte(), command);
        DIAMOND_SpeedBinnedData speedBinnedData = createSpeedBinTable();  // Diamond_ProtocolAnalyser.analyseGetSpeedBinTableResponse(message);
        EtdInformation etdInformation = etdclone.getDeviceInformation();
        etdInformation.lSpeedClassification.clear();
        for (int i=0; i<speedBinnedData.numberOfBins; i++)
        {
            float minSpeed = (float)((float)speedBinnedData.bins[i].minSpeed / 10f);  // Diamond returns data per 10
            float maxSpeed = (float)((float)speedBinnedData.bins[i].maxSpeed / 10f);  // Diamond returns data per 10
            EtdClassification classification = new EtdClassification();
            classification.identifier = i+1;
            classification.description = "" + minSpeed + Shared.getMessage(" km/h") + " - " + maxSpeed + Shared.getMessage(" km/h");
            classification.lowerLimit = minSpeed;
            classification.upperLimit = maxSpeed;

            etdInformation.lSpeedClassification.add(classification);
        }

        return(speedBinnedData);
    }


    private DIAMOND_Directory getFilesDirectory (Etd etdclone) throws Exception
    {
        byte[] command = Diamond_ProtocolConstructor.getFilesDirectory();
        Diamond_Message response = read(command);
        response.checkError();
        response.checkCommand(response.getResponseString().getBytes(), command);

        Diamond_Message message = new Diamond_Message();
        message.setData(response.getDataByte(), command);
        DIAMOND_Directory directory = Diamond_ProtocolAnalyser.analyseGetFilesDirectoryResponse(etdclone, message);
        return(directory);
    }


    private void startCollecting (Etd etdclone)
    {
        try
        {
            byte[] command = Diamond_ProtocolConstructor.startCollecting();
            Diamond_Message response = read(command);
            response.checkError();
            response.checkCommand(response.getResponseString().getBytes(), command);
        }
        catch (Exception e)
        {
            
        }
    }


    private void stopCollecting ()
    {
        try
        {
            byte[] command = Diamond_ProtocolConstructor.stopCollecting();
            Diamond_Message response = read(command);
            response.checkError();
            response.checkCommand(response.getResponseString().getBytes(), command);
        }
        catch (Exception e)
        {
            
        }
    }


    private void checkDatetime (Etd etdclone)
    {
        try
        {
            byte[] command = Diamond_ProtocolConstructor.getSystemStatusCounter();
            Diamond_Message response = read(command);
            long timestamp = System.currentTimeMillis();
            response.checkError();
            response.checkCommand(response.getResponseString().getBytes(), command);

            Diamond_Message message = new Diamond_Message();
            message.setData(response.getDataByte(), command);
            long timeDifference = 0;
            long currenttime = 0;
            boolean collecting = false;

            if (etdclone.getDeviceInformation().firmwareVersion.indexOf("5.") > -1)
            {
                message.get6X();
                message.get2X();
                message.get2X();
                message.get2X();
                message.get4X();
                message.get4X();
                message.get4X();
                message.get6X();
                message.get6X();
                message.get1X();
                collecting = (message.get1X() == 0x01);
                int hour = message.get2X();
                int minute = message.get2X();
                int seconds = message.get2X();
                int mseconds = message.get2X();
                int month = message.get2X();
                int date = message.get2X();
                int year = message.get2X();
                int dayOfWeek = message.get2X();

                Calendar calendar = Calendar.getInstance();
                calendar.set(Calendar.HOUR_OF_DAY, hour);
                calendar.set(Calendar.MINUTE, minute);
                calendar.set(Calendar.SECOND, seconds);
                calendar.set(Calendar.MILLISECOND, mseconds);
                calendar.set(Calendar.YEAR, year+2000);
                calendar.set(Calendar.MONTH, month-1);
                calendar.set(Calendar.DATE, date);

                currenttime = calendar.getTimeInMillis();
                timeDifference = Math.abs((currenttime-timestamp));
            }
            else
            {
                message.get6X();
                message.get2X();
                message.get2X();
                message.get4X();
                message.get4X();
                message.get6X();
                message.get6X();
                message.get1X();
                collecting = (message.get1X() == 0x01);
                int hour = message.get2X();
                int minute = message.get2X();
                int seconds = message.get2X();
                int mseconds = message.get2X();
                int month = message.get2X();
                int date = message.get2X();
                int year = message.get2X();
                int dayOfWeek = message.get2X();

                Calendar calendar = Calendar.getInstance();
                calendar.set(Calendar.HOUR_OF_DAY, hour);
                calendar.set(Calendar.MINUTE, minute);
                calendar.set(Calendar.SECOND, seconds);
                calendar.set(Calendar.MILLISECOND, mseconds);
                calendar.set(Calendar.YEAR, year+2000);
                calendar.set(Calendar.MONTH, month-1);
                calendar.set(Calendar.DATE, date);

                currenttime = calendar.getTimeInMillis();
                timeDifference = Math.abs((currenttime-timestamp));
            }

            if (timeDifference >= 60000)
            {
                Shared.println(device.information.name, "Datetime incorrect: " + new Date(timestamp).toString() + " - " + new Date(currenttime).toString() + " - DIF: " + timeDifference + " - Collecting?: " + collecting);

                if (collecting == true)
                {
                    // Stop collecting before set datetime
                    stopCollecting();
                }

                updateDatetimeCounter();
            }
        }
        catch (Exception e)
        {
            
        }
    }


    private void updateDatetimeCounter ()
    {
        try
        {
            byte[] command = Diamond_ProtocolConstructor.sendDatetimeCounter();
            Diamond_Message response = read(command);
            response.checkError();
            response.checkCommand(response.getResponseString().getBytes(), command);
            Shared.println(device.information.name, "Datetime updated OK");
        }
        catch (Exception e)
        {
            e.printStackTrace();
            Shared.println(device.information.name, e);
        }
    }


    private void retrieveFilesDirectoryOld (Etd etdclone, DIAMOND_Directory directory, DIAMOND_LengthBinnedData lengthBinnedData, DIAMOND_SpeedBinnedData speedBinnedData) throws Exception
    {
        for (int i=0; i<directory.subdirectorios.length; i++)
        {
            try
            {
                DIAMOND_Subdirectory subdirectory = directory.subdirectorios[i];
                retrieveFileDataOld(etdclone, subdirectory.number, lengthBinnedData, speedBinnedData);
            }
            catch (Exception e)
            {
                e.printStackTrace();
            }
        }
    }


    private void retrieveFileDataOld (Etd etdclone, int number, DIAMOND_LengthBinnedData lengthBinnedData, DIAMOND_SpeedBinnedData speedBinnedData) throws Exception
    {
        byte[] command = Diamond_ProtocolConstructor.retrieveFileData(number);
        Diamond_Message response = read(command);
        response.checkError();
        response.checkCommand(response.getResponseString().getBytes(), command);

        // Response to Rxx command is Rxx %6x with file len to retrieve
        Diamond_Message message = new Diamond_Message();
        message.setData(response.getDataByte(), command);

        int filelen = message.get6X();

        byte[] NACK = Diamond_ProtocolConstructor.NACK();
        byte[] ACK = Diamond_ProtocolConstructor.ACK();
        byte[] XMODEMEND = Diamond_ProtocolConstructor.XMODEMEND();

        int downloaded = 0;
        int packetLen = 132;
        int[] filecontent = new int[filelen];
        Diamond_Message pck = read(NACK);
        do
        {
            if (pck.length() == packetLen)
            {
                System.arraycopy(pck.getDataInt(), 3, filecontent, downloaded, Math.min(pck.length() - 4, filecontent.length - downloaded));
                downloaded = downloaded + Math.min(pck.length() - 4, filecontent.length - downloaded);
                if (downloaded < filelen) pck = read(ACK);
            }
            else
            {
                pck = read(NACK);
            }
        }
        while(downloaded < filelen);

        read(XMODEMEND);

        DIAMOND_File file = new DIAMOND_File(filecontent);

        Diamond_ProtocolAnalyser.analyseRetrieveFileDataContent(this.device, etdclone, file, lengthBinnedData, speedBinnedData);
    }


    private void retrieveFileOpenData (Etd etdclone, DIAMOND_LengthBinnedData lengthBinnedData, DIAMOND_SpeedBinnedData speedBinnedData) throws Exception
    {
        long millis = System.currentTimeMillis();

        try
        {
            byte[] command = Diamond_ProtocolConstructor.retrieveFileOpenData();
            Diamond_Message response = read(command);
            response.checkError();
            response.checkCommand(response.getResponseString().getBytes(), command);

            // Response to Rxx command is Rxx %6x with file len to retrieve
            Diamond_Message message = new Diamond_Message();
            message.setData(response.getDataByte(), command);

            int filelen = message.get6X();
            Shared.println(device.information.name, "File len: " + filelen);

            byte[] NACK = Diamond_ProtocolConstructor.NACK();
            byte[] ACK = Diamond_ProtocolConstructor.ACK();
            byte[] XMODEMEND = Diamond_ProtocolConstructor.XMODEMEND();

            int downloaded = 0;
            int packetLen = 132;
            int[] filecontent = new int[filelen];
            Diamond_Message pck = read(NACK);
            do
            {
                if (pck.length() == packetLen)
                {
                    System.arraycopy(pck.getDataInt(), 3, filecontent, downloaded, Math.min(pck.length() - 4, filecontent.length - downloaded));
                    downloaded = downloaded + Math.min(pck.length() - 4, filecontent.length - downloaded);
                    if (downloaded < filelen) pck = read(ACK);
                }
                else
                {
                    pck = read(NACK);
                }
            }
            while(downloaded < filelen);

            read(XMODEMEND);

            Shared.println(device.information.name, "1.END DOWNLOADING FILE: " +  filelen + " - DIF: " + (System.currentTimeMillis()-millis));
            DIAMOND_File file = new DIAMOND_File(filecontent);

            boolean delete = Diamond_ProtocolAnalyser.analyseRetrieveFileDataContent(this.device, etdclone, file, lengthBinnedData, speedBinnedData);
            Shared.println(device.information.name, "2.END DOWNLOADING FILE: " +  filelen + " - DEL: " + delete + " - DIF: " + (System.currentTimeMillis()-millis));
            if (delete == true)
            {
                // Delete all files if return true, and is exact hour
                Calendar calendar = Calendar.getInstance();
                calendar.setTimeInMillis(System.currentTimeMillis());
                // if (TimeUtils.inperiod(etdclone.getDeviceInformation().period, 60000))
                Shared.println(device.information.name, "3.END DOWNLOADING FILE: " +  filelen + " - DEL: " + delete + " - DIF: " + (System.currentTimeMillis()-millis) + " - MIN: " + calendar.get(Calendar.MINUTE));
                if (calendar.get(Calendar.MINUTE) == 0)
                {
                    try
                    {
                        deleteAllFiles();
                        String msg = Shared.getMessage("Open file deleted correctly");
                        Shared.println(device.information.name, msg);
                    }
                    catch (Exception e)
                    {
                        Shared.println(device.information.name, e);
                    }
                }
            }
        }
        catch (Exception e)
        {
            offline(etdclone);
            Shared.println(device.information.name, e);
        }
    }


    private void deleteAllFiles () throws Exception
    {
        // VOLVER A ACTIVAR EL DELETE
        // VOLVER A ACTIVAR EL DELETE
        // VOLVER A ACTIVAR EL DELETE
        // VOLVER A ACTIVAR EL DELETE
        // VOLVER A ACTIVAR EL DELETE
        // VOLVER A ACTIVAR EL DELETE
        // VOLVER A ACTIVAR EL DELETE
        // VOLVER A ACTIVAR EL DELETE
//        byte[] command = Diamond_ProtocolConstructor.deleteAllFiles();
//        Diamond_Message response = read(command);
//        response.checkError();
//        response.checkCommand(response.getResponseString().getBytes(), command);
        byte[] command = Diamond_ProtocolConstructor.deleteFilesDate();
        Diamond_Message response = read(command);
        response.checkError();
        response.checkCommand(response.getResponseString().getBytes(), command);
    }




    private void updateVersion (Etd etdclone, String connectionString)
    {
        try
        {
            int index = connectionString.indexOf("PHO#");
            if (index < 0)
            {
                index = connectionString.indexOf("UNI#");
            }

            if (index > -1)
            {
                String sversion = connectionString.substring(index+4, index+7);
                int version = Integer.parseInt(sversion);
                float f = (float)(((float)version) / 100f);
                if ((etdclone.getDeviceInformation().firmwareVersion == null) || (etdclone.getDeviceInformation().firmwareVersion.length() == 0))
                    etdclone.getDeviceInformation().firmwareVersion = "" + f;
            }
        }
        catch (Exception e)
        {
            
        }
    }




    private void connect() 
    {
        try
        {
            if (this.socket != null)
            {
                if (this.connected == true)
                {
                    return;
                }
            }

            this.socket = new Socket(this.device.getDeviceInformation().connection.address, this.device.getDeviceInformation().connection.port);
            this.socket.setSoTimeout(this.device.getDeviceInformation().connection.timeout);
            this.is = this.socket.getInputStream();
            this.os = this.socket.getOutputStream();
            this.connected = true;

            if (status != DeviceStatus.STATUS_ONLINE)
            {
                String message = Shared.getMessage("Connected, address = %1, port = %2, timeout = %3");
                message = message.replace("%1", device.getDeviceInformation().connection.address);
                message = message.replace("%2", "" +device.getDeviceInformation().connection.port);
                message = message.replace("%3", "" + device.getDeviceInformation().connection.timeout);
                Shared.println(device.information.name, message);
                status = DeviceStatus.STATUS_ONLINE;
            }
            
        }
        catch (Exception e)
        {
            try{disconnect();} catch (Exception ex){};
        }
        
    }


    private void disconnect() throws Exception
    {
        try { is.close(); }catch (Exception e) {}
        try { os.close(); }catch (Exception e) {}
        try { socket.close(); }catch (Exception e) {}
        is = null;
        os = null;
        socket = null;
        this.connected = false;
    }
    

        
    private Diamond_Message read(byte[] command) throws Exception
    {
        try
        {
            if (command.length > 0) send(command);
            return receive();
        }
        catch (Exception e)
        {
            throw e;
        }
    }
     
    
    
    private void send(byte[] command) throws Exception
    {
        try
        {
            socket.getOutputStream().write(command);
            socket.getOutputStream().flush();
        }
        catch (Exception e)
        {
            disconnect();
            throw e;
        }
    }
    
    
    
    private Diamond_Message receive() throws Exception
    {
       boolean salir = false;
       int res = 0;
       byte[] trama = null;

       int longitud = 0;
       int apuntador = 0;

       try
       {
           while ((res = is.read()) == 0){sleep(10);};

           trama = new byte[65535];
           trama[apuntador] = (byte)res;
           apuntador++;
           res = is.read();

           while (true)
           {
                trama[apuntador] = (byte)res;
                apuntador++;
                res = is.read();
           }
       }
       catch (SocketTimeoutException e)
       {
           if (apuntador > 0)
           {
               longitud = apuntador;
           }
           else
               throw e;
       }
       catch (Exception e)
       {
          throw e;
       }

       byte[] resultado = new byte[longitud];
       System.arraycopy(trama, 0, resultado, 0, longitud);

       Diamond_Message message = new Diamond_Message();
       message.setData(resultado);
       return(message);
    }    


    private DIAMOND_SpeedBinnedData createSpeedBinTable() throws Exception
    {
//        if ((this.device.getIdentifier().equalsIgnoreCase("etd-wisznice-1") == false) &&
//            (this.device.getIdentifier().equalsIgnoreCase("etd-sławatycze-1") == false))
//        {
            DIAMOND_SpeedBinnedData speedBinnedData = new DIAMOND_SpeedBinnedData();
            speedBinnedData.numberOfBins = 17;  // 16;
            speedBinnedData.fileName = "POLONIA.SPD";  // "DEFAULTX.SPD";
            speedBinnedData.createBins();
            return speedBinnedData;
//        }

//        DIAMOND_SpeedBinnedData speedBinnedData = new DIAMOND_SpeedBinnedData();
//        speedBinnedData.numberOfBins = 16;
//        speedBinnedData.fileName = "DEFAULTX.SPD";
//        speedBinnedData.createBinsOld();
//        return speedBinnedData;
    }

}