package mergedocx;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.nio.charset.Charset;
import java.nio.file.DirectoryStream;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;

import static java.nio.charset.StandardCharsets.UTF_8;
import static java.nio.file.Files.*;
import static ru.tensor.petrov.commons.util.StringUtil.endsWith_ignoreCase;
import static ru.tensor.petrov.commons.util.StringUtil.trimEnd;
import static ru.tensor.petrov.commons.util.SystemOut.fixupWindowsConsoleEncoding;
import static ru.tensor.petrov.commons.util.SystemOut.println;

public class MergeDocx {

    private static final int CHARACTER_TO_REPLACE = '$';
    private static final Charset CHARSET_1251 = Charset.forName("Cp1251");

    public static void main(String[] a) throws IOException {
        fixupWindowsConsoleEncoding();

        Path fileRoot = Paths.get(".").toRealPath();
        println("Папка:\n  ", fileRoot);

        Map<String, PairFile> map = new HashMap<>();
        try (DirectoryStream<Path> directoryStream = newDirectoryStream(fileRoot)) {
            //<editor-fold defaultstate="collapsed" desc="mapping">
            for (Path file : directoryStream) {
                if (!isDirectory(file)) {
                    String nameWithMask = file.getFileName().toString();

                    if (endsWith_ignoreCase(nameWithMask, ".txt")) {
                        String name = trimEnd(nameWithMask, 4).toLowerCase();
                        if (map.containsKey(name)) {
                            map.get(name).txt = file;
                        } else {
                            map.put(name, PairFile.fromTxt(file));
                        }
                    } else if (endsWith_ignoreCase(nameWithMask, ".docx")) {
                        String name = trimEnd(nameWithMask, 5).toLowerCase();
                        if (map.containsKey(name)) {
                            map.get(name).docx = file;
                        } else {
                            map.put(name, PairFile.fromDocx(file));
                        }
                    }
                }
            }
            //</editor-fold>
        }

        boolean hasGood = false;
        ArrayList<PairFile> pairlessFiles = new ArrayList<>();
        for (PairFile pair : map.values()) {
            if (!pair.isComplete()) {
                pairlessFiles.add(pair);
            } else {
                hasGood = true;
            }
        }

        if (!pairlessFiles.isEmpty()) {
            println();
            if (pairlessFiles.size() == 1) {
                println("У файла нет пары:");
            } else {
                println("У ", pairlessFiles.size(), " файлов нет пар:");
            }
            for (PairFile pairlessFile : pairlessFiles) {
                println("  ", pairlessFile.getAName());
            }
        }


        int cntHandled = 0, cntTotal = 0;
        boolean lose = false;
        if (hasGood) {
            println("\n" + "Обработка: ");
            Path dirOut = fileRoot.resolve("out");

            if (exists(dirOut)) {
                deleteDir(dirOut);
            }
            createDirectories(dirOut);

            for (PairFile pair : map.values()) {
                if (pair.isComplete()) {
                    println("  ", pair.txt.getFileName());
                    Path docxFileName = pair.docx.getFileName();
                    println("  ", docxFileName);
                    try {
                        MergeProccessInfo info = process(pair, dirOut.resolve(docxFileName));
                        //<editor-fold defaultstate="collapsed" desc="print info">
                        if (info.hasDocumentXml) {
                            if (info.isConverge()) {
                                println("  OK (заменено: ", info.cntLines_inTxt, ")");
                            } else {
                                lose = true;
                                println("  НЕ СОШЛОСЬ (txt: ", info.cntLines_inTxt, ", docx: ", info.cntSymbols_inDocx, ")");
                            }
                        } else {
                            lose = true;
                            println("  ОШИБКА: docx файл имеет не верный формат (отсутствует document.xml). Строк в txt: ", info.cntLines_inTxt);
                        }
                        //</editor-fold>
                        ++cntHandled;
                    } catch (Throwable any) {
                        lose = true;
                        println("  ОШИБКА: ", any);
                    }
                    println();
                }
                ++cntTotal;
            }
        }

        println("Обработано ", cntHandled, " из ", cntTotal, " файлов");
        println(lose ? "Были ошибки" : "Ошибок не было");

        if (!pairlessFiles.isEmpty()) {
            println("\n" + "Были файл(ы) не имеющие пар (", pairlessFiles.size(), ")");
        }
    }

    private static MergeProccessInfo process(PairFile pair, Path fileOut) throws Exception {
        MergeProccessInfo info = new MergeProccessInfo();
        try (
                ZipInputStream zis = new ZipInputStream(new BufferedInputStream(newInputStream(pair.docx)));
                ZipOutputStream zos = new ZipOutputStream(new BufferedOutputStream(newOutputStream(fileOut)));
                BufferedReader readerTxt = newBufferedReader((pair.txt), CHARSET_1251);
            )
        {
            for (ZipEntry entry; (entry = zis.getNextEntry()) != null;) {
                String name = entry.getName();
                zos.putNextEntry(new ZipEntry(name));

                if (endsWith_ignoreCase(name, "document.xml")) {
                    info.hasDocumentXml = true;
                    BufferedReader readerZipEntry = new BufferedReader(new InputStreamReader(zis, UTF_8));
                    BufferedWriter writerZipEntry = new BufferedWriter(new OutputStreamWriter(zos, UTF_8));

                    for (int ch; (ch = readerZipEntry.read()) > -1;) {
                        if (ch == CHARACTER_TO_REPLACE) {
                            info.cntSymbols_inDocx++;

                            String line = readerTxt.readLine();
                            if (line != null) {
                                writerZipEntry.write(line);
                                info.cntLines_inTxt++;
                            }
                        } else {
                            writerZipEntry.write(ch);
                        }
                    }

                    writerZipEntry.flush();
                }
                copy(zis, zos);
                zos.closeEntry();
            }

            //<editor-fold defaultstate="collapsed" desc="подсчёт лишних строк в txt файле">
            while (readerTxt.readLine() != null) {
                info.cntLines_inTxt++;
            }
            //</editor-fold>

        }
        return info;
    }

    //<editor-fold defaultstate="collapsed" desc="copy">
    private static final byte[] BUFFER = new byte[4096 * 1024];
    private static void copy(InputStream input, OutputStream output) throws IOException {
        for (int length; (length = input.read(BUFFER)) != -1;) {
            output.write(BUFFER, 0, length);
        }
    }
    //</editor-fold>

    private static void deleteDir(Path dir) throws IOException {
        try (DirectoryStream<Path> directoryStream = newDirectoryStream(dir)) {
            for (Path path : directoryStream) {
                if (isDirectory(path)) {
                    deleteDir(dir);
                } else {
                    delete(path);
                }
            }
        }
    }
}

package mergedocx;

public class MergeProccessInfo {

    public int cntLines_inTxt, cntSymbols_inDocx;
    public boolean hasDocumentXml;

    public boolean isConverge() {
        return cntLines_inTxt == cntSymbols_inDocx;
    }
}

package mergedocx;

import java.nio.file.Path;

public class PairFile {

    public Path txt, docx;

    private PairFile() {}

    public static PairFile fromTxt(Path txt) {
        PairFile pairFile = new PairFile();
        pairFile.txt = txt;
        return pairFile;
    }

    public static PairFile fromDocx(Path docx) {
        PairFile pairFile = new PairFile();
        pairFile.docx = docx;
        return pairFile;
    }

    public boolean isComplete() {
        return txt != null && docx != null;
    }

    public String getAName() {
        if (txt != null) {
            return txt.getFileName().toString();
        } else if (docx != null) {
            return docx.getFileName().toString();
        } else {
            return "";
        }
    }
}