/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package pnandmd.Point1;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.FilenameFilter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Klasa tworzaca plik z siecia Petriego i kilka innych. Klasa czyta dane z
 * plikow pdb w folderze roboczym i na ich podstawie generuje siec.
 *
 * Dla kazdego atomu robi osobna siec!
 *
 * @author Ania
 */
public class TworzSiec2 {

    //czy pierwsze czytanie - wtedy tworzy nowe miejsca dla atomow
    private boolean pierCzyt;
    //czy nowy plik aby zrobic polaczenie z miejsca/atomu
    //numery miejsc z poprzedniego czytania - czy dodawac nowe miejsca
    private ArrayList aktMiejsca = new ArrayList();
    //numery aktualnych trnazycji ktore ostatnio ustawialy wspolrzedne
    private ArrayList aktTranz = new ArrayList();
    //1 z 3 plikow pozniej tworzacych plik sieci - z miejscami
    private BufferedWriter miejsca;
    //2 z 3 plikow pozniej tworzacych plik sieci - z tranzycjami
    private BufferedWriter tranz;
    //3 z 3 plikow pozniej tworzacych plik sieci - z lukami
    private BufferedWriter luki;
    //plik zawierajacy nazwy miejsc - czyli wspolrzedne ktore one reprezentuja
    private BufferedWriter mNazwy;
    private BufferedWriter tNazwy;
    //lista zawierajaca czasy od kotrych mozna odpalac tranzycje
    private ArrayList czTranz = new ArrayList();
    private BufferedWriter czasy;
    //plik zawierajacy ilosc wystapien danego atomu w danej wspolrzendej - trnazycje
    private BufferedWriter wystapienia;
    private ArrayList wys = new ArrayList();
    //pliki i lista zawierajace ilosc wystapien miejsca - tzn ile razy atom przy tworzeniu w nim by
    private BufferedWriter wystapieniaM;
    private ArrayList wysMiej = new ArrayList();

    //obiekt czytajacy pliki z pdb
    private CzytaniePdb czyt;
    //mapa zawierajaca jako klucze wsp a jako elementy numery miejsc, dla spr
    //czy dane miejsce juz wystepuje
    Map<String, Integer> mapaM = new HashMap<>();
    //mapa zwierajaca jako klucze miejsca we i wyj a jako elem numery tranz
    //dla spr czy dana tranzyja juz istnieje
    Map<String, Integer> mapaT = new HashMap<>();
    //czas aktulany - nr ramki
    private int czas;
    //katalog z plikami
    private File dir;
    //licznik ktore miejsce
    private int liczM = -1;
    //licznik ktora tranz
    private int liczT = -1;
    //licznik ktory luk
    private int liczL = -1;
    //plik z gotowa siecia
    private BufferedWriter siecGotowa;
    //ilosc atomow
    private int ilosc = 0;
    //pierwsze czytniae pliku
    private boolean pierPlik = false;

    private float oko;
    //ile jest miejsc z nr atomow + startowe
    private int przes;

    private File newDir;
    //lista list dla kazdej tranzycji w jakich plikach jest
    private List pliki = new ArrayList<>();
    private BufferedWriter wystapieniaPliki;

    private String fileName;

    /**
     * Konstuktor ktory przyjmuje jako katalok z plikami pdb roboczy katalog. Do
     * tego dokonuje inicjalizacji plikow, parametrow itd.
     */
    public TworzSiec2() {
        inicjacja();
        dir = new File(System.getProperty("user.dir"));
    }

    /**
     * Konstruktor ktorego argumentem jest katalog z plikami pdb. Do tego
     * dokonuje inicjalizacji plikow, parametrow itd.
     *
     * @param kat
     */
    public TworzSiec2(String kat, float p1) {
        dir = new File(kat);
        oko = p1;
        inicjacja();

    }

