poved/src/data/BitmapBuilder.java @ d6da2d93

package data;

import gui.Window;

import java.io.BufferedWriter;
import java.io.File;
import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.*;

/**
 *
 * Trida prochazi seznam spoju, casovych kodu, linek a pevnych kodu a na jejich zaklade naplnuje a generuje bitmapy,
 * ktere zapisuje do vystupniho souboru
 *
 * @author  Daniel Stus, Marek Sobota, Lukas Scurko, Jan Jirman
 * @version 1.0
 *
 */
public class BitmapBuilder {

    //-------------- Atributy --------------/

    /** Seznam uchovavajici vsechny zaznamy souboru pevnykod.txt */
    private ArrayList<JDFPevnykodRecord> pevnykod = new ArrayList<>();

    /** Seznam uchovavajici vsechny zaznamy pozadovanych linek souboru caskody.txt */
    private ArrayList<JDFCaskodyRecord> caskody = new ArrayList<>();

    /** Seznam uchovavajici vsechny zaznamy pozadovanych linek souboru spoje.txt */
    private ArrayList<JDFSpojeRecord> spoje = new ArrayList<>();

    /** Seznam uchovavajici vsechny vygenerovane bitmapy */
    private ArrayList<Bitmap> bitmaps = new ArrayList<>();

    /** Seznam uchovavajici vsechny uzivatelem zadane linky pro generaci */
    private List<String> lineList;

    /** Seznam uchovavajici vsechny uzivatelem zadane neuplne linky pro generaci */
    private List<String> pseudoLines;

    /** Cesta k vystupnimu souboru pro vypis vygenerovanych bitmap */
    private Path outputFile;

    /** Instance GUI pro vypis kontrolnich zprav */
    private Window window;


    //-------------- Konstruktor -------------/


    /**
     * Konstruktor, prebira instanci okna pro vypisy, vytvari a kontroluje vystupni soubor
     *
     * @param window Instance tridy pro vypisy
     * @param outputPath Cesta k vystupnimu souboru
     */
    public BitmapBuilder(Window window, File outputPath){
    	this.window = window;
    	window.printMessage("Vytvořen BitmapBuilder");

    	// Vytvoření výstupního souboru
    	this.outputFile = outputPath.toPath();
        try {
            if (Files.notExists(outputFile)) {
                Files.createFile(outputFile);
                window.printMessage("Vytvořen soubor: "+outputFile.toString());
            }
            else {
                window.printMessage("Výstupní soubor již existuje, přepisuji...");
                Files.deleteIfExists(outputFile);
                Files.createFile(outputFile);
            }

        } catch (IOException e) {
            e.printStackTrace();
            window.printMessage("Neočekávaná chyba při práci s výstupním souborem");
        }
    }

    //----------------- Metody ----------------/

    /**
     * Metoda naplni seznam pevnych kodu
     *
     * @param loadedData kompletni nactena dana souboru pevnykod
     */
    public void getPevnyKod(ArrayList<String[]> loadedData){
        JDFPevnykodRecord pevnykodRecord;
        for(String[] record : loadedData){
                pevnykodRecord = new JDFPevnykodRecord(record);
                pevnykod.add(pevnykodRecord);
        }
        window.printMessage("Načten soubor Pevnykod.txt");
    }

    /**
     * Metoda naplni seznam caskody, vsemi zaznamy odpovidajicih pozadovanym linkam a caskodum s numerickou hodnotou
     *
     * @param loadedData kompletni nactena dana souboru caskody
     */
    public void getCaskody(ArrayList<String[]> loadedData){
        JDFCaskodyRecord caskodyRecord;
        for(String[] record : loadedData){
            if (lineList.contains(record[0]) && record[4].matches("\\d+")) {
                caskodyRecord = new JDFCaskodyRecord(record);
                caskody.add(caskodyRecord);
            }
        }
        window.printMessage("Načteny požadované linky ze souboru Caskody.txt");
    }

