noctalia-shell/Services/Compositor/MangoService.qml

import QtQuick
import Quickshell
import Quickshell.Io
import Quickshell.Wayland
import qs.Commons
import qs.Services.Keyboard
import qs.Services.UI

Item {
    id: root

    // 1. FACADE INTERFACE
    property ListModel workspaces: ListModel {}
    property var windows: [] 
    property int focusedWindowIndex: -1

    signal workspaceChanged
    signal activeWindowChanged
    signal windowListChanged
    signal displayScalesChanged

    property string selectedMonitor: ""
    property string currentLayoutSymbol: ""
    property bool initialized: false

    // 2. CONFIGURATION
    QtObject {
        id: config
        readonly property int defaultWorkspaceId: 1
        
        // Pre-compiled Regex for Performance
        readonly property var reTagDetail: /^(\S+)\s+tag\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)$/
        readonly property var reTagBinary: /^(\S+)\s+tags\s+([01]+)\s+([01]+)\s+([01]+)$/
        readonly property var reLayout: /^(\S+)\s+layout\s+(\S+)$/
        readonly property var reMetadata: /^(\S+)\s+(title|appid)\s+(.*)$/
        readonly property var reKbLayout: /^(\S+)\s+kb_layout\s+(.*)$/
        readonly property var reScale: /^(\S+)\s+scale_factor\s+(\d+(\.\d+)?)$/
        
        readonly property var query: ({
            eventStream: ["mmsg", "-w"], 
            monitors:    ["mmsg", "-g", "-o"],
            outputs:     ["mmsg", "-g", "-A"], // Scales
            workspaces:  ["mmsg", "-g", "-t"] 
        })

        readonly property var action: ({
            tag:            ["mmsg", "-s", "-t"],
            view:           ["mmsg", "-s", "-d", "view"],
            toggleOverview: ["mmsg", "-s", "-d", "toggleoverview"],
            setLayout:      ["mmsg", "-s", "-d", "setlayout"],
            killClient:     ["mmsg", "-s", "-d", "killclient"],
            quit:           ["mmsg", "-s", "-q"]
        })
    }

    // 3. LOGIC ENGINE
    QtObject {
        id: internal

        // State
        property var activeTags: ({}) 
        property var multiTagState: ({}) 
        property bool hasValidTagData: false
        
        // Map<ToplevelObject, WorkspaceID>
        property var windowStateMap: new Map()
        
        property string mmsgFocusedTitle: ""
        property string mmsgFocusedAppId: ""
        property string currentKbLayout: ""
        
        // Caches
        property var workspaceCache: ({})
        property var monitorScales: ({}) 
        property string lastWindowSig: ""

        // Buffers
        property string streamBuffer: ""

        // --- STREAM PROCESSOR ---
        function processFrame(output) {
            const lines = output.trim().split('\n');
            const newWsList = [];
            const newWsCache = {};
            const processedTags = {}; 
            let metadataChanged = false;
            let receivedClientCounts = false; // Track if we got real numbers

            for (let i = 0; i < lines.length; i++) {
                const line = lines[i].trim();
                if (!line) continue;

                // 1. Tag Details (High Quality Data: Contains Client Counts)
                const tagMatch = line.match(config.reTagDetail);
                if (tagMatch) {
                    const outputName = tagMatch[1];
                    const tagId = parseInt(tagMatch[2]);
                    const state = parseInt(tagMatch[3]);
                    const clients = parseInt(tagMatch[4]);
                    const focused = parseInt(tagMatch[5]);
                    const isActive = (state & 1) !== 0;
                    
                    if (isActive) internal.activeTags[outputName] = tagId;
                    const wsData = {
                        "id": tagId, "idx": tagId, "name": tagId.toString(),
                        "output": outputName,
                        "isActive": isActive,
                        "isFocused": isActive && (focused === 1 || outputName === root.selectedMonitor),
                        "isUrgent": (state & 2) !== 0,
                        "isOccupied": clients > 0,
                        "clients": clients // We have the real number!
                    };
                    const key = `${outputName}-${tagId}`;
                    newWsCache[key] = wsData;
                    newWsList.push(wsData);
                    processedTags[key] = true;
                    receivedClientCounts = true;
                    continue;
                }
                
                // 2. Binary Tags (Low Quality Data: No Client Counts)
                const tagsMatch = line.match(config.reTagBinary);
                if (tagsMatch) {
                    const outputName = tagsMatch[1];
                    const occ = tagsMatch[2];
                    const seltags = tagsMatch[3];
                    const urg = tagsMatch[4];
                    const len = occ.length;

                    // Overview Detection
                    let activeCount = 0;
                    for (let c = 0; c < seltags.length; c++) if (seltags[c] === '1') activeCount++;
                    internal.multiTagState[outputName] = (activeCount > 1);

                    for (let j = 0; j < len; j++) {
                        const tagId = j + 1;
                        const charIdx = len - 1 - j; 
                        const key = `${outputName}-${tagId}`;
                        
                        if (processedTags[key]) continue;
                        const isActive = seltags[charIdx] === '1';
                        const isOccupied = occ[charIdx] === '1';

                        if (isActive) internal.activeTags[outputName] = tagId;
                        newWsList.push({
                            "id": tagId, "idx": tagId, "name": tagId.toString(),
                            "output": outputName,
                            "isActive": isActive,
                            "isFocused": false,
                            "isUrgent": urg[charIdx] === '1',
                            "isOccupied": isOccupied,
                            "clients": isOccupied ? -1 : 0 // -1 indicates "Unknown, but at least 1"
                        });
                    }
                    continue;
                }

                // 3. Metadata
                const metaMatch = line.match(config.reMetadata);
                if (metaMatch) {
                    const prop = metaMatch[2];
                    const val = metaMatch[3];
                    if (prop === "title") internal.mmsgFocusedTitle = val;
                    else if (prop === "appid") internal.mmsgFocusedAppId = val;
                    metadataChanged = true;
                    continue;
                }
                
                // 4. Layout
                const layoutMatch = line.match(config.reLayout);
                if (layoutMatch) {
                    if (layoutMatch[2] !== root.currentLayoutSymbol) root.currentLayoutSymbol = layoutMatch[2];
                }

                // 5. Keyboard
                const kbMatch = line.match(config.reKbLayout);
                if (kbMatch) {
                    const kbName = kbMatch[2];
                    if (kbName !== internal.currentKbLayout) {
                        internal.currentKbLayout = kbName;
                        if (KeyboardLayoutService) KeyboardLayoutService.setCurrentLayout(kbName);
                    }
                }
            }

            // Apply
            if (JSON.stringify(newWsCache) !== JSON.stringify(internal.workspaceCache)) {
                internal.workspaceCache = newWsCache;
                newWsList.sort((a, b) => {
                    if (a.id !== b.id) return a.id - b.id;
                    return a.output.localeCompare(b.output);
                });
                root.workspaces.clear();
                for (let k = 0; k < newWsList.length; k++) root.workspaces.append(newWsList[k]);
                root.workspaceChanged();

                if (receivedClientCounts) internal.hasValidTagData = true;
            }
            
            if (metadataChanged || newWsList.length > 0) {
                internal.updateWindowList();
            }
        }

        // --- WINDOW LIST MERGE ---
        function updateWindowList() {
            if (!ToplevelManager.toplevels) return;

            // FIX: SAFETY CHECK
            // If we haven't received "Detailed" data yet (only binary), 
            // we don't know where the windows are. Abort to prevent map poisoning.
            if (!internal.hasValidTagData) return;

            const rawList = ToplevelManager.toplevels.values;
            const finalList = [];
            let newFocusedIdx = -1;
            
            const currentObjects = new Set();
            const tagCapacities = new Map();
            
            // Build Capacities
            let totalCapacity = 0;
            for (let key in internal.workspaceCache) {
                const ws = internal.workspaceCache[key];
                const cap = ws.clients > 0 ? ws.clients : 0;
                tagCapacities.set(key, cap);
            totalCapacity += cap;
            }
            

            if (totalCapacity === 0 && rawList.length > 0 && !internal.hasValidTagData) return;

            const unassignedWindows = [];

            // Pass 1: Known & Focused
            for (let i = 0; i < rawList.length; i++) {
                const toplevel = rawList[i];
                if (!toplevel || toplevel.outliers) continue;
                
                currentObjects.add(toplevel);

                const appId = toplevel.appId || toplevel.wayland.appId || "";
                const title = toplevel.title || toplevel.wayland.title || "";
                
                let outputName = root.selectedMonitor;
                if (toplevel.outputs && toplevel.outputs.length > 0) {
                    outputName = toplevel.outputs[0].name;
                }

                const currentActiveTag = internal.activeTags[outputName] || config.defaultWorkspaceId;
                const isMultiTag = internal.multiTagState[outputName] === true; 
                let wsId = -1; 

                const isFocused = toplevel.activated;
                const isMmsgFocus = (title === internal.mmsgFocusedTitle) && 
                                    (appId === internal.mmsgFocusedAppId);
                
                if (isFocused && isMmsgFocus && !isMultiTag) {
                    wsId = currentActiveTag;
                    internal.windowStateMap.set(toplevel, wsId);
                } 
                else if (internal.windowStateMap.has(toplevel)) {
                    wsId = internal.windowStateMap.get(toplevel);
                }

                if (wsId !== -1) {
                    const key = `${outputName}-${wsId}`;
                    const cap = tagCapacities.get(key) || 0;
                    if (cap > 0) tagCapacities.set(key, cap - 1);
                    
                    finalList.push(createWindowObject(toplevel, outputName, appId, title, wsId, isFocused, i));
                } else {
                    unassignedWindows.push({ toplevel, outputName, appId, title, isFocused, index: i });
                }
            }

            // Pass 2: Distribute Unknowns
            for (const win of unassignedWindows) {
                let assignedId = -1;

                for (let key in internal.workspaceCache) {
                    const ws = internal.workspaceCache[key];
                    // Robust output check: match name OR if both are undefined/generic
                    if (ws.output !== win.outputName && win.outputName !== "") continue;

                    const cap = tagCapacities.get(key) || 0;
                    if (cap > 0) {
                        assignedId = ws.id;
                        tagCapacities.set(key, cap - 1); 
                        break;
                    }
                }

                if (assignedId === -1) {
                    assignedId = internal.activeTags[win.outputName] || config.defaultWorkspaceId;
                }

                internal.windowStateMap.set(win.toplevel, assignedId);
                finalList.push(createWindowObject(
                    win.toplevel, win.outputName, win.appId, win.title, assignedId, win.isFocused, win.index
                ));
            }

            finalList.sort((a, b) => {
                const idxA = parseInt(a.id.split('-').pop());
                const idxB = parseInt(b.id.split('-').pop());
                return idxA - idxB;
            });

            for(let i=0; i<finalList.length; i++) {
                if (finalList[i].isFocused) newFocusedIdx = i;
            }

            if (internal.windowStateMap.size > rawList.length + 10) {
                for (const key of internal.windowStateMap.keys()) {
                    if (!currentObjects.has(key)) internal.windowStateMap.delete(key);
                }
            }

            const sig = JSON.stringify(finalList.map(w => w.id + w.workspaceId + w.isFocused));
            if (sig !== internal.lastWindowSig) {
                internal.lastWindowSig = sig;
                root.windows = finalList;
                root.windowListChanged();
            }

            if (newFocusedIdx !== root.focusedWindowIndex) {
                root.focusedWindowIndex = newFocusedIdx;
                root.activeWindowChanged();
            }
        }

        function createWindowObject(toplevel, outputName, appId, title, wsId, isFocused, index) {
             return {
                "id": `${outputName}-${appId}-${index}`,
                "title": title,
                "appId": appId,
                "class": appId,
                "workspaceId": wsId,
                "isFocused": isFocused,
                "output": outputName,
                "handle": toplevel,
                "fullscreen": toplevel.fullscreen,
                "floating": toplevel.maximized === false && toplevel.fullscreen === false
            };
        }

        // --- SCALES ---
        function updateScales() {
            const scalesMap = {};
            for (const [name, data] of Object.entries(internal.monitorScales)) {
                scalesMap[name] = {
                    "name": name,
                    "scale": data.scale || 1.0,
                    "width": 0, "height": 0, "x": 0, "y": 0 
                };
            }
            if (CompositorService && CompositorService.onDisplayScalesUpdated) {
                CompositorService.onDisplayScalesUpdated(scalesMap);
            }
            root.displayScalesChanged();
        }
    }

    // 4. PROCESSES

    Process {
        id: eventStream
        running: false
        command: config.query.eventStream
        stdout: SplitParser {
            onRead: (line) => {
                if (line.includes("selmon") && line.includes(" 1")) {
                    const parts = line.split(' ');
                    if (parts.length >= 3) root.selectedMonitor = parts[0];
                    return;
                }
                internal.streamBuffer += line + "\n";
                if (line.match(config.reTagBinary)) {
                    internal.processFrame(internal.streamBuffer);
                    internal.streamBuffer = ""; 
                }
            }
        }
        onExited: (code) => { if (code !== 0) restartTimer.start(); }
    }
    Timer { id: restartTimer; interval: 1000; onTriggered: if(initialized) eventStream.running = true }

    Process {
        id: procInitial
        command: config.query.workspaces
        stdout: SplitParser { onRead: (line) => internal.streamBuffer += line + "\n" }
        onExited: (code) => {
            if (code === 0) {
                internal.processFrame(internal.streamBuffer);
                internal.streamBuffer = "";
            }
        }
    }

    Process {
        id: procOutputs
        command: config.query.outputs
        stdout: SplitParser {
            onRead: (line) => {
                const match = line.match(config.reScale);
                if (match) {
                    const out = match[1];
                    const scale = parseFloat(match[2]);
                    if (!internal.monitorScales[out]) internal.monitorScales[out] = {};
                    internal.monitorScales[out].scale = scale;
                }
            }
        }
        onExited: (code) => { if (code === 0) internal.updateScales(); }
    }

    // 5. WAYLAND & INIT

    Connections {
        target: ToplevelManager
        function onToplevelsChanged() { internal.updateWindowList(); }
    }
    Timer {
        interval: 200; running: true; repeat: true
        onTriggered: internal.updateWindowList()
    }

    function initialize() {
        if (initialized) return;
        Logger.i("MangoService", "Service Started");
        
        procOutputs.running = true;
        procInitial.running = true;
        eventStream.running = true;
        Quickshell.execDetached(["mmsg", "-g", "-o"]); 
        
        initialized = true;
    }

    function queryDisplayScales() { procOutputs.running = true; }

    function switchToWorkspace(workspace) {
        const tagId = workspace.idx || workspace.id || config.defaultWorkspaceId;
        const output = workspace.output || root.selectedMonitor || "";
        const cmd = config.action.tag.slice();
        if (output && Object.keys(internal.monitorScales).length > 1) cmd.push("-o", output);
        cmd.push(tagId.toString());
        Quickshell.execDetached(cmd);
    }

    function focusWindow(window) {
        if (window && window.handle) window.handle.activate();
        else if (window.workspaceId) switchToWorkspace({ id: window.workspaceId, output: window.output });
    }

    function closeWindow(window) {
        if (window && window.handle) window.handle.close();
        else Quickshell.execDetached(config.action.killClient);
    }

    function logout() { Quickshell.execDetached(config.action.quit); }
}