ARK-OS/arkos/arkrt/ArkGraphics/ArkGraphics.swift

//
// Copyright 2026 Aarav Ravindra Kharade
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//

import ark.sys.libc

// -
//  ArkGraphics — Display Client Library
// -
//  Client-side library that connects to the ArkOS Display Daemon
//  via /dev/display.sock and sends rendering commands.
//
//  This is the rendering API used by all ArkOS UI applications.
//  Commands are sent as packed binary structs over a Unix domain
//  socket for minimal overhead.
//
//  Usage:
//    let gfx = ArkGraphics()
//    gfx.clear(r: 30, g: 30, b: 35)
//    gfx.fillRect(x: 100, y: 100, w: 200, h: 50, r: 0, g: 120, b: 215)
//    gfx.drawLine(x1: 10, y1: 10, x2: 200, y2: 200, r: 255, g: 255, b: 255)
//    gfx.pan()  // Present to screen
//
// -

// - Wire Protocol -

/// Packed command structure sent to the display daemon.
/// Total size: 25 bytes (1 + 5*4 + 4*1).
private struct DisplayCommand {
    var cmd: UInt8       // Command ID (1=fillRect, 2=pan, 3=clear, 4=fillRoundedRect)
    var x: Int32         // X coordinate (or 0 for non-spatial commands)
    var y: Int32         // Y coordinate
    var w: Int32         // Width
    var h: Int32         // Height
    var r: UInt8         // Red   (0–255)
    var g: UInt8         // Green (0–255)
    var b: UInt8         // Blue  (0–255)
    var a: UInt8         // Alpha (0–255)
    var radius: Int32    // Border radius
}

// - Graphics Client -

/// Client-side handle to the display daemon. Manages the socket
/// connection and provides high-level drawing primitives.
// C bridge to bypass varargs issues in Swift's ioctl binding
@_silgen_name("ioctl")
func ioctl_fb(_ fd: Int32, _ request: UInt, _ info: UnsafeMutableRawPointer) -> Int32

public class ArkGraphics {
    /// File descriptor for the Unix domain socket connection.
    private var fd: Int32 = -1

    /// Path to the display daemon socket.
    private let socketPath = "/dev/display.sock"

    /// Maximum connection retry attempts on initialization.
    private let maxRetries = 30

    private let retryDelay: useconds_t = 500_000 // 500ms

    public var screenWidth: Int = 1024
    public var screenHeight: Int = 768

    /// Creates a new graphics client and connects to the display daemon.
    /// Retries up to 10 times with 500ms delay (total 5s) to allow the
    /// daemon time to start during boot.
    public init() {
        for attempt in 1...maxRetries {
            if tryConnect() {
                break
            }
            if attempt < maxRetries {
                usleep(retryDelay)
            }
        }
        
        if !isConnected {
            print("ArkGraphics: WARNING — Failed to connect to display daemon after \(maxRetries) attempts")
        }

        // Query real resolution from fb0 (guaranteed to exist if daemon is running)
        let fb_fd = ark_open2("/dev/fb0", O_RDONLY)
        if fb_fd >= 0 {
            // Memory layout of fb_var_screeninfo (ABI compatible with Linux)
            struct fb_var_screeninfo {
                var xres: UInt32 = 0
                var yres: UInt32 = 0
                var xres_virtual: UInt32 = 0
                var yres_virtual: UInt32 = 0
                var xoffset: UInt32 = 0
                var yoffset: UInt32 = 0
                var bits_per_pixel: UInt32 = 0
                var grayscale: UInt32 = 0
                var red: (UInt32, UInt32, UInt32) = (0,0,0)
                var green: (UInt32, UInt32, UInt32) = (0,0,0)
                var blue: (UInt32, UInt32, UInt32) = (0,0,0)
                var transp: (UInt32, UInt32, UInt32) = (0,0,0)
                var nonstd: UInt32 = 0
                var activate: UInt32 = 0
                var height: UInt32 = 0
                var width: UInt32 = 0
                var accel_flags: UInt32 = 0
                var pixclock: UInt32 = 0
                var left_margin: UInt32 = 0
                var right_margin: UInt32 = 0
                var upper_margin: UInt32 = 0
                var lower_margin: UInt32 = 0
                var hsync_len: UInt32 = 0
                var vsync_len: UInt32 = 0
                var sync: UInt32 = 0
                var vmode: UInt32 = 0
                var reserved: (UInt32, UInt32, UInt32, UInt32, UInt32, UInt32) = (0, 0, 0, 0, 0, 0)
            }
            var vinfo = fb_var_screeninfo()
            let FBIOGET_VSCREENINFO: UInt = 0x4600
            if ioctl_fb(fb_fd, FBIOGET_VSCREENINFO, &vinfo) >= 0 {
                self.screenWidth = Int(vinfo.xres) > 0 ? Int(vinfo.xres) : 1920
                self.screenHeight = Int(vinfo.yres) > 0 ? Int(vinfo.yres) : 1080
            }
            close(fb_fd)
        }
        
        if let str = ArkSys.File.readString("/tmp/screen_size.txt") {
            var w = 0
            var h = 0
            var parsingW = true
            for char in str {
                if char == " " {
                    parsingW = false
                } else if let num = char.wholeNumberValue {
                    if parsingW {
                        w = w * 10 + num
                    } else {
                        h = h * 10 + num
                    }
                }
            }
            if w > 0 && h > 0 {
                self.screenWidth = w
                self.screenHeight = h
            }
        }
        
        // Final fallback if ioctl and file fail
        if self.screenWidth <= 0 { self.screenWidth = 1920 }
        if self.screenHeight <= 0 { self.screenHeight = 1080 }
    }

