/*
 * 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 java.io.PrintStream;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.IntStream;
import org.jdrupes.builder.core.console.Ansi.Color;

/// Provides a split console using ANSI escape sequences.
///
public class SplitConsole {

    private final TerminalInfo term;
    private final List<ManagedLine> managedLines = new ArrayList<>();
    @SuppressWarnings("PMD.UseConcurrentHashMap")
    private final Map<Thread, String> offScreenLines = new LinkedHashMap<>();
    private final PrintStream out = System.out;

    /// The Class ManagedLine.
    ///
    @SuppressWarnings({ "PMD.ClassWithOnlyPrivateConstructorsShouldBeFinal" })
    private class ManagedLine {
        private Thread thread;
        private String text = "";
        private String lastRendered;
        private Color color = Color.BLUE;
    }

    /// Initializes a new split console.
    ///
    public SplitConsole() {
        this.term = new TerminalInfo();

        if (term.supportsAnsi()) {
            for (int i = 0; i < term.lines() * 1 / 3; i++) {
                out.println();
            }
            recomputeLayout(term.lines() * 1 / 3);
            redraw();
        }
    }

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

    /// Allocate a line for outputs from the current thread. 
    ///
    @SuppressWarnings({ "PMD.AvoidSynchronizedAtMethodLevel",
        "PMD.AvoidDuplicateLiterals" })
    private synchronized void allocateLine() {
        Thread thread = Thread.currentThread();
        if (managedLine(thread) != null || offScreenLines.containsKey(thread)) {
            return;
        }

        // Find free and allocate or use overflow
        IntStream.range(0, managedLines.size())
            .filter(i -> managedLines.get(i).thread == null).findFirst()
            .ifPresentOrElse(i -> {
                initManaged(i, thread, "");
            }, () -> {
                offScreenLines.put(thread, "");
            });
    }

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

    /// Deallocate the line for outputs from the current thread.
    ///
    @SuppressWarnings("PMD.AvoidSynchronizedAtMethodLevel")
    private synchronized void deallocateLine() {
        Thread thread = Thread.currentThread();
        var line = managedLine(thread);

        if (line != null) {
            line.thread = null;
            line.text = "";
            promoteOffScreenLines();
            redraw();
        } else {
            offScreenLines.remove(thread);
        }
    }

    @SuppressWarnings("PMD.AvoidSynchronizedAtMethodLevel")
    private synchronized 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 offLine = offScreenLines.entrySet().iterator().next();
                initManaged(managedLines.size() - 1, offLine.getKey(),
                    offLine.getValue());
                offScreenLines.remove(offLine.getKey());
            }
        }
    }

    private void shiftManaged(int index) {
        var lastManaged = managedLines.size() - 1;
        for (int i = index; i < lastManaged; i++) {
            var toMove = managedLines.get(i + 1);
            managedLines.set(i, toMove);
            toMove.lastRendered = null;
        }
        managedLines.set(lastManaged, new ManagedLine());
    }

    /// Update the line for outputs from the current thread.
    ///
    /// @param text the text
    ///
    @SuppressWarnings("PMD.AvoidSynchronizedAtMethodLevel")
    private synchronized void writeLine(String text) {
        Thread thread = Thread.currentThread();
        var line = managedLine(thread);

//        String spinnerChar = "";
//        Spinner spinner = threadSpinners.get(thread);
//        if (spinner != null) {
//            spinnerChar = spinner.next();
//        }
//
//        String coloredText = applyColor(thread, spinnerChar + " " + text);

        if (line != null) {
            line.text = text;
            redraw();
        } else if (offScreenLines.containsKey(thread)) {
            offScreenLines.put(thread, text);
        }
    }

//    private String applyColor(Thread thread, String text) {
//        Integer color = threadColors.get(thread);
//        if (color != null) {
//            return Ansi.color(color) + text + Ansi.RESET;
//        }
//        return text;
//    }

    private Color pickColor(Thread thread) {
        Color[] codes = Color.values();
        return codes[Math.abs(thread.hashCode()) % codes.length];
    }

    /// Prints a line in the scrollable part of the console.
    ///
    /// @param text the text
    ///
    public void println(String text) {
        int lastScrolled = term.lines() - managedLines.size() - 1;
        out.println(Ansi.hideCursor() + Ansi.scrollRange(0, lastScrolled)
            + Ansi.scrollUp() + Ansi.scrollAll()
            + Ansi.cursorAt(lastScrolled - 1, 0)
            + Ansi.showCursor() + text);
        out.flush();
    }

    @SuppressWarnings("PMD.AvoidSynchronizedAtMethodLevel")
    private synchronized void redraw() {
        redraw(false);
    }

    @SuppressWarnings("PMD.AvoidSynchronizedAtMethodLevel")
    private synchronized void redraw(boolean force) {
        if (!term.supportsAnsi()) {
            return;
        }

        var managedStart = term.lines() - managedLines.size();
        out.print(Ansi.hideCursor());
        for (int i = 0; i < managedLines.size(); i++) {
            ManagedLine line = managedLines.get(i);
            var row = managedStart + i;
            if (!Objects.equals(line.text, line.lastRendered) || force) {
                out.print(Ansi.cursorAt(row, 0) + Ansi.clearLine()
                    + line.text);
                line.lastRendered = line.text;
            }
        }

        out.print(Ansi.cursorAt(managedStart - 1, 0)
            + Ansi.showCursor());
        out.flush();
    }

    /// Close.
    ///
    public void close() {
        if (term.supportsAnsi()) {
            out.print(Ansi.showCursor());
        }
    }

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

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

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

        /// Update the text in the status line.
        ///
        /// @param text the text
        ///
        public void update(String text) {
            writeLine(text);
        }

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

}