    private void inicjacja() {
        try {
            pierCzyt = true;
            czas = 0;
            newDir = new File("" + dir.getAbsolutePath() + File.separator + "alg1");
            newDir.mkdir();
            miejsca = new BufferedWriter(new FileWriter(new File("" + newDir.getAbsolutePath() + File.separator + "miejsca.tmp")));
            tranz = new BufferedWriter(new FileWriter(new File("" + newDir.getAbsolutePath() + File.separator + "tranz.tmp")));
            luki = new BufferedWriter(new FileWriter(new File("" + newDir.getAbsolutePath() + File.separator + "luki.tmp")));
            mNazwy = new BufferedWriter(new FileWriter(new File("" + newDir.getAbsolutePath() + File.separator + "mNazwy.txt")));
            wystapienia = new BufferedWriter(new FileWriter(new File("" + newDir.getAbsolutePath() + File.separator + "wystapienia.txt")));
            wystapieniaM = new BufferedWriter(new FileWriter(new File("" + newDir.getAbsolutePath() + File.separator + "wystapieniaM.txt")));
            wystapieniaPliki = new BufferedWriter(new FileWriter(new File("" + newDir.getAbsolutePath() + File.separator + "wystapieniaPliki.txt")));
            czasy = new BufferedWriter(new FileWriter(new File("" + newDir.getAbsolutePath() + File.separator + "czasy.txt")));
            tNazwy = new BufferedWriter(new FileWriter(new File("" + newDir.getAbsolutePath() + File.separator + "tNazwy.txt")));
            siecGotowa = new BufferedWriter(new FileWriter(new File("" + newDir.getAbsolutePath() + File.separator + "siecAlg1.apnn")));
            wystapienia.write("1");
            wystapienia.newLine();
        } catch (IOException ex) {
            Logger.getLogger(TworzSiec2.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    /**
     * Najwazniejsza metoda. W niej czytane sa kolejne pliki pdb z katalogu,
     * nastepnie dla kazdej klatki wywolywana jest metoda ktora dodaje
     * odpowiednie dane do plikow wynikowych.
     */
    public void tworzenie() {
        ArrayList wsp;
        Date date = new Date();
        System.out.println(date);
        FilenameFilter filtr = new FilenameFilter() {

            @Override
            public boolean accept(File dir, String name) {
                return (name.endsWith(".pdb"));
            }
        };
        String[] list = dir.list(filtr);
        int dl = list.length;
        boolean koniecP;
        for (int i = 0; i < dl; i++) {
            System.out.println("czytam plik: " + list[i]);
            fileName = list[i];
            czyt = new CzytaniePdb(list[i], dir, oko);
            czas = 0;
            pierPlik = true;
            do {
                wsp = czyt.zwrocWszystkie();
                czas = czyt.getKlatka();
                if (pierCzyt) {
                    oko = czyt.zwrocOko();
                    ilosc = wsp.size();
                    pierCzyt = false;
                    pierPlik = false;
                    pierCzytanie(wsp);
                } else if (pierPlik == true) {
                    pierPlik = false;
                    czytaniePierKlatki(wsp);
                } else {
                    if ((wsp != null) && (wsp.size() > 0)) {
                        kolejneCzyt(wsp);
                    }
                }
                koniecP = czyt.koniecPliku();
            } while (koniecP == false);
        }
        date = new Date();
        System.out.println(date);
    }

    /**
     * Metoda ktora wywolywana jest jesli czytamy pierwsza klatke nastepnego
     * pliku. Rozni sie tym od zwyklego dodawania ze laczy pierwsze miejsce z
     * atomem i miejsce start a nie z poprzednim polozeniem atomu. Zaznacza
     * rowniez ze to startowe polozenie jest aktualnym polozeniem atomu.
     *
     * @param wsp lista wspolrzednych z pliku
     */
    private void czytaniePierKlatki(ArrayList wsp) {
        int n = wsp.size();
        String klucz;
        double[] tab;
        int nrMiej, nrTr;
        boolean tworzTranz;
        int w;
        for (int i = 0; i < n; i++) {
            tworzTranz = false;
            tab = (double[]) wsp.get(i);
            klucz = "atom: " + (int) tab[0] + " : " + (tab[1] * oko) + "," + (tab[2] * oko) + "," + (tab[3] * oko);
            //System.out.println(klucz);
            if (!mapaM.containsKey(klucz)) {//nie ma miejsca, tworz nowe
                noweMiejsce(tab, false);
                nrMiej = liczM;
                tworzTranz = true;
            } else {//jest miejsce
                nrMiej = mapaM.get(klucz);
                w = (int) wysMiej.get(nrMiej - przes);
                wysMiej.set(nrMiej - przes, w + 1);
                klucz = "" + (int) tab[0] + "," + nrMiej;
                if (mapaT.containsKey(klucz)) {//jest juz tranzycja - juz zaczynalismy z tego
                    nrTr = mapaT.get(klucz);
                    //dodawanie do listy plikow w ktorych wystepuje
                    List<String> pom = (List<String>) pliki.get(nrTr);
                    if (!pom.contains(fileName)) {
                        pom.add(fileName);
                        pliki.set(nrTr, pom);
                    }
                    int oldWys = (int) wys.get(nrTr);
                    wys.set(nrTr, oldWys + 1);
                    aktTranz.set((int) tab[0], nrTr);
                } else {
                    tworzTranz = true;
                }
            }
            aktMiejsca.set((int) tab[0], nrMiej);
            if (tworzTranz == true) {//nie ma tranzycji, miejsce bylo lub utworzone
                nowaTranz(czas, (int) tab[0], nrMiej);
                aktTranz.set((int) tab[0], liczT);
                stworzPolaczenia((int) tab[0], nrMiej, liczT, (int) tab[0] + ilosc);
            }

        }
    }

    /**
     * Tworzy miejsca "startowe" - miejsca nie obrazujace wspolrzednych lecz
     * dodane sztucznie aby oznaczyc ze tranzycja przesuwa atom na pierwszwe
     * polozenie dla ktoregos z plikow.
     *
     * @param n ilosc atomow - tyle trzeba stworzyc nowych miejsc
     */
    private void dodajZerowe(int n) {
        //System.out.println(""+n);
        for (int i = 0; i < n; i++) {
            try {
                liczM++;
                miejsca.write("\\place{P_" + liczM + "}{\\name{p" + liczM + "}\\capacity{1}\\init{1}}");
                miejsca.newLine();
            } catch (IOException ex) {
                Logger.getLogger(TworzSiec2.class.getName()).log(Level.SEVERE, null, ex);
            }

        }
        przes = liczM + 1;
    }

    /**
     * Pierwsze czytanie wspolrzednych - pierwsza klatka pierwszego pliku.
     * Tworzenie miejsc dla atomow, miejsca startowych i pierwszych tranzycji.
     *
     * @param wsp lista wspolrzednych atomow
     */
    private void pierCzytanie(ArrayList wsp) {
        try {
            int n = wsp.size();
            //pierwsza petla tworzy tylko miejsca dla atomow
            for (int i = 0; i < n; i++) {
                liczM++;
                miejsca.write("\\place{P_" + liczM + "}{\\name{p" + liczM + "}\\capacity{1}\\init{1}}");
                miejsca.newLine();
            }
            ilosc = n;
            dodajZerowe(ilosc);
            double[] tab;
            for (int i = 0; i < n; i++) {
                tab = (double[]) wsp.get(i);
                aktMiejsca.add((int) tab[0], i);
                aktTranz.add((int) tab[0], i);
            }
            czytaniePierKlatki(wsp);
        } catch (IOException ex) {
            Logger.getLogger(TworzSiec2.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    private void kolejneCzyt(ArrayList wsp) {

        String klucz;
        double[] tab;
        boolean wystap;
        int n = wsp.size();
        int w;
        for (int i = 0; i < n; i++) {
            tab = (double[]) wsp.get(i);
            klucz = "atom: " + (int) tab[0] + " : " + (tab[1] * oko) + "," + (tab[2] * oko) + "," + (tab[3] * oko);
            wystap = mapaM.containsKey(klucz);
            if (wystap == false) {//nie ma miejsca takiego wiec na pewno nie ma tranz
                noweMiejsce(tab, false);
                nowaTranz2(czas, (int) tab[0]);
                stworzPolaczenia2((int) tab[0]);
                aktMiejsca.set((int) tab[0], liczM);
                aktTranz.set((int) tab[0], liczT);
            } else {//jest miejsce
                int popMiej = (int) aktMiejsca.get((int) tab[0]);
                int miejscePlik = mapaM.get(klucz);
                w = (int) wysMiej.get(miejscePlik - przes);
                wysMiej.set(miejscePlik - przes, w + 1);
                aktMiejsca.set((int) tab[0], miejscePlik);
                if (popMiej == miejscePlik) {//atom sie nie przesunal - stare i nowe miejsca rowne
                    /*int nrTranz = (int) aktTranz.get((int)tab[0]);
                     int oldCzas = (int) czTranz.get(nrTranz);
                     if(oldCzas > czas){
                     czTranz.set(nrTranz, czas);
                     }
                     int oldWys = (int) wys.get(nrTranz);
                     wys.set(nrTranz, oldWys + 1);*/
                } else {//atom sie przesunal
                    klucz = "" + (int) tab[0] + "," + miejscePlik + "," + popMiej;
                    wystap = mapaT.containsKey(klucz);
                    if (wystap == false) {//nie ma tranzycji przesuwajacej - nowe przesuniecie
                        nowaTranz3(czas, (int) tab[0], miejscePlik, popMiej);
                        stworzPolaczenia3((int) tab[0], miejscePlik, popMiej);
                        aktTranz.set((int) tab[0], liczT);
                    } else {//juz wczesniej przesunal sie na ta pozycje
                        int nrTranz = mapaT.get(klucz);
                        //dodawanie do listy plikow w ktorych wystepuje
                        List<String> pom = (List<String>) pliki.get(nrTranz);
                        if (!pom.contains(fileName)) {
                            pom.add(fileName);
                            pliki.set(nrTranz, pom);
                        }
                        int oldCzas = (int) czTranz.get(nrTranz);
                        if (oldCzas > czas) {
                            czTranz.set(nrTranz, czas);
                        }
                        int oldWys = (int) wys.get(nrTranz);
                        wys.set(nrTranz, oldWys + 1);
                        aktTranz.set((int) tab[0], nrTranz);
                    }
                }
            }
        }
    }

    /**
     * Metoda ktora tworzy nowe miejsce o wspolrzednych w tablicy. Tworzenie
     * miejsca obejmuje wpisanie do pliku z miejscami (ktory bedzie scalony jako
     * czesc pliku wynikowego), dodanie do HashMapy, wpisanie do pliku z nazwami
     * miejsc oraz zwiekszenie licznika miejsc. Moze tez ustawic zeton w
     * miejscu.
     *
     * @param tab tablica ktorej elemnty 1-3 zwieraja wspolrzedne
     * @param full czy miejsce ma byc pelne - 1 zeton, czy nie
     */
    private void noweMiejsce(double[] tab, boolean full) {
        try {
            liczM++;
            if (full == false) {
                miejsca.write("\\place{P_" + liczM + "}{\\name{p" + liczM + "}\\capacity{1}\\init{0}}");
            } else {
                miejsca.write("\\place{P_" + liczM + "}{\\name{p" + liczM + "}\\capacity{1}\\init{1}}");
            }
            miejsca.newLine();
            String klucz = "atom: " + (int) tab[0] + " : " + (tab[1] * oko) + "," + (tab[2] * oko) + "," + (tab[3] * oko);
            mapaM.put(klucz, liczM);
            wysMiej.add(liczM - przes, 1);
            mNazwy.write("p " + liczM + " : " + klucz);
            mNazwy.newLine();
        } catch (IOException ex) {
            Logger.getLogger(TworzSiec2.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    /**
     * Metoda ktora tworzy nowa tranzycje. Dopisuje ja do pliku z tranzycjami,
     * dodaje informacje do listy z czasami, zwieksza licznik, dodaje informacje
     * do HashMapy i pliku z opismi tranzycji. Miejscem we/wy - atomem ktorego
     * dotyczy tranzycja jest argument atom, drugim miejscem wyjsciowym
     * (wspolrzedna gdzie laduje atom) jest miejsce podane w argumencie. Metoda
     * ta wywolywana jest dla tworzenie tranzycji z miejsc startowych, gdzie nie
     * ma poprzedniego polozenia atomu.
     *
     * @param czas aktulany czas kiedy trnazycja sie pojawia
     * @param atom numer atomu ktorego dotyczy tranzycja
     * @param nrMiej nr miejsca do ktorego przesuniety jest atom
     */
    private void nowaTranz(int czas, int atom, int nrMiej) {
        try {
            liczT++;
            tranz.write("\\transition{T_" + liczT + "}{\\name{t" + liczT + "}}");
            tranz.newLine();
            czTranz.add(liczT, czas);
            wys.add(liczT, 1);
            mapaT.put("" + atom + "," + nrMiej, liczT);
            List<String> pomList = new ArrayList<>();
            pomList.add(fileName);
            pliki.add(liczT, pomList);
            tNazwy.write("t " + liczT + " : atom: " + atom + " , wsp do: p" + nrMiej);
            tNazwy.newLine();
        } catch (IOException ex) {
            Logger.getLogger(TworzSiec2.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    /**
     * Metoda ktora towrzy nowa tranzycje (dopisuje potrzebne rzeczy jak metoda
     * nowaTranz()), z ta roznica ze poza miejscem we/wy atomem i miejscem
     * wyjsciowym liczM dodaje kolejne miejsce wejsciowe - poprzednia
     * lokalizacje atomu.
     *
     * @param czas aktulany czas
     * @param atom numer atomu ktorego dotyczy tranzycja
     */
    private void nowaTranz2(int czas, int atom) {
        try {
            int popMiej = (int) aktMiejsca.get(atom);
            liczT++;
            tranz.write("\\transition{T_" + liczT + "}{\\name{t" + liczT + "}}");
            tranz.newLine();
            czTranz.add(liczT, czas);
            wys.add(liczT, 1);
            List<String> pomList = new ArrayList<>();
            pomList.add(fileName);
            pliki.add(liczT, pomList);
            mapaT.put("" + atom + "," + liczM + "," + popMiej, liczT);
            tNazwy.write("t " + liczT + " : atom: " + atom + " , wsp do: p" + liczM + " , wsp z: p" + popMiej);
            tNazwy.newLine();
        } catch (IOException ex) {
            Logger.getLogger(TworzSiec2.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    /**
     * Tworzy nowa trnazycje, ktora bedzie odpowiadac za przesuniecie atomu z
     * popMiej do miejscePlik (oba to numery miejsc). Dodaje odpowiednie
     * warotsci do plikow, map i list.
     *
     * @param czas aktulany czas
     * @param atom atom ktorego dotyczy przesuniecie
     * @param miejscePlik numer miejsca do ktorego przesuwany jest atom
     * @param popMiej numer miejsca z kotrego przesuwany jest atom
     */
    private void nowaTranz3(int czas, int atom, int miejscePlik, int popMiej) {
        try {
            liczT++;
            tranz.write("\\transition{T_" + liczT + "}{\\name{t" + liczT + "}}");
            tranz.newLine();
            czTranz.add(liczT, czas);
            wys.add(liczT, 1);
            List<String> pomList = new ArrayList<>();
            pomList.add(fileName);
            pliki.add(liczT, pomList);
            mapaT.put("" + atom + "," + miejscePlik + "," + popMiej, liczT);
            tNazwy.write("t " + liczT + " : atom: " + atom + " , wsp do: p" + miejscePlik + " , wsp z: p" + popMiej);
            tNazwy.newLine();
        } catch (IOException ex) {
            Logger.getLogger(TworzSiec2.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    /**
     * Tworzy polaczenia miedzy: nowo dodana tranzycja i miejscem z pliku (ze
     * atom przeszedl do tych wspolrzendych) nowo dodana tranzycja i atomem
     * ktorego dotyczy ta tranzycja (arg dla metody) atomem ktorego dotyczy ta
     * trnazycja i nowo dodana trnazycja miejscem bedacym poprzednia lokalizacja
     * atomu oraz nowo utworzona tranzycja
     *
     * @param atom nr atomu ktorego dotyczy ta trnazycja i jednoczenie nr
     * miejsca
     * @param miejscePlik mr miejsca do ktorego przesunal sie atom (wziete z
     * pliku)
     * @param popMiej nr poprzedniego miejsca w ktorym byl atom
     */
    private void stworzPolaczenia3(int atom, int miejscePlik, int popMiej) {
        try {
            liczL++;
            luki.write("\\arc{A_" + liczL + "}{\\from{P_" + atom + "} \\to{T_" + liczT + "} \\weight{1} \\type{ordinary}}");
            luki.newLine();
            liczL++;
            luki.write("\\arc{A_" + liczL + "}{\\from{T_" + liczT + "} \\to{P_" + atom + "} \\weight{1} \\type{ordinary}}");
            luki.newLine();
            liczL++;
            luki.write("\\arc{A_" + liczL + "}{\\from{T_" + liczT + "} \\to{P_" + miejscePlik + "} \\weight{1} \\type{ordinary}}");
            luki.newLine();
            liczL++;
            luki.write("\\arc{A_" + liczL + "}{\\from{P_" + popMiej + "} \\to{T_" + liczT + "} \\weight{1} \\type{ordinary}}");
            luki.newLine();
        } catch (IOException ex) {
            Logger.getLogger(TworzSiec2.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    /**
     * Tworzy polaczenia miedzy: nowo dodana tranzycja i nowo dodanym miejscem
     * (ze atom przeszedl do tych wspolrzendych) nowo dodana tranzycja i atomem
     * ktorego dotyczy ta tranzycja (arg dla metody) atomem ktorego dotyczy ta
     * trnazycja i nowo dodana trnazycja miejscem bedacym poprzednia lokalizacja
     * atomu oraz nowo utworzona tranzycja
     *
     * @param atom numer atomu ktorego dotyczy tranzycja
     */
    private void stworzPolaczenia2(int atom) {
        try {
            int popMiej = (int) aktMiejsca.get(atom);
            liczL++;
            luki.write("\\arc{A_" + liczL + "}{\\from{P_" + atom + "} \\to{T_" + liczT + "} \\weight{1} \\type{ordinary}}");
            luki.newLine();
            liczL++;
            luki.write("\\arc{A_" + liczL + "}{\\from{T_" + liczT + "} \\to{P_" + atom + "} \\weight{1} \\type{ordinary}}");
            luki.newLine();
            liczL++;
            luki.write("\\arc{A_" + liczL + "}{\\from{T_" + liczT + "} \\to{P_" + liczM + "} \\weight{1} \\type{ordinary}}");
            luki.newLine();
            liczL++;
            luki.write("\\arc{A_" + liczL + "}{\\from{P_" + popMiej + "} \\to{T_" + liczT + "} \\weight{1} \\type{ordinary}}");
            luki.newLine();
        } catch (IOException ex) {
            Logger.getLogger(TworzSiec2.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    /**
     * Tworzy polaczenia miedzy: tranzycja nrTranz i miejscem nrMiej (ze atom
     * przeszedl do tych wspolrzendych) tranzycja nrTranz i atomem ktorego
     * dotyczy ta tranzycja (arg dla metody) atomem ktorego dotyczy ta trnazycja
     * i tranzycjhja nrTanz miejscem startowym dla tego atomu i tranzycja
     * nrTranz
     *
     * Metoda wywolywana tylko przy czytaniu pierwszej klatki. Rozni sie tym ze
     * dodaje polaczenie tranzycji z miejscem startowym a nie poprzednim
     * polozeniem atomu.
     *
     * @param atom numer atomu ktorego dotyczy tranzycja
     * @param nrMiej miejsce okreslajece wspolrzedne gdzie laduje atom
     * @param nrTranz numer tranzycji wokol ktorej sa robione polaczeni
     * @param nrStart nr miejsca startowego dla danego atomu
     */
    private void stworzPolaczenia(int atom, int nrMiej, int nrTranz, int nrStart) {
        try {
            liczL++;
            luki.write("\\arc{A_" + liczL + "}{\\from{P_" + atom + "} \\to{T_" + nrTranz + "} \\weight{1} \\type{ordinary}}");
            luki.newLine();
            liczL++;
            luki.write("\\arc{A_" + liczL + "}{\\from{T_" + nrTranz + "} \\to{P_" + atom + "} \\weight{1} \\type{ordinary}}");
            luki.newLine();
            liczL++;
            luki.write("\\arc{A_" + liczL + "}{\\from{T_" + nrTranz + "} \\to{P_" + nrMiej + "} \\weight{1} \\type{ordinary}}");
            luki.newLine();
            liczL++;
            luki.write("\\arc{A_" + liczL + "}{\\from{P_" + nrStart + "} \\to{T_" + nrTranz + "} \\weight{1} \\type{ordinary}}");
            luki.newLine();
        } catch (IOException ex) {
            Logger.getLogger(TworzSiec2.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    private void przepisz(String name) {
        try {
            String line;
            try (BufferedReader br = new BufferedReader(new FileReader(name))) {
                while ((line = br.readLine()) != null) {
                    siecGotowa.write(line);
                    siecGotowa.newLine();
                }
                siecGotowa.newLine();
            }
        } catch (IOException ex) {
            Logger.getLogger(TworzSiec2.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    public void koniec() {
        try {
            miejsca.close();
            tranz.close();
            luki.close();
            tNazwy.close();
            mNazwy.close();
            siecGotowa.write("\\beginnet{unnamed3}");
            siecGotowa.newLine();
            siecGotowa.newLine();
            siecGotowa.newLine();
            przepisz("" + newDir.getAbsolutePath() + File.separator + "miejsca.tmp");
            przepisz("" + newDir.getAbsolutePath() + File.separator + "tranz.tmp");
            przepisz("" + newDir.getAbsolutePath() + File.separator + "luki.tmp");
            siecGotowa.newLine();
            siecGotowa.write("\\endnet");
            siecGotowa.newLine();
            siecGotowa.close();

            int n = wys.size();
            wystapienia.write("tranz: " + liczT + " miejsca: " + liczM + " przes: " + (ilosc * 2));
            wystapienia.newLine();
            for (int i = 0; i < n; i++) {
                wystapienia.write("t " + i + " wys: " + (int) wys.get(i));
                wystapienia.newLine();
            }
            wystapienia.close();

            n = wysMiej.size();
            wystapieniaM.write("tranz: " + liczT + " miejsca: " + liczM);
            wystapieniaM.newLine();
            for (int i = 0; i < n; i++) {
                wystapieniaM.write("m " + (przes + i) + " wys: " + (int) wysMiej.get(i));
                wystapieniaM.newLine();
            }
            wystapieniaM.close();

            n = czTranz.size();
            for (int i = 0; i < n; i++) {
                czasy.write("t " + i + " czas: " + (int) czTranz.get(i));
                czasy.newLine();
            }
            czasy.close();

            n = pliki.size();
            for (int i = 0; i < n; i++) {
                List<String> pom = (List<String>) pliki.get(i);
                wystapieniaPliki.write("t " + i + " plik: ");
                for (String napis : pom) {
                    wystapieniaPliki.write(napis + ", ");
                }
                wystapieniaPliki.newLine();
            }
            wystapieniaPliki.close();

            File plik = new File("" + newDir.getAbsolutePath() + File.separator + "miejsca.tmp");
            plik.delete();
            plik = new File("" + newDir.getAbsolutePath() + File.separator + "tranz.tmp");
            plik.delete();
            plik = new File("" + newDir.getAbsolutePath() + File.separator + "luki.tmp");
            plik.delete();

            tNazwy.close();
            mNazwy.close();

        } catch (IOException ex) {
            Logger.getLogger(TworzSiec2.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

}
