package tv.tivilux.nativeplayer.data;

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;

/** Opt-in, bounded in-memory diagnostics. Never stores a URL, header or exception message. */
public final class LiveStreamTrace {
    private LiveStreamTrace() {}
    interface Clock { long getAsLong(); }
    static Clock clock = () -> System.nanoTime() / 1_000_000L;
    private static volatile boolean recording;
    private static volatile long capture;
    private static long started;
    private static long selection;
    private static String channel = "Live channel";
    private static String channelKey = "";
    private static final List<Session> sessions = new ArrayList<>();
    private static final ArrayDeque<String> events = new ArrayDeque<>();
    private static int dropped;

    public static synchronized void start() {
        recording = false;
        capture++;
        sessions.clear(); events.clear(); dropped = 0; selection = 0;
        channel = "Live channel"; channelKey = "";
        started = clock.getAsLong();
        recording = true;
        event("CAPTURE START — tune A, then B; return here without pressing HOME");
    }
    public static synchronized void stop() {
        if (recording) event("CAPTURE STOP — later events are not recorded");
        recording = false;
    }
    public static synchronized void clear() {
        recording = false; capture++; sessions.clear(); events.clear(); dropped = 0;
    }
    public static boolean isRecording() { return recording; }
    private static long now() { return clock.getAsLong() - started; }
    private static boolean valid(Session s) { return recording && s.captureId == capture; }
    private static String safeName(String name) {
        if (name == null || name.contains("://")) return "Live channel";
        return name.replaceAll("[\\p{Cntrl}]", " ").substring(0, Math.min(name.replaceAll("[\\p{Cntrl}]", " ").length(), 70));
    }
    private static void event(String text) {
        if (events.size() == 240) { events.removeFirst(); dropped++; }
        events.addLast(String.format(Locale.US, "+%07d ms %s", now(), text));
    }
    public static synchronized void selected(String key, String name) {
        if (!recording) return;
        if (!key.equals(channelKey)) {
            long time = now();
            for (Session s : sessions) if (s.retiredAt < 0) s.retiredAt = time;
            selection++; channelKey = key; channel = safeName(name);
        }
        event("SELECT #" + selection + " " + channel);
    }
    public static synchronized void begin(String mediaId, String format, String key, String name) {
        if (!recording) return;
        // Restored guide previews may start without a fresh ViewModel selection callback.
        if (!key.equals(channelKey)) selected(key, name);
        begin(mediaId, format);
    }
    /** Called before setMediaItem, binding even delayed HLS requests to this exact source. */
    public static synchronized void begin(String mediaId, String format) {
        if (!recording) return;
        if (sessions.size() >= 16) {
            event("CAPTURE LIMIT: 16 source attempts; start a new capture for more");
            recording = false; return;
        }
        long time = now();
        for (Session s : sessions) if (s.retiredAt < 0) s.retiredAt = time;
        Session s = new Session(capture, sessions.size() + 1, selection, mediaId, channel, format);
        sessions.add(s);
        event(s.label() + " SOURCE ASSIGNED " + format);
    }
    public static synchronized Session find(String mediaId) {
        if (!recording) return null;
        for (Session s : sessions) if (s.mediaId.equals(mediaId)) return s;
        return null;
    }
    public static synchronized void ending(String mediaId) {
        Session s = find(mediaId);
        if (s != null) {
            if (s.retiredAt < 0) s.retiredAt = now();
            event(s.label() + " STOP/CLEAR requested");
        }
    }
    public static final class Session {
        final long captureId, selectionId;
        final int id;
        final String mediaId, name, format;
        volatile long retiredAt = -1;
        final List<Request> requests = new ArrayList<>();
        Session(long captureId, int id, long selectionId, String mediaId, String name, String format) {
            this.captureId = captureId; this.id = id; this.selectionId = selectionId;
            this.mediaId = mediaId; this.name = name; this.format = format;
        }
        String label() { return "S" + id + " [" + name + "]"; }
        public Request open(String kind) {
            synchronized (LiveStreamTrace.class) {
                if (!valid(this)) return null;
                if (requests.size() >= 160) {
                    event("CAPTURE LIMIT: request budget reached"); recording = false; return null;
                }
                Request r = new Request(this, requests.size() + 1, kind, now());
                requests.add(r);
                event(r.label() + " OPEN begin" + (retiredAt >= 0 ? " AFTER SWITCH/STOP" : ""));
                return r;
            }
        }
    }
    public static final class Request {
        final Session session;
        final int id;
        final String kind;
        final long openedAt;
        final boolean openedLate;
        volatile long bytes, lateBytes, lastRead = -1, lastLateRead = -1, closeBegin = -1, closedAt = -1;
        volatile boolean openReturned, closeFailed;
        Request(Session s, int id, String kind, long time) {
            session = s; this.id = id; this.kind = kind; openedAt = time; openedLate = s.retiredAt >= 0;
        }
        String label() { return "S" + session.id + "/R" + id + " " + kind; }
        public void opened() {
            synchronized (LiveStreamTrace.class) {
                if (!valid(session)) return;
                openReturned = true; event(label() + " OPEN returned");
            }
        }
        /** Loader-thread counters only; no per-read string formatting or disk I/O. */
        public void read(int count) {
            if (count <= 0 || !valid(session)) return;
            bytes += count; lastRead = now();
            if (session.retiredAt >= 0) {
                boolean first = lateBytes == 0;
                lateBytes += count; lastLateRead = lastRead;
                if (first) synchronized (LiveStreamTrace.class) {
                    if (valid(session)) event(label() + " FIRST READ RETURN AFTER SWITCH/STOP");
                }
            }
        }
        public void error(String phase) {
            synchronized (LiveStreamTrace.class) {
                if (valid(session)) event(label() + " " + phase + " threw (message omitted)");
            }
        }
        public void closing() {
            synchronized (LiveStreamTrace.class) {
                if (!valid(session)) return;
                closeBegin = now(); event(label() + " CLOSE begin");
            }
        }
        public void closed(boolean success) {
            synchronized (LiveStreamTrace.class) {
                if (!valid(session)) return;
                closedAt = now(); closeFailed = !success;
                event(label() + (success ? " CLOSE returned" : " CLOSE threw") + " bytes=" + bytes + " lateReadBytes=" + lateBytes);
            }
        }
    }
    public static synchronized String snapshot() {
        StringBuilder out = new StringBuilder("TiviLux Stream Diagnostics\n");
        out.append(recording ? "RECORDING" : "STOPPED").append(" — local memory only\n");
        out.append("Read return = bytes delivered to player, not proof of wire arrival.\nClose return = client API completion, not XUI slot release.\n\n");
        for (Session s : sessions) {
            int pending = 0, failed = 0, lateOpens = 0;
            long latestClose = -1, lateBytes = 0, lastLate = -1;
            for (Request r : s.requests) {
                if (r.closedAt < 0) pending++;
                if (r.closeFailed) failed++;
                latestClose = Math.max(latestClose, r.closedAt);
                lateBytes += r.lateBytes; lastLate = Math.max(lastLate, r.lastLateRead);
                if (r.openedLate) lateOpens++;
            }
            out.append(s.label()).append(" ").append(s.format).append("\n");
            out.append("  requests=").append(s.requests.size()).append(" unclosed=").append(pending).append(" closeErrors=").append(failed).append("\n");
            if (s.retiredAt >= 0) {
                out.append("  switched/stopped at +").append(s.retiredAt).append(" ms; late opens=").append(lateOpens).append("\n");
                if (!s.requests.isEmpty() && pending == 0 && failed == 0)
                    out.append("  latest close ").append(Math.max(0, latestClose - s.retiredAt)).append(" ms after switch/stop\n");
                out.append("  read bytes after switch/stop=").append(lateBytes);
                if (lastLate >= 0) out.append("; last at +").append(lastLate - s.retiredAt).append(" ms");
                out.append("\n");
            }
        }
        out.append("\nEVENTS (oldest first; ").append(dropped).append(" older entries omitted)\n");
        for (String e : events) out.append(e).append("\n");
        return out.toString();
    }
}
