/*
 * JDrupes Builder
 * Copyright (C) 2026 Michael N. Lipp
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

package org.jdrupes.builder.core.console;

import com.google.common.flogger.FluentLogger;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.Writer;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import org.jdrupes.builder.api.BuildException;
import org.jdrupes.builder.api.StatusLine;
import org.jline.terminal.Terminal;
import org.jline.terminal.TerminalBuilder;
import org.jline.utils.AttributedString;
import org.jline.utils.AttributedStringBuilder;
import org.jline.utils.AttributedStyle;
import org.jline.utils.InfoCmp.Capability;

/// Provides a split console using ANSI escape sequences.
///
@SuppressWarnings({ "PMD.AvoidSynchronizedStatement", "PMD.GodClass" })
public final class SplitConsole implements AutoCloseable {

    private static final FluentLogger logger = FluentLogger.forEnclosingClass();
    private static final StatusLine NULL_STATUS_LINE = new StatusLine() {
        @Override
        public void update(String text, Object... args) {
            // Does nothing
        }

        @Override
        @SuppressWarnings("PMD.RelianceOnDefaultCharset")
        public PrintWriter writer(String prefix) {
            return new PrintWriter(OutputStream.nullOutputStream());
        }

        @Override
        public void close() {
            // Does nothing
        }
    };
    private static AtomicInteger openCount = new AtomicInteger();
    private static SplitConsole instance;
    private final Terminal terminal;
    private final List<ManagedLine> managedLines = new ArrayList<>();
    @SuppressWarnings("PMD.UseConcurrentHashMap")
    // Guarded by managedLines
    private final Map<Thread, String> offScreenLines = new LinkedHashMap<>();
    private final PrintStream realOut;
    private final PrintStream realErr;
    // Used to synchronize output to terminal
    private final PrintStream terminalOut;
    private final PrintStream splitOut;
    private final PrintStream splitErr;
    private byte[] incompleteLine = new byte[0];
    private final Redrawer redrawer;

    /// The class LineData
    ///
    private static final class LineData {
        private Thread thread;
        private String text;

        private LineData(Thread thread, String text) {
            this.thread = thread;
            this.text = text;
        }

        @SuppressWarnings("PMD.ShortMethodName")
        private static LineData of(Thread thread, String text) {
            return new LineData(thread, text);
        }

        private LineData set(LineData lineData) {
            thread = lineData.thread;
            text = lineData.text;
            return this;
        }

        private static LineData from(ManagedLine managedLine) {
            return new LineData(managedLine.thread, managedLine.text);
        }
    }

    /// The Class ManagedLine.
    ///
    private static final class ManagedLine {
        private Thread thread;
        private String text = "";
        private String lastRendered;

        private ManagedLine set(LineData lineData) {
            thread = lineData.thread;
            text = lineData.text;
            return this;
        }

        private void clear() {
            thread = null;
            text = "";
        }
    }

    /// Open the split console.
    ///
    /// @return the split console
    ///
    @SuppressWarnings({ "PMD.AvoidLiteralsInIfCondition" })
    public static SplitConsole open() {
        synchronized (openCount) {
            if (openCount.incrementAndGet() == 1) {
                instance = new SplitConsole();
            }
            return instance;
        }
    }

    /// Return a status line implementation that discards all update
    /// information.
    ///
    /// @return the status line
    ///
    public static StatusLine nullStatusLine() {
        return NULL_STATUS_LINE;
    }

    /// Initializes a new split console.
    ///
    @SuppressWarnings({ "PMD.ForLoopCanBeForeach" })
    private SplitConsole() {
        logger.atFine().log("Initializing split console");
        realOut = System.out;
        realErr = System.err;
        try {
            terminal = TerminalBuilder.builder().system(true).build();
        } catch (IOException e) {
            throw new BuildException().cause(e);
        }
        var required = List.of(Capability.cursor_up, Capability.cursor_down,
            Capability.parm_up_cursor, Capability.parm_down_cursor,
            Capability.cursor_visible, Capability.cursor_invisible,
            Capability.carriage_return, Capability.clr_eol);
        if (required.stream().map(c -> terminal.getStringCapability(c) == null)
            .filter(b -> b).findAny().isPresent()) {
            logger.atFine().log(
                "Insufficient terminal control support, using plain output");
            redrawer = null;
            terminalOut = System.out;
            splitOut = System.out;
            splitErr = System.err;
            return;
        }

        logger.atFine().log("Using terminal control support for split console");
        terminalOut = new PrintStream(terminal.output(), true,
            Charset.defaultCharset());
        synchronized (managedLines) {
            recomputeLayout(terminal.getHeight() * 1 / 3);
            synchronized (terminalOut) {
                for (int i = 0; i < managedLines.size(); i++) {
                    terminalOut.println();
                }
                for (int i = 0; i < managedLines.size(); i++) {
                    terminal.puts(Capability.cursor_up);
                }
                terminal.flush();
            }
        }
        redrawer = new Redrawer();
        redrawStatus();
        splitOut = new PrintStream(new StreamWrapper(null), true,
            Charset.defaultCharset());
        splitErr = new PrintStream(new StreamWrapper(
            AttributedStyle.DEFAULT.foreground(AttributedStyle.RED)),
            true, Charset.defaultCharset());
        System.setOut(splitOut);
        System.setErr(splitErr);
    }

    private Optional<ManagedLine> managedLine(Thread thread) {
        Objects.nonNull(thread);
        return managedLines.stream()
            .filter(l -> Objects.equals(l.thread, thread)).findFirst();
    }

    /// Allocate a line for outputs from the current thread. 
    ///
    private void allocateLine() {
        if (openCount.get() == 0) {
            return;
        }
        Thread thread = Thread.currentThread();
        synchronized (managedLines) {
            if (managedLine(thread).isPresent()
                || offScreenLines.containsKey(thread)) {
                return;
            }

            // Allocate in off-screen lines. Will be moved on update.
            offScreenLines.put(thread, "");
        }
    }

    private void initManaged(int index, Thread thread, String text) {
        var line = managedLines.get(index);
        line.thread = thread;
        line.text = text;
        line.lastRendered = null;
    }

    /// Deallocate the line for outputs from the current thread.
    ///
    private void deallocateLine() {
        Thread thread = Thread.currentThread();
        synchronized (managedLines) {
            managedLine(thread).ifPresentOrElse(line -> {
                line.clear();
                promoteOffScreenLines();
                redrawStatus();
            }, () -> offScreenLines.remove(thread));
        }
    }

    private void recomputeLayout(int managedHeight) {
        while (managedLines.size() > managedHeight) {
            if (managedLines.get(managedLines.size() - 1).thread == null) {
                managedLines.remove(managedLines.size() - 1);
                break;
            }
            int freeSlot;
            for (freeSlot = 0; freeSlot < managedLines.size() - 1;
                    freeSlot++) {
                if (managedLines.get(freeSlot).thread == null) {
                    break;
                }
            }
            if (freeSlot < managedLines.size() - 1) {
                ManagedLine last = managedLines.get(managedLines.size() - 1);
                managedLines.set(freeSlot, last);
                continue;
            }
            ManagedLine last = managedLines.get(managedLines.size() - 1);
            offScreenLines.put(last.thread, last.text);
            last.thread = null;
        }

        if (managedLines.size() < managedHeight) {
            while (managedLines.size() < managedHeight) {
                managedLines.add(new ManagedLine());
            }
            promoteOffScreenLines();
        }
    }

    private void promoteOffScreenLines() {
        for (int i = 0; i < managedLines.size(); i++) {
            if (offScreenLines.isEmpty()) {
                break;
            }
            if (managedLines.get(i).thread == null) {
                // shiftManaged(i);
                var offLineIter = offScreenLines.entrySet().iterator();
                var offLine = offLineIter.next();
                initManaged(i, offLine.getKey(), offLine.getValue());
                offLineIter.remove();
            }
        }
    }

    /// Update the line for outputs from the current thread.
    ///
    /// @param text the text
    ///
    private void updateStatus(String text, Object... args) {
        var pending = LineData.of(Thread.currentThread(),
            args.length > 0 ? String.format(text, args) : text);
        synchronized (managedLines) {
            if (managedLine(pending.thread).map(l -> {
                l.set(pending);
                return true;
            }).orElse(false)) {
                return;
            }
            offScreenLines.remove(pending.thread);

            // Insert in managed lines
            var updIter = managedLines.iterator();
            while (updIter.hasNext()) {
                var updating = updIter.next();
                var tmp = LineData.from(updating);
                updating.set(pending);
                pending.set(tmp);
                if (pending.thread == null) {
                    // Found empty slot
                    break;
                }
                if (!updIter.hasNext()) {
                    // Nothing left to try
                    offScreenLines.put(pending.thread, pending.text);
                }
            }
            redrawStatus();
        }
    }

    /// Writes the bytes to the scrollable part of the console.
    ///
    /// @param text the text
    ///
    @SuppressWarnings({ "PMD.AvoidLiteralsInIfCondition" })
    private void write(byte[] text, int offset, int length,
            AttributedStyle style) throws IOException {
        synchronized (terminalOut) {
            if (incompleteLine.length > 0) {
                // Prepend left over text and try again
                byte[] prepended = new byte[incompleteLine.length + length];
                System.arraycopy(
                    incompleteLine, 0, prepended, 0, incompleteLine.length);
                System.arraycopy(
                    text, offset, prepended, incompleteLine.length, length);
                incompleteLine = new byte[0];
                write(prepended, style);
                return;
            }

            // Write line(s)
            int end = offset + length;
            for (int i = offset; i < end; i++) {
                if (text[i] != '\n') {
                    continue;
                }
                @SuppressWarnings("PMD.AvoidInstantiatingObjectsInLoops")
                int columns = AttributedString.fromAnsi(new String(
                    text, offset, i - offset + 1, StandardCharsets.UTF_8))
                    .columnLength();
                int rows = (columns + terminal.getWidth() - 1)
                    / terminal.getWidth();
                for (int j = 0; j < rows; j++) {
                    terminal.puts(Capability.carriage_return);
                    terminal.puts(Capability.clr_eol);
                    terminal.puts(Capability.newline);
                }
                terminal.puts(Capability.carriage_return);
                terminal.puts(Capability.clr_eol);
                terminal.puts(Capability.parm_up_cursor, rows);
                terminal.flush();
                // Write line including newline, moves cursor to next line
                writeStyled(terminalOut, text, offset, i - offset + 1, style);
                offset = i + 1;
            }
            incompleteLine = new byte[end - offset];
            System.arraycopy(text, offset, incompleteLine, 0, end - offset);
            if (incompleteLine.length > 0) {
                // Show incomplete line, will be overwritten by next write
                terminalOut.write(incompleteLine, 0, incompleteLine.length);
            }
            terminalOut.flush();
        }
        redrawStatus(true);
    }

    private void write(byte[] text, AttributedStyle style) throws IOException {
        write(text, 0, text.length, style);
    }

    private void writeStyled(PrintStream out, byte[] chars, int off, int len,
            AttributedStyle style) throws IOException {
        // Only called by write, already synchronized
        if (style == null) {
            out.write(chars, off, len);
            return;
        }
        AttributedStringBuilder builder = new AttributedStringBuilder();
        builder.style(style);
        builder.ansiAppend(new String(chars, off, len, StandardCharsets.UTF_8));
        builder.style(AttributedStyle.DEFAULT);
        builder.append("");
        AttributedString result = builder.toAttributedString();
        out.print(result.toAnsi());
    }

    private void redrawStatus() {
        redrawStatus(false);
    }

    private void redrawStatus(boolean force) {
        if (redrawer != null) {
            redrawer.triggerRedraw(force);
        }
    }

    /// Redraws the status lines.
    /// 
    private final class Redrawer implements Runnable {
        private final AtomicBoolean running = new AtomicBoolean(true);
        private final AtomicBoolean redraw = new AtomicBoolean(false);
        private final AtomicBoolean force = new AtomicBoolean(false);
        private final Thread thread;

        private Redrawer() {
            thread = Thread.ofVirtual().name("Split console redrawer")
                .start(this);
        }

        @Override
        public void run() {
            while (true) {
                synchronized (this) {
                    if (!running.get()) {
                        break;
                    }
                    if (!redraw.get()) {
                        try {
                            wait();
                        } catch (InterruptedException e) {
                            break;
                        }
                    }
                    redraw.set(false);
                }
                if (openCount.get() > 0) {
                    doRedraw(force.getAndSet(false));
                }
            }
        }

        private void triggerRedraw(boolean force) {
            synchronized (this) {
                redraw.set(true);
                if (force) {
                    this.force.set(true);
                }
                notifyAll();
            }
        }

        @SuppressWarnings({ "PMD.EmptyCatchBlock" })
        private void stop() {
            synchronized (this) {
                logger.atFine().log("Stopping redrawer");
                running.set(false);
                notifyAll();
            }
            try {
                thread.join();
                logger.atFine().log("Redrawer stopped");
            } catch (InterruptedException e) {
                // Ignore
            }
        }
    }

    @SuppressWarnings({ "PMD.ForLoopCanBeForeach" })
    private void doRedraw(boolean force) {
        synchronized (managedLines) {
            synchronized (terminalOut) {
                terminal.puts(Capability.cursor_invisible);
                for (int i = 0; i < managedLines.size(); i++) {
                    terminal.puts(Capability.newline);
                    ManagedLine line = managedLines.get(i);
                    if (!force
                        && Objects.equals(line.text, line.lastRendered)) {
                        continue;
                    }
                    terminal.puts(Capability.carriage_return);
                    terminal.puts(Capability.clr_eol);
                    terminal.flush();
                    if (openCount.get() > 0) {
                        terminalOut.print("> " + line.text.substring(0,
                            Math.min(line.text.length(),
                                terminal.getWidth() - 2)));
                    }
                    line.lastRendered = line.text;
                }
                terminal.puts(Capability.parm_up_cursor, managedLines.size());
                terminal.puts(Capability.carriage_return);
                terminal.puts(Capability.cursor_visible);
                terminal.flush();
                if (incompleteLine.length > 0) {
                    terminalOut.write(incompleteLine, 0, incompleteLine.length);
                    terminalOut.flush();
                }
            }
        }
    }

    /// Writes the bytes to the scrollable part of the console.
    ///
    /// @return the prints the stream
    ///
    public PrintStream out() {
        return splitOut;
    }

    /// Writes the bytes to the scrollable part of the console.
    ///
    /// @return the prints the stream
    ///
    public PrintStream err() {
        return splitErr;
    }

    /// Close.
    ///
    @Override
    public void close() {
        synchronized (openCount) {
            if (openCount.get() == 0) {
                return;
            }
            if (openCount.decrementAndGet() > 0) {
                return;
            }

            // Don't use this anymore
            System.setOut(realOut);
            System.setErr(realErr);
            instance = null;

            // Cleanup
            logger.atFine().log("Closing split console");
            if (redrawer != null) {
                redrawer.stop();
                synchronized (managedLines) {
                    for (var line : managedLines) {
                        line.thread = null;
                        line.text = "";
                        line.lastRendered = null;
                    }
                    offScreenLines.clear();
                }
                doRedraw(true);
            }
            logger.atFine().log("Split console closed");
        }
    }

    /// Allocates a line for outputs from the current thread.
    ///
    /// @return the status line
    ///
    public DefaultStatusLine statusLine() {
        return new DefaultStatusLine();
    }

    /// Represents a status line for outputs from the current thread.
    ///
    public final class DefaultStatusLine implements StatusLine {

        private PrintWriter asWriter;

        /// Initializes a new status line for the invoking thread.
        ///
        private DefaultStatusLine() {
            allocateLine();
        }

        /// Update.
        ///
        /// @param text the text
        /// @param args the args
        ///
        @Override
        public void update(String text, Object... args) {
            updateStatus(text, args);
        }

        /// Writer.
        ///
        /// @param prefix the prefix
        /// @return the prints the writer
        ///
        @Override
        public PrintWriter writer(String prefix) {
            if (asWriter == null) {
                asWriter = new PrintWriter(new Writer() {
                    private final String prepend = prefix == null ? "" : prefix;
                    @SuppressWarnings("PMD.AvoidStringBufferField")
                    private final StringBuilder buf = new StringBuilder();

                    @Override
                    public void write(char[] cbuf, int off, int len)
                            throws IOException {
                        for (int i = off; i < off + len; i++) {
                            if (cbuf[i] == '\n' || cbuf[i] == '\r') {
                                updateStatus(prepend + buf.toString());
                                buf.setLength(0);
                            } else {
                                buf.append(cbuf[i]);
                            }
                        }
                    }

                    @Override
                    public void flush() throws IOException {
                        updateStatus(prepend + buf.toString());
                    }

                    @Override
                    public void close() throws IOException {
                        // Does nothing
                    }

                });
            }
            return asWriter;
        }

        /// Deallocate the line for outputs from the current thread.
        ///
        @Override
        public void close() {
            deallocateLine();
        }
    }

    /// Makes [#write] available as a stream.
    ///
    public final class StreamWrapper extends OutputStream {

        private final AttributedStyle style;

        private StreamWrapper(AttributedStyle style) {
            this.style = style;
        }

        /// Write.
        ///
        /// @param ch the ch
        /// @throws IOException Signals that an I/O exception has occurred.
        ///
        @Override
        @SuppressWarnings("PMD.ShortVariable")
        public void write(int ch) throws IOException {
            SplitConsole.this.write(new byte[] { (byte) ch }, 0, 1, style);
        }

        /// Write.
        ///
        /// @param ch the ch
        /// @param off the off
        /// @param len the len
        /// @throws IOException Signals that an I/O exception has occurred.
        ///
        @Override
        @SuppressWarnings("PMD.ShortVariable")
        public void write(byte[] ch, int off, int len) throws IOException {
            SplitConsole.this.write(ch, off, len, style);
        }

        /// Close.
        ///
        /// @throws IOException Signals that an I/O exception has occurred.
        ///
        @Override
        public void close() throws IOException {
            // Don't forward close
        }
    }

}