    /**
     * Metoda naplni seznam spoju, vsemi zaznamy odpovidajicih pozadovanym linkam
     *
     * @param loadedData kompletni nactena dana souboru spoje
     */
    public void getSpoje(ArrayList<String[]> loadedData){
        JDFSpojeRecord spojeRecord;
        for(String[] record : loadedData){
            if (lineList.contains(record[0])) {
                spojeRecord = new JDFSpojeRecord(record);
                spoje.add(spojeRecord);
            }
        }
        window.printMessage("Načteny požadované linky ze souboru Spoje.txt");
    }

    /**
     * Naplni seznam uzivatelsky zadanych linek
     *
     * @param lineList seznam uzivatelskych linek
     * @return true - pokud se podarilo naplnit seznam
     *          false - pokud se nepodarilo naplnit seznam
     */
    public boolean initLineList(List[] lineList){
        this.lineList = lineList[0];
        this.pseudoLines = lineList[1];
        window.printMessage("Načten uživatelský seznam linek");
        window.printMessage("Nalezené linky: "+this.lineList);
        if(this.lineList.size() < 1){
        	window.printMessage("Seznam linek je prázdný!");
        	return false;
        }

        if(this.pseudoLines.size() > 0) {
            window.printMessage("Načten uživatelský seznam pseudo linek");
            window.printMessage("Nalezené pseudo linky: "+pseudoLines);
        }
        return true;

    }


    /**
     * Metoda overi jestli je obdobi casoveho omezeni spada do obdobi pro generovanou bitmapu
     *
     * @param dateFrom pocatek generovaneho obdobi bitmapy
     * @param dateTo konec generovaneho obdobi bitmapy
     * @param dateFromHardCode pocatek obdobi caskoveho omezeni
     * @param dateToHardCode konec obdobi casoveho omezeni
     * @return Vrati {@code true} pokud casove omezeni spada do odobi generavaneho bitmapou, {@code false} pokud casove omezeni nespada do obdobi generovaneho bitmapou
     */
    public boolean isInRange(LocalDate dateFrom, LocalDate dateTo, String dateFromHardCode, String dateToHardCode) {
        //Formát datumu v Caskody.txt např: - 09022018
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("ddMMyyyy");

        LocalDate hardCodeDateFrom;
        LocalDate hardCodeDateTo;

            //Naparsuj pouze pokud datum do existuje
            if (!dateToHardCode.equals("")) {
                hardCodeDateFrom = LocalDate.parse(dateFromHardCode, formatter);
                hardCodeDateTo = LocalDate.parse(dateToHardCode, formatter);

                if (hardCodeDateFrom.isBefore(dateFrom) && hardCodeDateTo.isAfter(dateTo)) {
                    return true;
                }

                if (!hardCodeDateFrom.isBefore(dateFrom) && !hardCodeDateTo.isAfter(dateTo)) {
                    return true;
                }

                if (hardCodeDateFrom.isBefore(dateFrom) && !hardCodeDateTo.isAfter(dateTo) && hardCodeDateTo.isAfter(dateFrom)) {
                    return true;
                }

                if (hardCodeDateFrom.isAfter(dateFrom) && hardCodeDateTo.isAfter(dateTo) && !hardCodeDateFrom.isAfter(dateTo)) {
                    return true;
                }

            }

            //Pokud se jedná pouze o jeden den
            else {
                hardCodeDateFrom = LocalDate.parse(dateFromHardCode, formatter);

                if (!hardCodeDateFrom.isBefore(dateFrom) && !hardCodeDateFrom.isAfter(dateTo)) {
                    return true;
                }

            }

        return false;

    }

