MergeTask.java

package wf.util;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;

import javafx.beans.property.BooleanProperty;
import javafx.beans.property.SimpleBooleanProperty;
import javafx.concurrent.Task;
import wf.Main;

public class MergeTask extends Task<Object> {

    private final String WORK_DONE_LABEL_FORMAT = "%.1f";

    String FieldDelimiter = ",";
    private String selectedDirectory = "";
    private String selectedFileType = "";
    private String mask = "";
    private String maskedFileNumber = "";
    private String fileName = "";
    private String fileNameMergedData = "";

    private String line = "";

    private int filesToBeProcessed = 0;
    private int initialFileNumber = 0;
    private int current_file_number = 0;
    private int fileLines = 0;

    private int skipHeaderLines = 0;
    private int skipTailLines = 0;

    private int linesToBeProcessed = 0;
    private int linesCounter = 0;

    private List<String> selectedFileNames = new ArrayList<String>();
    //private List<String> selectedFileToBeLoaded = new ArrayList<String>();
    private List<String> fileNames = new ArrayList<String>();

    private List<String[]> tempData = new ArrayList<String[]>(); // it contains the merged data

    private String[] fields;
    private String[] values = new String[]{"", "", "", "", "", "", "", ""};

    private double workProgressPercent;

    //private boolean invertSign = true;
    private List<Boolean> invertSigns = new ArrayList<Boolean>(Arrays.asList(true, true, true, true));

    BooleanProperty processFailed = new SimpleBooleanProperty(false);

    private static final MergeTask INSTANCE = new MergeTask();

    public static MergeTask getInstance() {

        return INSTANCE;
    }

    @Override
    public Object call() throws Exception {

        return null;
    }


    public int getFilesToBeProcessed() {

        return filesToBeProcessed;
    }

    public void setSelectedDirectory(String value) {


        selectedDirectory = value;
    }

    public void setSelectedFiles(List<String> selectedFiles) {

        selectedFileNames = selectedFiles;
    }

    public void setSelectedFileType(String value) {


        selectedFileType = value;
    }

    public void setMask(String value) {

        mask = value;
    }

    public void setFilesToBeProcessed(int value) {

        filesToBeProcessed = value;
    }

    public void setInitialFileNumber(int value) {

        initialFileNumber = value;
    }

    public void setHeaderLines(int value) {

        skipHeaderLines = value;
    }

    public void setTailLines(int value) {

        skipTailLines = value;
    }

    public int getHeaderLines() {

        return skipHeaderLines;
    }

    public int getTailLines() {

        return skipTailLines;
    }

    public void invertSigns(List<Boolean> values) {

    	invertSigns = values;
    }

    private void processFile(int f, List<String> fileNames) {

        if(f == 0) {

            this.updateProgress(0, filesToBeProcessed);
            this.updateMessage("Merged, 0.0%");
        }

        //Get the file name not empty and use it to get the number of lines
        for(int i = 0; i < 4; i++) {

            if(fileNames.get(i) != "") {

                fileName = fileNames.get(i);
                break;
            }
        }

        fileLines = 0;

        BufferedReader br;

        //Get number of file lines of
        try {

            br = new BufferedReader(new FileReader(fileName));

            //String line;

            while ((line = br.readLine()) != null) {

                fileLines++;
            }

            br.close();

            linesToBeProcessed = fileLines - (getHeaderLines() + getTailLines());

            if((fileLines > 0) && (fileLines > getHeaderLines() + getTailLines())) {

            	mergeData(fileNames, linesToBeProcessed);

                writeMergedFile();

                //workProgressPercent = rn.round((((double) f+1 / (double) filesToBeProcessed) * 100), 1);
                workProgressPercent = (double) ((f+1) / (double) filesToBeProcessed) * 100;

                //System.out.println(workProgressPercent);

                this.updateProgress(f+1, filesToBeProcessed);
                this.updateMessage("Merged, "
                + String.format(WORK_DONE_LABEL_FORMAT, workProgressPercent) + "%");
            }

        } catch (FileNotFoundException ex) {

            Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);

            processFailed.setValue(true);

        } catch (IOException ex) {

            Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);

