package org.jdrupes.builder.core.progessui;

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.Queue;
import java.util.stream.IntStream;

import io.vavr.Tuple;
import io.vavr.Tuple2;
import sun.misc.Signal;
import sun.misc.SignalHandler;

public class SplitConsole {

    private class ManagedLine {
        public Thread thread;
        public String text = "";
        public String lastRendered = null;
        public Spinner spinner = Spinner.DOTS;
        public Color color = Color.BLUE;
    }

    private final Terminal term;

    private final List<ManagedLine> managedLines = new ArrayList<>();
    private final Map<Thread, String> offScreenLines = new LinkedHashMap<>();
    private final Spinner[] spinners = Spinner.values();

    public SplitConsole() {
        this.term = new Terminal();

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

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

    public 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.spinner = Spinner.CYCLE;
        line.color = pickColor(thread);
    }

    public 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);
        }
    }

    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());
    }

    private void installSigWinchHandler() {
        try {
            Signal.handle(new Signal("WINCH"), new SignalHandler() {
                @Override
                public void handle(Signal sig) {
                    term.refreshSize();
//                    recomputeLayout();
                    redraw();
                }
            });
        } catch (Throwable ignored) {
        }
    }

    public synchronized void writeLine(String text) {
        Thread thread = Thread.currentThread();
//        Integer index = managedLineByThread.get(thread);
        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];
    }

    public void println(String text) {
        int lastScrolled = term.lines() - managedLines.size() - 1;
        System.out.println(Ansi.hideCursor() + Ansi.scrollRange(0, lastScrolled)
            + Ansi.scrollUp() + Ansi.scrollAll()
            + Ansi.cursorAt(lastScrolled - 1, 0)
            + Ansi.showCursor() + text);
        System.out.flush();
    }

    private synchronized void redraw() {
        redraw(false);
    }

    private synchronized void redraw(boolean force) {
        if (!term.supportsAnsi) {
            return;
        }

        var managedStart = term.lines() - managedLines.size();
        System.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) {
                System.out.print(Ansi.cursorAt(row, 0) + Ansi.clearLine()
                    + line.text);
                line.lastRendered = line.text;
            }
        }

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

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

    enum Spinner {
        CYCLE(new String[] { "-", "\\", "|", "/" }),
        DOTS(new String[] { ".", "..", "...", "   " });

        private final String[] frames;
        private int idx = 0;

        Spinner(String[] frames) {
            this.frames = frames;
        }

        public String next() {
            String frame = frames[idx % frames.length];
            idx++;
            return frame;
        }
    }

    public enum Color {
        RED(31),
        GREEN(32),
        YELLOW(33),
        BLUE(34),
        MAGENTA(35),
        CYAN(36);

        private final int code;

        Color(int code) {
            this.code = code;
        }

        public int code() {
            return code;
        }
    }

}