    /**
     * Metoda orizne, nastavi a vrati obdobi pro casove omezeni, tak aby spadalo do obdobi generavaneho bitmapou, pro naplneni
     *
     * @param dateFrom pocatek generovaneho obdobi bitmapy
     * @param dateTo konec generovaneho obdobi bitmapy
     * @param dateFromHardCode pocatek obdobi casoveho omezeni
     * @param dateToHardCode konec obdobi casoveho omezeni
     * @return pole s pocatkem a koncem obdobi casoveho omezeni, index 0 -> pocatek, index 1 -> konec
     */
    private LocalDate[] setHardCodeRange(LocalDate dateFrom, LocalDate dateTo, String dateFromHardCode, String dateToHardCode) {
        //Formát datumu v Caskody.txt např: - 09022018
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("ddMMyyyy");

        LocalDate[] hardCodeRange = new LocalDate[2];
        LocalDate hardCodeDateFrom;
        LocalDate hardCodeDateTo;

            //Naparsuj pouze pokud datum existuje
            if (!dateToHardCode.equals("")) {
                hardCodeDateFrom = LocalDate.parse(dateFromHardCode, formatter);
                hardCodeDateTo = LocalDate.parse(dateToHardCode, formatter);


                if (!hardCodeDateFrom.isBefore(dateFrom) && !hardCodeDateFrom.isAfter(dateTo)) {
                    hardCodeRange[0] = hardCodeDateFrom;
                }
                else hardCodeRange[0] = dateFrom;

                if (!hardCodeDateTo.isAfter(dateTo) && !hardCodeDateTo.isBefore(dateFrom)) {
                    hardCodeRange[1] = hardCodeDateTo;
                }
                else hardCodeRange[1] = dateTo;

            }

            //Existuje vždy
            else {
                hardCodeDateFrom = LocalDate.parse(dateFromHardCode, formatter);
                hardCodeRange[0] = hardCodeDateFrom;
                hardCodeRange[1] = null;
            }

            return hardCodeRange;

        }

    /**
     * Metoda overi zda-li zadany retezec odpovida cislene hodnote
     *
     * @param inputData retezec pro overeni
     * @return Vrati {@code true} pokud je retezec cislem, v opacnem pripade vrati {@code false}
     */
    private static boolean isNumeric(String inputData) {
        return inputData.matches("[-+]?\\d+(\\.\\d+)?");
    }


    /**
     * Zavola prislusne metody bitmapy pro naplneni podle casoveho kodu
     *
     * @param bitmap bitmapa pro naplneni
     * @param dateFrom pocatek obdobi pro naplneni
     * @param dateTo konec obdobi pro naplneni
     * @param TimeCodeType cislo casoveho kodu
     */
    private void fillBitmap (Bitmap bitmap, LocalDate dateFrom, LocalDate dateTo, int TimeCodeType) {

        switch (TimeCodeType) {
            case 1: {
                if (dateTo!=null) bitmap.setHardCodeDays(dateFrom, dateTo, 1);
                else bitmap.setDay(dateFrom, 1);
                break;
            }
            case 2: {
                bitmap.setHardCodeDays(bitmap.getDateFrom(), bitmap.getDateTo(), 1);
                if (dateTo!=null) bitmap.setDaysInRange(dateFrom, dateTo, 1);
                else bitmap.setDay(dateFrom, 1);
                break;
            }
            case 3: {
                bitmap.setDay(dateFrom, 1);
                break;
            }
            case 4: {
                bitmap.setHardCodeDays(bitmap.getDateFrom(), bitmap.getDateTo(), 1);
                if (dateTo!=null) bitmap.unsetDaysInRange(dateFrom, dateTo);
                else bitmap.setDay(dateFrom, 0);
                break;
            }
            case 5: {
                bitmap.setHardCodeWeeks(1, 1);
                break;
            }
            case 6: {
                bitmap.setHardCodeWeeks(1, 0);
                break;
            }
            case 7: {
                bitmap.setHardCodeWeeksInRange(dateFrom, dateTo, 1, 1);
                break;
            }
            case 8: {
                bitmap.setHardCodeWeeksInRange(dateFrom, dateTo, 1, 0);
                break;
            }
            default: break;
        }

    }

