package jmri.jmrit.operations.trains;

import java.awt.*;
import java.io.*;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;

import javax.print.attribute.standard.Sides;
import javax.swing.ImageIcon;
import javax.swing.JLabel;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import jmri.jmrit.operations.setup.Setup;
import jmri.jmrit.operations.trains.trainbuilder.TrainCommon;
import jmri.util.davidflanagan.CompatibleHardcopyWriter;

/**
 * Used for train Manifests and switch lists.
 *
 * @author Daniel Boudreau (C) 2025
 */
public class TrainPrintManifest extends TrainCommon {

    static final char SPACE = ' ';

    /**
     * Print or preview a train Manifest or switch list.
     *
     * @param file          File to be printed or previewed
     * @param name          Title of document
     * @param isPreview     true if preview
     * @param fontName      optional font to use when printing document
     * @param logoURL       optional pathname for logo
     * @param printerName   optional default printer name
     * @param orientation   Setup.LANDSCAPE, Setup.PORTRAIT, or Setup.HANDHELD
     * @param fontSize      font size
     * @param isPrintHeader when true print page header
     * @param sides         two sides long or short can be null
     */
    public static void printReport(File file, String name, boolean isPreview, String fontName, String logoURL,
            String printerName, String orientation, int fontSize, boolean isPrintHeader, Sides sides) {
        
        // obtain a CompatibleHardcopyWriter to do this
        double margin = .5;
        Dimension pagesize = null; // HardcopyWritter provides default page
                                   // sizes for portrait and landscape

        if (orientation.equals(Setup.HANDHELD) || orientation.equals(Setup.HALFPAGE)) {
            isPrintHeader = false;
            // add margins to page size
            pagesize = new Dimension(getPageSize(orientation).width + PAPER_MARGINS.width,
                    getPageSize(orientation).height + PAPER_MARGINS.height);
        }
        try (CompatibleHardcopyWriter writer = new CompatibleHardcopyWriter(new Frame(), name, fontSize, margin,
                margin, margin, margin, isPreview, printerName, orientation.equals(Setup.LANDSCAPE), isPrintHeader, sides, pagesize);
                BufferedReader in = new BufferedReader(new InputStreamReader(
                        new FileInputStream(file), StandardCharsets.UTF_8));) {

            // set font
            if (!fontName.isEmpty()) {
                writer.setFontName(fontName);
            }

            if (logoURL != null && !logoURL.equals(Setup.NONE)) {
                ImageIcon icon = new ImageIcon(logoURL);
                if (icon.getIconWidth() == -1) {
                    log.error("Logo not found: {}", logoURL);
                } else {
                    writer.write(icon.getImage(), new JLabel(icon));
                }
            }

            List<String> lines = new ArrayList<>();
            String line;
            while (true) {
                line = in.readLine();
                if (line == null) {
                    if (isPreview) {
                        // need to do this in case the input file was empty to create preview
                        writer.write(" ");
                    }
                    break;
                }
                lines.add(line);
                if (line.isBlank()) {
                    print(writer, lines, false);
                }
            }
            print(writer, lines, true);
        } catch (FileNotFoundException e) {
            log.error("Build file doesn't exist", e);
        } catch (CompatibleHardcopyWriter.PrintCanceledException ex) {
            log.debug("Print canceled");
        } catch (IOException e) {
            log.warn("Exception printing: {}", e.getLocalizedMessage());
        }
    }

