package pl.wat.ms4ds.terenfunkcje.nmt;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import pl.wat.ms4ds.terenfunkcje.*;
import pl.wat.ms4ds.terenfunkcje.konwersja.CoordUtils;
import pl.wat.ms4ds.terenfunkcje.konwersja.PUWGCoord;

import java.io.*;
import java.nio.file.FileSystemException;
import java.util.HashMap;
import java.util.Set;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;

public class NMTReader {

    private static final Logger logger = LoggerFactory.getLogger(NMTReader.class);


    static void main(String[] args) {
//        File dir = new File(System.getProperty("user.home") + "/nmt/gugik_SkorowidzNMT2018.gml");

        int i = 0;
        String inDir = "C:/Workspace/nmt/gugik_1m/asc/";
        String outDir = "C:/Workspace/nmt/unzipped/";
        String testFn = "D:\\Work\\73771_1025306_NMT-M348Dc41.xyz\\";
//        String testFn = "C:\\Workspace\\nmt\\M-33-7-A-c-3-2.asc";
        try {
//            readFromFileASC(testFn);
            readFromFileXYZ(testFn);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
//        renameFiles(inDir, inDir);

        Set<String> files = NMTDataProvider.listFiles(inDir);
        for (String file : files) {
            try {
                String unzipfn = unzipFile(inDir + file, outDir);
                if (unzipfn.endsWith(".asc")) {
                    readFromFileASC(outDir + unzipfn);
                } else if (unzipfn.endsWith(".xyz")) {
                    readFromFileXYZ(outDir + unzipfn);
                }
            } catch (IOException e) {

            }
        }

    }

    static void renameFiles(String inDir, String outDir) {
        try {
            Set<String> fileNames = NMTDataProvider.listFiles(inDir);
            for (String fn : fileNames) {
                String fn1 = fn.substring(0, fn.lastIndexOf("-") + 1);
                String fn2 = fn.substring(fn.lastIndexOf("-") + 1, fn.indexOf("."));
                String ext = fn.substring(fn.indexOf("."));
                int pos;
                if (fn2.length() == 5) {
                    pos = 1;
                } else if (fn2.length() == 6) {
                    pos = 2;
                } else {
                    //if (fn2.length() == 7)
                    pos = 3;
                }
                String fn3 = fn2.substring(0, pos);
                String fn4 = fn2.substring(pos, pos + 1);
                String fn5 = fn2.substring(pos + 1, pos + 2);
                String fn6 = fn2.substring(pos + 2, pos + 3);
                String fn7 = fn2.substring(pos + 3, pos + 4);
                String nfn = fn1 + fn3 + '-' + fn4 + '-' + fn5 + '-' + fn6 + '-' + fn7;
                File fileToMove = new File(inDir + fn);
                boolean isMoved = fileToMove.renameTo(new File(outDir + nfn + ext));
                if (!isMoved) {
                    throw new FileSystemException(outDir + fileToMove);
                }
                System.out.println(nfn);

            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    private static void readFromFileASC(String fn) throws IOException {
        long start = System.currentTimeMillis();
        File file = new File(fn);
        InputStream inputStream = new FileInputStream(file);
        try (BufferedReader br = new BufferedReader(new InputStreamReader(inputStream))) {
            String line = br.readLine();
            String[] split = line.split(" ");
            int ncols = Integer.parseInt(split[1]);
            line = br.readLine();
            split = line.split(" ");
            int nrows = Integer.parseInt(split[1]);
            line = br.readLine();
            split = line.split(" ");
            double xll = Double.parseDouble(split[1]);
            line = br.readLine();
            split = line.split(" ");
            double yll = Double.parseDouble(split[1]);
            line = br.readLine();
            split = line.split(" ");
            double cellsize = Double.parseDouble(split[1]);
            line = br.readLine();
            split = line.split(" ");
            double nodata = Double.parseDouble(split[1]);
            double[][] data = new double[nrows][ncols];
            for (int i = nrows - 1; i >= 0; i--) {
                line = br.readLine();
                split = line.split(" ");
                for (int j = 0; j < ncols; j++) {
                    data[i][j] = Double.parseDouble(split[j]);
                }
            }
            GeoCoord geo_ll = new GeoCoord();
            CoordUtils.convertPUWG1992ToWGS84(yll, xll, geo_ll);
            GeoCoord geo_ur = new GeoCoord();
            CoordUtils.convertPUWG1992ToWGS84(yll + nrows + cellsize, xll + ncols * cellsize, geo_ur);
            int d_x = (int) ((geo_ur.lon - geo_ll.lon) / MapConsts.DELTA_X) + 3;
            int d_y = (int) ((geo_ur.lat - geo_ll.lat) / MapConsts.DELTA_Y) + 3;
            Square[][] kwadraty = new Square[d_x][d_y];
            final int x = GridCoord.zamienDlugoscGeoNaIdKwadratuX(geo_ll.lon);
            final int y = GridCoord.zamienSzerokoscGeoNaIdKwadratuY(geo_ll.lat);
            kwadraty[0][0] = new Square();

//            Kwadrat kw = Teren.getKwadrat(x, y);
            // Wyznacz współrzędne geo środka kwadratu.
            GeoCoord geoCoord = new GeoCoord();
            geoCoord.lon = GridCoord.zamienIdKwadratuXNaDlugoscGeo(x);
            geoCoord.lat = GridCoord.zamienIdKwadratuYNaSzerokoscGeo(y);
            PUWGCoord puwgCoord = new PUWGCoord();
            // Wyznacz współrzędne PUWG lewego dolnego rogu kwadratu.
            CoordUtils.convertWGS84ToPUWG1992(geoCoord.lat - MapConsts.DELTA_Y / 2, geoCoord.lon - MapConsts.DELTA_X / 2, puwgCoord);
            kwadraty[0][0].ell = (int) puwgCoord.easting;
            kwadraty[0][0].nll = (int) puwgCoord.northing;
            // Wyznacz współrzędne PUWG prawego górnego rogu kwadratu.
            CoordUtils.convertWGS84ToPUWG1992(geoCoord.lat + MapConsts.DELTA_Y / 2, geoCoord.lon + MapConsts.DELTA_X / 2, puwgCoord);
            kwadraty[0][0].eur = (int) puwgCoord.easting;
            kwadraty[0][0].nur = (int) puwgCoord.northing;
            double dyy = 0;
            double h;
            int idX = 0;
            int idY = 0;
//            HashMap<Kwadrat, Kwadrat> kws = new HashMap();
            for (int i = 0; i < nrows; i++) {
                double yy = yll + dyy;
                dyy += cellsize;
                // Reset współrzędnej X na gridzie (siatce).
                idX = 0;
                if (yy >= kwadraty[idX][idY].nur) {
                    // Przekracza zakres współrzędnych pionowych, zatem kolejny/sąsiedni kwadrat po osi OY.
                    idY++;
                    if (kwadraty[idX][idY] == null) {
                        kwadraty[idX][idY] = new Square();
                    }
//                    kw = Teren.getKwadrat(idX, idY);
                    if (kwadraty[idX][idY].nur == 0) {
                        // Świeży kwadrat.
                        // Wyznacz współrzędne geo środka kwadratu.
                        geoCoord.lon = GridCoord.zamienIdKwadratuXNaDlugoscGeo(idX + x);
                        geoCoord.lat = GridCoord.zamienIdKwadratuYNaSzerokoscGeo(idY + y);
                        // Wyznacz współrzędne PUWG prawego górnego rogu kwadratu.
                        CoordUtils.convertWGS84ToPUWG1992(geoCoord.lat + MapConsts.DELTA_Y / 2, geoCoord.lon + MapConsts.DELTA_X / 2, puwgCoord);
                        kwadraty[idX][idY].eur = (int) puwgCoord.easting;
                        kwadraty[idX][idY].nur = (int) puwgCoord.northing;
                    }
                }
                double dxx = 0;
                for (int j = 0; j < ncols; j++) {
                    double xx = xll + dxx;
                    dxx += cellsize;
                    if (xx >= kwadraty[idX][idY].eur) {
                        // Przekracza zakres współrzędnych poziomych, zatem kolejny/sąsiedni kwadrat po osi OX.
                        idX++;
                        if (kwadraty[idX][idY] == null) {
                            kwadraty[idX][idY] = new Square();
                        }
//                        kw = Teren.getKwadrat(idX, idY);
                        if (kwadraty[idX][idY].eur == 0) {
                            // Świeży kwadrat.
                            // Wyznacz współrzędne geo środka kwadratu.
                            geoCoord.lon = GridCoord.zamienIdKwadratuXNaDlugoscGeo(idX + x);
                            geoCoord.lat = GridCoord.zamienIdKwadratuYNaSzerokoscGeo(idY + y);
                            // Wyznacz współrzędne PUWG prawego górnego rogu kwadratu.
                            CoordUtils.convertWGS84ToPUWG1992(geoCoord.lat + MapConsts.DELTA_Y / 2, geoCoord.lon + MapConsts.DELTA_X / 2, puwgCoord);
                            kwadraty[idX][idY].eur = (int) puwgCoord.easting;
                            kwadraty[idX][idY].nur = (int) puwgCoord.northing;
                        }
                    } else if (xx < kwadraty[idX][idY].ell) {
                        idX--;
                    }

//                    kws.put(kw, kw);
                    h = data[i][j];
                    if (kwadraty[idX][idY] != Square.EMPTY && h > nodata) {
                        kwadraty[idX][idY].sumaWysokosci += h;
                        kwadraty[idX][idY].count++;
                    }
                }
            }
            for (int i = 0; i < d_x; i++) {
                for (int j = 0; j < d_y; j++) {
                    Square kw = kwadraty[i][j];
                    if (kw != null) {
                        kw.wysokoscSrednia = (int) (kw.sumaWysokosci / kw.count);
                        Square kwOryg = Teren.getKwadrat(i + x, j + y);
                        // Aktualizacja tylko w przypadku braku danych o wysokości.
                        if (kwOryg != Square.EMPTY && kwOryg.wysokoscSrednia <= -1000) {
//                            kwOryg.wysokoscSrednia = kw.wysokoscSrednia;
                            kwOryg.sumaWysokosci = kw.sumaWysokosci;
                            kwOryg.count = kw.count;
                        }
                    }
                }
            }
            logger.debug("Time= {}[ms]", System.currentTimeMillis() - start);
        }
    }

    private static void readFromFileXYZ(String fn) throws IOException {
        File file = new File(fn);
        InputStream inputStream = new FileInputStream(file);
        Square kw = Square.EMPTY;
        PUWGCoord puwgCoord = new PUWGCoord();
        GeoCoord geo = new GeoCoord();
        HashMap<Square, Square> map = new HashMap<>();
        try (BufferedReader br = new BufferedReader(new InputStreamReader(inputStream))) {
            String line;
            while ((line = br.readLine()) != null) {
                String[] split = line.split(" ");
                double x = Double.parseDouble(split[0]);
                double y = Double.parseDouble(split[1]);
                double h = Double.parseDouble(split[2]);
                if (kw.ell > x || kw.eur < x || kw.nll > y || kw.nur < y) {
                    // Punkt poza granicą bieżącego kwadratu.
                    CoordUtils.convertPUWG1992ToWGS84(y, x, geo);
                    kw = Teren.getKwadrat(geo.lat, geo.lon);
                    if (kw == Square.EMPTY) {
                        continue;
                    }
                    if (kw.stopienZalesienia > 0 || kw.stopienZawodnienia > 0 || kw.stopienZabudowy > 0) {
                        System.out.println(kw);
                    }
                    map.put(kw, kw);
                    if (kw.nur == 0) {
                        // Kwadrat jeszcze nie był odczytany (czysty).
                        int idX = GridCoord.zamienDlugoscGeoNaIdKwadratuX(geo.lon);
                        int idY = GridCoord.zamienSzerokoscGeoNaIdKwadratuY(geo.lat);
                        // Współrzędne geo środka kwadratu.
                        geo.lon = GridCoord.zamienIdKwadratuXNaDlugoscGeo(idX);
                        geo.lat = GridCoord.zamienIdKwadratuYNaSzerokoscGeo(idY);
                        // Wyznacz współrzędne PUWG lewego dolnego rogu kwadratu.
                        CoordUtils.convertWGS84ToPUWG1992(geo.lat - MapConsts.DELTA_Y / 2, geo.lon - MapConsts.DELTA_X / 2, puwgCoord);
                        kw.ell = (int) puwgCoord.easting;
                        kw.nll = (int) puwgCoord.northing;
                        // Wyznacz współrzędne PUWG prawego górnego rogu kwadratu.
                        CoordUtils.convertWGS84ToPUWG1992(geo.lat + MapConsts.DELTA_Y / 2, geo.lon + MapConsts.DELTA_X / 2, puwgCoord);
                        kw.eur = (int) puwgCoord.easting;
                        kw.nur = (int) puwgCoord.northing;
                    }
                }
//                if (kw != Kwadrat.EMPTY_SQUARE && kw.wysokoscSrednia <= -1000) {
                if (kw != Square.EMPTY) {
                    kw.sumaWysokosci += h;
                    kw.count++;
//                    kw.wysokoscSrednia = kw.wysokoscSrednia;
                }
            }


        }

    }

    public static String unzipFile(String zipFileName, String destDir) throws IOException {
        byte[] buffer = new byte[1024];
        String unzipFileName = "";
        try (ZipInputStream zis = new ZipInputStream(new FileInputStream(zipFileName))) {
            ZipEntry zipEntry = zis.getNextEntry();
            while (zipEntry != null) {
                unzipFileName = zipEntry.getName();
                File newFile = new File(destDir + unzipFileName);
//                File newFile = new File(destDir + File.separator + unzipFileName);
                int len;
                // write file content
                FileOutputStream fos = new FileOutputStream(newFile);
                while ((len = zis.read(buffer)) > 0) {
                    fos.write(buffer, 0, len);
                }
                fos.close();
                zipEntry = zis.getNextEntry();
            }
            zis.closeEntry();
        }
        return unzipFileName;
    }
}