    /**
     * Vygeneruje, naplni a prida do vysledneho seznamu vsechny pseudo bitmapy
     *
     * @param dateFrom pocatek obdobi pro bitmapu
     * @param dateTo konec obdobi pro bitmapu
     */
    public void generatePseudoBitmaps(LocalDate dateFrom, LocalDate dateTo) {

        for (String psLine : pseudoLines) {

            window.printMessage("Zpracovávám pseudo linku: "+psLine);

            LocalDate[] hardCodeRange;
            String[] plRecord = psLine.split("-", 2);
            Bitmap generatedBitmap = new Bitmap(dateFrom, dateTo, "000000", "0", plRecord[0], plRecord[1], "0");

            //Pokud nemá žádné časové omezení a žádný pevnýkód -> naplň jedničkami
            if (plRecord[0].equals("00") && plRecord[1].length() == 0) {
                generatedBitmap.fillWithOnes();
                bitmaps.add(generatedBitmap);
                continue;
            }

            //Pokud nemá spoj žádná omezení -> napln bitmapu podle pevnych kodu a přidej
            else if (plRecord[0].equals("00") && plRecord[1].length() > 0) {
                generatedBitmap.setHardCodeDays(dateFrom, dateTo, 1);
                bitmaps.add(generatedBitmap);
                continue;
            }

            else {
                for (JDFCaskodyRecord caskod : caskody) {
                    if (caskod.getTimeCode().equals(plRecord[0])) {
                        if (isInRange(dateFrom, dateTo, caskod.getStartDate(), caskod.getEndDate())) {
                            hardCodeRange = setHardCodeRange(dateFrom, dateTo, caskod.getStartDate(), caskod.getEndDate());
                            fillBitmap(generatedBitmap, hardCodeRange[0], hardCodeRange[1], Integer.parseInt(caskod.getTypeTimeCode()));
                        }
                    }
                }
            }


            //Jinak bitmapa byla již naplněna -> přidej
                bitmaps.add(generatedBitmap);


        }
    }