    deinit {
        if fd >= 0 { close(fd) }
    }

    // - Connection Management -

    /// Attempts to connect to the display daemon socket.
    /// Returns true on success, false on failure.
    private func tryConnect() -> Bool {
        #if canImport(Glibc)
        let sock = socket(AF_UNIX, Int32(SOCK_STREAM.rawValue), 0)
        #else
        let sock = socket(AF_UNIX, Int32(SOCK_STREAM), 0)
        #endif
        if sock < 0 { return false }

        var addr = sockaddr_un()
        addr.sun_family = sa_family_t(AF_UNIX)

        let pathBytes = socketPath.utf8CString
        withUnsafeMutablePointer(to: &addr.sun_path) { sunPathPtr in
            let rawPtr = UnsafeMutableRawPointer(sunPathPtr).assumingMemoryBound(to: CChar.self)
            for i in 0..<min(pathBytes.count, 108) {
                rawPtr[i] = pathBytes[i]
            }
        }

        let addrSize = MemoryLayout<sockaddr_un>.size
        let connectResult = withUnsafePointer(to: &addr) { addrPtr in
            addrPtr.withMemoryRebound(to: sockaddr.self, capacity: 1) { saPtr in
                connect(sock, saPtr, socklen_t(addrSize))
            }
        }

        if connectResult < 0 {
            close(sock)
            return false
        }

        self.fd = sock
        return true
    }

    /// Returns true if connected to the display daemon.
    public var isConnected: Bool {
        return fd >= 0
    }

    // - Rendering Commands -

    @inline(__always)
    private func toTopLeftY(y: Int, h: Int) -> Int32 {
        return Int32(screenHeight - y - h)
    }


    /// Fills a rectangle with a solid RGB color.
    ///
    /// - Parameters:
    ///   - x: Left edge in pixels
    ///   - y: Top edge in pixels
    ///   - w: Width in pixels
    ///   - h: Height in pixels
    ///   - r: Red component (0–255)
    ///   - g: Green component (0–255)
    ///   - b: Blue component (0–255)
    public func fillRectRGB(x: Int, y: Int, w: Int, h: Int,
                            r: UInt8, g: UInt8, b: UInt8) {
        sendCommand(DisplayCommand(
            cmd: 1, x: Int32(x), y: toTopLeftY(y: y, h: h), w: Int32(w), h: Int32(h),
            r: r, g: g, b: b, a: 255, radius: 0
        ))
    }

    /// Fills a rectangle with an RGBA color, blending it with the background.
    public func fillRectRGBA(x: Int, y: Int, w: Int, h: Int,
                             r: UInt8, g: UInt8, b: UInt8, a: UInt8) {
        sendCommand(DisplayCommand(
            cmd: 1, x: Int32(x), y: toTopLeftY(y: y, h: h), w: Int32(w), h: Int32(h),
            r: r, g: g, b: b, a: a, radius: 0
        ))
    }
    