            processFailed.setValue(true);
        }

        /*

        //dispaly data
        for(int i = 0; i < linesToBeProcessed; i ++) {


        	 System.out.println("Event " + i + " " + tempData.get(i)[0] + " " + tempData.get(i)[1]
        			 + " " + tempData.get(i)[2] + " " + tempData.get(i)[3]
        					 + " " + tempData.get(i)[4] + " " + tempData.get(i)[5]							 + " " + tempData.get(i)[6] + " " + tempData.get(i)[7]);
        } */
    }

    public Task<Void> mergeDataFromFiles() {
        return new Task<Void>() {
            @Override
            protected Void call() throws InterruptedException {

                fileNames.clear();
                fileNames.add("");
                fileNames.add("");
                fileNames.add("");
                fileNames.add("");

                processFailed.setValue(false);

                 //case mask null or mask with digits
                if(mask == "") {

                    for(int f = 0; f < filesToBeProcessed; f++) {

                        current_file_number = f + initialFileNumber;

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

                            if(selectedFileNames.get(i) != "") {

                            	fileNames.set(i, selectedDirectory
                            			+ "/"
                            			+ selectedFileNames.get(i).substring(0, selectedFileNames.get(i).length()-(4))
                            			+ String.valueOf(current_file_number)
                            			+ "."
                            			+ selectedFileType);
                            }
                        }

                        processFile(f, selectedFileNames);
                    }

                } else {

                    for(int f = 0; f < filesToBeProcessed; f++) {

                        current_file_number = f + initialFileNumber;

                        maskedFileNumber = mask.substring(0, mask.length()
                        		- String.valueOf(current_file_number).length())
                        		+ String.valueOf(current_file_number);

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

                            if(selectedFileNames.get(i) != "") {

                            	fileNames.set(i, selectedDirectory
                            			+ "/"
                            			+ selectedFileNames.get(i).substring(0, selectedFileNames.get(i).length()-(4 + mask.length()))
                            			+ maskedFileNumber
                            			+ "."
                            			+ selectedFileType);
                            }
                        }

                        processFile(f, fileNames);
                    }
                }

                return null;
            }
        };
    }

    private void mergeData(List<String> fileNames, int fileLines) {

    	tempData.clear();
    	values[0] = "";
    	values[1] = "";
    	values[2] = "";
    	values[3] = "";
    	values[4] = "";
    	values[5] = "";
    	values[6] = "";
    	values[7] = "";

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

    		tempData.add(new String[]{"", "", "", "", "", "", "", ""});
    	}

    	//Loop through the channels
    	for(int i = 0; i < 4; i++) {

    		if(fileNames.get(i) != "") {

    			//read data in the file
    			BufferedReader br;

    			try {

    				br = new BufferedReader(new FileReader(fileNames.get(i)));

    				//Skip Header
    				for(int l = 0; l < getHeaderLines(); l++) {

    					br.readLine();
    				}

    				linesCounter = 0;

    				while (((line = br.readLine()) != null) && (linesCounter < fileLines)) {

    					fields = line.split(FieldDelimiter, -1);
    					//Invert sign of the signal if option selected
    					if(invertSigns.get(i)) {

    						fields[1] = String.valueOf((-1)*Double.parseDouble(fields[1]));
    					}

    					//get line data and update it
    					values = tempData.get(linesCounter);
    					values[i*2] = fields[0];
    					values[(i*2)+1] = fields[1];

    					tempData.set(linesCounter, values);

    					linesCounter++;
    				}

    				br.close();

    			} catch (FileNotFoundException ex) {

    				//Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);

    				processFailed.setValue(true);

    			} catch (IOException ex) {

    				//Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);

    				processFailed.setValue(true);
    			}

    		} else {


    			for(int j = 0; j < fileLines; j++) {

    				//get line data and update it
					values = tempData.get(j);
					values[i*2] = "0.0";
    				values[(i*2)+1] = "0.0";

					tempData.set(j, values);
    			}
    		}
    	}
    }

    public boolean getProcessFailed() {

        return processFailed.getValue();
    }

    private void writeMergedFile() {

    	fileNameMergedData = fileName.substring(0, fileName.lastIndexOf("/")+1)
    			+ "allCh_" + fileName.substring(fileName.lastIndexOf("/") + 3);

		/*- The idea to create bw inside try is because it closes the resources automatically in case of exception thrown or not */
		try (BufferedWriter bw = new BufferedWriter(new PrintWriter(fileNameMergedData))) {

			for(int l = 0; l< linesToBeProcessed; l++) {

				bw.write(tempData.get(l)[0] + "," + tempData.get(l)[1]
						+ "," + tempData.get(l)[2] + "," + tempData.get(l)[3]
	        			+ "," + tempData.get(l)[4] + "," + tempData.get(l)[5]
	        			+ "," + tempData.get(l)[6] + "," + tempData.get(l)[7]);
				bw.newLine();
			}

			processFailed.setValue(false);

			bw.flush();
			bw.close();

		} catch (final IOException e) {

			processFailed.setValue(true);
			//e.printStackTrace();
		}
    }
}