    /**
     * Metoda projde seznamy spoju, caskodu, pevnychkodu a linek na jejichz zaklade vygeneruje a naplni bitmapy v zadanem obdobi
     * vysledne bitmapy vypise v pozadovanem formatu do vystupniho souboru
     *
     * @param dateFrom pocatek obdobi pro bitmapu
     * @param dateTo konec obdobi pro bitmapu
     */
    public void writeBitmaps(LocalDate dateFrom, LocalDate dateTo) {
        
        try(BufferedWriter writer = Files.newBufferedWriter(outputFile, Charset.defaultCharset(), StandardOpenOption.APPEND)) {
            DateTimeFormatter format = DateTimeFormatter.ofPattern("d.M.yyyy");
            String currentLine =  spoje.get(0).getNumberLine();
            String currentTimeCode;
            String previousTimeCode;
            LocalDate[] hardCodeRange;

            //Výpis období do výstupního souboru, ve formátu: Období;dateFrom(d.M.yyyy);dateTo(d.M.yyyy)
            writer.write("Období;" + dateFrom.format(format)+ ";" + dateTo.format(format) + "\r\n\r\n");

            window.printMessage("Zpracovávám bitmapy...");
            window.printMessage("Zpracovávám linku: "+currentLine);


            //Pro každý spoj
            for (JDFSpojeRecord spoj : spoje) {
                currentTimeCode = "00";

                //Pokud se jedná o novou linku - Vypiš _______ ??? (Je potřeba) ???
                if (!currentLine.equals(spoj.getNumberLine())) {
                    currentLine = spoj.getNumberLine();
                    window.printMessage("Zpracovávám linku: "+currentLine);
                }

                //Výpis právě prozkoumávaného spoje
                String currentJoin = spoj.getNumberJoin();
                window.printMessage("- spoj: "+currentJoin);

                Bitmap generatedBitmap = new Bitmap(dateFrom, dateTo, currentLine, currentJoin, currentTimeCode, spoj.hardCodesToString(pevnykod), spoj.getNumberLineVersion());
                int viableTimeCodes = 0; //Počet časových kódu číslo 3 daného spoje
                int timeCodesInRange = 0; //Počet časových kódu aplikovaných na spoj

                previousTimeCode = "";

                for (JDFCaskodyRecord caskod : caskody) {


                    // Zda se jedná o aktuálně zkoumanou linku a spoj
                    if (currentLine.equals(caskod.getNumberLine()) && currentJoin.equals(caskod.getNumberJoin())) {

                        currentTimeCode =  caskod.getTimeCode();
                        generatedBitmap.setTimeCode(currentTimeCode);

                        if(caskod.getTypeTimeCode().matches("1|3|7|8")) viableTimeCodes++;

                        // Pokud se jedná o stejný spoj, ale jiný časový kód vytvoř novou bitmapu a přidej předchozí
                        if (!currentTimeCode.equals(previousTimeCode) && isNumeric(currentTimeCode) && !previousTimeCode.equals("")) {
                            bitmaps.add(generatedBitmap);
                            generatedBitmap = new Bitmap(dateFrom, dateTo, currentLine, currentJoin, currentTimeCode, spoj.hardCodesToString(pevnykod), spoj.getNumberLineVersion());
                        }


                         //Pokud je zkoumaný časový kód v rozsahu bitmapy
                        if (isInRange(dateFrom, dateTo, caskod.getStartDate(), caskod.getEndDate())) {
                            timeCodesInRange++;
                            hardCodeRange = setHardCodeRange(dateFrom, dateTo, caskod.getStartDate(), caskod.getEndDate());
                            fillBitmap(generatedBitmap, hardCodeRange[0], hardCodeRange[1], Integer.parseInt(caskod.getTypeTimeCode()));
                        }

                        previousTimeCode = currentTimeCode;
                    }
                }



                //Pokud nemá žádné časové omezení a žádný pevnýkód -> naplň jedničkami
                if (timeCodesInRange == 0 && spoj.getHardCodes().size() == 0 && viableTimeCodes == 0) {
                    generatedBitmap.fillWithOnes();
                    bitmaps.add(generatedBitmap);
                }

                //Pokud nemá spoj žádná omezení -> napln bitmapu podle pevnych kodu a přidej
                else if (timeCodesInRange == 0 && spoj.getHardCodes().size() > 0 && viableTimeCodes == 0) {
                    generatedBitmap.setHardCodeDays(dateFrom, dateTo, 1);
                    bitmaps.add(generatedBitmap);
                }

                //Jinak bitmapa byla již naplněna -> přidej
                else {
                    bitmaps.add(generatedBitmap);
                }
            }

                //Pokud existují nějaké pseudolinky -> naplň a přidej do seznamu generovaných bitmap
                if(pseudoLines.size() > 0) {
                    generatePseudoBitmaps(dateFrom, dateTo);
                }

                //Odstraň duplikátní bitmapy
                removeDuplicates();

                //Seřaď seznam bitmap
                Collections.sort(bitmaps);

                //Celkový počet vygenerovaných bitmap
                window.printMessage("Celkem vygenerováno: "+bitmaps.size()+" Bitmap");

                //Vypiš bitmapy do souboru
            for (Bitmap bitmap : bitmaps) {
                writer.write(bitmap.toString()+"\r\n");
            }


        } catch (IOException e) {
            e.printStackTrace();
            window.printMessage("Neočekávaná chyba při zapisování bitmapy");
        }
        window.printMessage("Bitmapy úspěšně zapsány");
    }

    /**
     * Odstraní duplikatni bitmapy
     */
    public void removeDuplicates() {
        Set<Bitmap> bitmapsWODuplicates = new TreeSet<>();
        bitmapsWODuplicates.addAll(this.bitmaps);
        this.bitmaps = new ArrayList<>(bitmapsWODuplicates);

    }

    /**
     * Vrati seznam uzivatelskych linek pro generovani
     *
     * @return seznam uzivatelskych linek pro generovani
     */
    public List<String> getLineList() {
        return lineList;
    }

    /**
     * Nastavi seznam uzivatelskych linek na hodnotu {@code lineList}
     *
     * @param lineList seznam uzivatelskych linek
     */
    public void setLineList(List<String> lineList) {
        this.lineList = lineList;
    }

    /**
     * Vrati cestu k vystupnimu souboru
     *
     * @return cesta k vystupnimu souboru
     */
    public Path getOutputFile() {
        return outputFile;
    }

    /**
     * Nastavi cestu vystupniho souboru na hodnut {@code outputFile}
     *
     * @param outputFile cesta vystupniho souboru
     */
    public void setOutputFile(Path outputFile) {
        this.outputFile = outputFile;
    }
}