    private static void print(CompatibleHardcopyWriter writer, List<String> lines, boolean lastBlock)
            throws IOException {
        int lineSize = getNumberOfLines(lines);
        if (Setup.isPrintNoPageBreaksEnabled() &&
                writer.getCurrentLineNumber() != 0 &&
                writer.getLinesPerPage() - writer.getCurrentLineNumber() < lineSize) {
            writer.pageBreak();
        }
        // check for exact page break
        if (writer.getLinesPerPage() - writer.getCurrentLineNumber() == lineSize) {
            // eliminate blank line after page break
            String s = lines.get(lines.size() - 1);
            if (s.isBlank()) {
                lines.remove(lines.size() - 1);
            }
        }
        // use line feed for all lines?
        if (lastBlock && writer.getLinesPerPage() - writer.getCurrentLineNumber() < lineSize) {
            lastBlock = false; // yes
        }

        Color color = null;
        boolean printingColor = false;
        for (String line : lines) {
            // determine if there's a line separator
            if (printHorizontialLineSeparator(writer, line)) {
                color = null;
                continue;
            }
            // color text?
            if (line.contains(TEXT_COLOR_START)) {
                color = getTextColor(line);
                if (line.contains(TEXT_COLOR_END)) {
                    printingColor = false;
                } else {
                    // printing multiple lines in color
                    printingColor = true;
                }
                // could be a color change when using two column format
                if (line.contains(Character.toString(VERTICAL_LINE_CHAR))) {
                    String s = line.substring(0, line.indexOf(VERTICAL_LINE_CHAR));
                    s = getTextColorString(s);
                    writer.write(color, s); // 1st half of line printed
                    // get the new color and text
                    line = line.substring(line.indexOf(VERTICAL_LINE_CHAR));
                    color = getTextColor(line);
                    // pad out string
                    line = tabString(getTextColorString(line), s.length());
                } else {
                    // simple case only one color
                    line = getTextColorString(line);
                }
            } else if (line.contains(TEXT_COLOR_END)) {
                printingColor = false;
                line = getTextColorString(line);
            } else if (!printingColor) {
                color = null;
            }

            printVerticalLineSeparator(writer, line);
            line = line.replace(VERTICAL_LINE_CHAR, SPACE);

            if (color != null) {
                writer.write(color, line + NEW_LINE);
                continue;
            }
            writer.write(line);
            // no line feed if last line of file, eliminates blank page
            if (!lastBlock ||
                    writer.getCurrentLineNumber() < writer.getLinesPerPage() - 1) {
                writer.write(NEW_LINE);
            }
        }
        lines.clear();
    }

    /*
     * When determining the number of lines to print, we need to ignore any
     * horizontal lines.
     */
    private static int getNumberOfLines(List<String> lines) {
        int numberLines = lines.size();
        for (String line : lines) {
            for (char c : line.toCharArray()) {
                if (c == HORIZONTAL_LINE_CHAR) {
                    numberLines--;
                    break;
                }
            }
        }
        return numberLines;
    }

    /*
     * Returns true if horizontal line was printed, or line length = 0
     */
    private static boolean printHorizontialLineSeparator(CompatibleHardcopyWriter writer, String line) {
        boolean horizontialLineSeparatorFound = true;
        if (line.length() > 0) {
            for (int i = 0; i < line.length(); i++) {
                if (line.charAt(i) != HORIZONTAL_LINE_CHAR) {
                    horizontialLineSeparatorFound = false;
                    break;
                }
            }
            if (horizontialLineSeparatorFound) {
                int endCol = writer.getCharactersPerLine() + 1;
                writer.write(writer.getCurrentLineNumber(), 0, writer.getCurrentLineNumber(),
                        endCol);
            }
        }
        return horizontialLineSeparatorFound;
    }

    private static void printVerticalLineSeparator(CompatibleHardcopyWriter writer, String line) {
        for (int i = 0; i < line.length(); i++) {
            if (line.charAt(i) == VERTICAL_LINE_CHAR) {
                // make a frame (two column format)
                if (Setup.isTabEnabled()) {
                    int endCol = writer.getCharactersPerLine() + 1;
                    writer.write(writer.getCurrentLineNumber(), 0, writer.getCurrentLineNumber() + 1, 0);
                    writer.write(writer.getCurrentLineNumber(), endCol,
                            writer.getCurrentLineNumber() + 1, endCol);
                }
                writer.write(writer.getCurrentLineNumber(), i + 1, writer.getCurrentLineNumber() + 1,
                        i + 1);
            }
        }
    }

    private final static Logger log = LoggerFactory.getLogger(TrainPrintManifest.class);
}