pragma Singleton
import Quickshell
import QtQuick
import Quickshell.Io

Singleton {
    id: updateService
    
    // Core properties
    readonly property bool busy: checkupdatesProcess.running
    readonly property int updates: updatePackages.length
    property var updatePackages: []
    property var selectedPackages: []
    property int selectedPackagesCount: 0
    property bool updateInProgress: false
    
    // Process for checking updates
    Process {
        id: checkupdatesProcess
        command: ["checkupdates"]
        onExited: function(exitCode) {
            if (exitCode !== 0 && exitCode !== 2) {
                console.warn("[UpdateService] checkupdates failed (code:", exitCode, ")");
                updatePackages = [];
                return;
            }
        }
        stdout: StdioCollector {
            onStreamFinished: {
                parseCheckupdatesOutput(text);
            }
        }
    }
    
    // Parse checkupdates output
    function parseCheckupdatesOutput(output) {
        const lines = output.trim().split('\n').filter(line => line.trim());
        const packages = [];
        
        for (const line of lines) {
            const m = line.match(/^(\S+)\s+([^\s]+)\s+->\s+([^\s]+)$/);
            if (m) {
                packages.push({
                    name: m[1],
                    oldVersion: m[2],
                    newVersion: m[3],
                    description: `${m[1]} ${m[2]} -> ${m[3]}`
                });
            }
        }
        
        updatePackages = packages;
    }
    
    // Check for updates
    function doPoll() {
        if (busy) return;
        checkupdatesProcess.running = true;
    }
    
    // Update all packages
    function runUpdate() {
        if (updates === 0) {
            doPoll();
            return;
        }
        
        updateInProgress = true;
        Quickshell.execDetached(["pkexec", "pacman", "-Syu", "--noconfirm"]);
        
        // Refresh after updates with multiple attempts
        refreshAfterUpdate();
    }
    
    // Update selected packages
    function runSelectiveUpdate() {
        if (selectedPackages.length === 0) return;
        
        updateInProgress = true;
        const command = ["pkexec", "pacman", "-S", "--noconfirm"].concat(selectedPackages);
        Quickshell.execDetached(command);
        
        // Clear selection and refresh
        selectedPackages = [];
        selectedPackagesCount = 0;
        refreshAfterUpdate();
    }
    
    // Package selection functions
    function togglePackageSelection(packageName) {
        const index = selectedPackages.indexOf(packageName);
        if (index > -1) {
            selectedPackages.splice(index, 1);
        } else {
            selectedPackages.push(packageName);
        }
        selectedPackagesCount = selectedPackages.length;
    }
    
    function selectAllPackages() {
        selectedPackages = updatePackages.map(pkg => pkg.name);
        selectedPackagesCount = selectedPackages.length;
    }
    
    function deselectAllPackages() {
        selectedPackages = [];
        selectedPackagesCount = 0;
    }
    
    function isPackageSelected(packageName) {
        return selectedPackages.indexOf(packageName) > -1;
    }
    
    // Robust refresh after updates
    function refreshAfterUpdate() {
        // First refresh attempt after 3 seconds
        Qt.callLater(() => {
            doPoll();
        }, 3000);
        
        // Second refresh attempt after 8 seconds
        Qt.callLater(() => {
            doPoll();
        }, 8000);
        
        // Third refresh attempt after 15 seconds
        Qt.callLater(() => {
            doPoll();
            updateInProgress = false;
        }, 15000);
        
        // Final refresh attempt after 30 seconds
        Qt.callLater(() => {
            doPoll();
        }, 30000);
    }
    
    // Notification helper
    function notify(title, body) {
        Quickshell.execDetached(["notify-send", "-a", "UpdateService", "-i", "system-software-update", title, body]);
    }
    
    // Auto-poll every 15 minutes
    Timer {
        interval: 15 * 60 * 1000 // 15 minutes
        repeat: true
        running: true
        onTriggered: doPoll()
    }
    
    // Initial check
    Component.onCompleted: doPoll()
}