    /// Fills a rounded rectangle with a solid RGB color.
    public func fillRoundedRectRGB(x: Int, y: Int, w: Int, h: Int,
                                   r: UInt8, g: UInt8, b: UInt8, radius: Int) {
        sendCommand(DisplayCommand(
            cmd: 4, x: Int32(x), y: toTopLeftY(y: y, h: h), w: Int32(w), h: Int32(h),
            r: r, g: g, b: b, a: 255, radius: Int32(radius)
        ))
    }

    /// Fills a rounded rectangle with an RGBA color.
    public func fillRoundedRectRGBA(x: Int, y: Int, w: Int, h: Int,
                                    r: UInt8, g: UInt8, b: UInt8, a: UInt8, radius: Int) {
        sendCommand(DisplayCommand(
            cmd: 4, x: Int32(x), y: toTopLeftY(y: y, h: h), w: Int32(w), h: Int32(h),
            r: r, g: g, b: b, a: a, radius: Int32(radius)
        ))
    }

    /// Clears the entire screen to a solid RGB color.
    public func clear(r: UInt8, g: UInt8, b: UInt8) {
        sendCommand(DisplayCommand(
            cmd: 3, x: 0, y: 0, w: 0, h: 0,
            r: r, g: g, b: b, a: 255, radius: 0
        ))
    }

    /// Presents the current back buffer to the screen (page flip).
    /// Must be called after all drawing commands to make them visible.
    public func pan() {
        sendCommand(DisplayCommand(
            cmd: 2, x: 0, y: 0, w: 0, h: 0,
            r: 0, g: 0, b: 0, a: 0, radius: 0
        ))
    }

    /// Draws a horizontal line of 1 pixel height.
    public func drawHLine(x: Int, y: Int, w: Int,
                          r: UInt8, g: UInt8, b: UInt8) {
        fillRectRGB(x: x, y: y, w: w, h: 1, r: r, g: g, b: b)
    }

    /// Draws a vertical line of 1 pixel width.
    public func drawVLine(x: Int, y: Int, h: Int,
                          r: UInt8, g: UInt8, b: UInt8) {
        fillRectRGB(x: x, y: y, w: 1, h: h, r: r, g: g, b: b)
    }

    /// Draws a rectangle outline (border only, no fill).
    ///
    /// - Parameters:
    ///   - thickness: Border width in pixels (default 1)
    public func drawRectOutline(x: Int, y: Int, w: Int, h: Int,
                                r: UInt8, g: UInt8, b: UInt8,
                                thickness: Int = 1) {
        // Top edge
        fillRectRGB(x: x, y: y, w: w, h: thickness, r: r, g: g, b: b)
        // Bottom edge
        fillRectRGB(x: x, y: y + h - thickness, w: w, h: thickness, r: r, g: g, b: b)
        // Left edge
        fillRectRGB(x: x, y: y, w: thickness, h: h, r: r, g: g, b: b)
        // Right edge
        fillRectRGB(x: x + w - thickness, y: y, w: thickness, h: h, r: r, g: g, b: b)
    }

    // - Internal Transport -

    private func sendCommand(_ cmd: DisplayCommand) {
        if fd < 0 { return }
        let buffer = UnsafeMutablePointer<UInt8>.allocate(capacity: 25)
        defer { buffer.deallocate() }
        
        buffer[0] = cmd.cmd
        
        var x = cmd.x
        var y = cmd.y
        var w = cmd.w
        var h = cmd.h
        var radius = cmd.radius
        
        _ = withUnsafePointer(to: &x) { memcpy(buffer + 1, $0, 4) }
        _ = withUnsafePointer(to: &y) { memcpy(buffer + 5, $0, 4) }
        _ = withUnsafePointer(to: &w) { memcpy(buffer + 9, $0, 4) }
        _ = withUnsafePointer(to: &h) { memcpy(buffer + 13, $0, 4) }
        
        buffer[17] = cmd.r
        buffer[18] = cmd.g
        buffer[19] = cmd.b
        buffer[20] = cmd.a
        
        _ = withUnsafePointer(to: &radius) { memcpy(buffer + 21, $0, 4) }
        
        var totalWritten = 0
        while totalWritten < 25 {
            let written = write(fd, buffer + totalWritten, 25 - totalWritten)
            if written <= 0 { break }
            totalWritten += Int(written)
        }
    }
}