ARK-OS/arkos/system/swift_splash.swift

import Foundation
#if canImport(Glibc)
import Glibc
#endif

// ── Framebuffer structs ──

struct fb_bitfield {
    var offset: UInt32 = 0
    var length: UInt32 = 0
    var msb_right: UInt32 = 0
}

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: fb_bitfield = fb_bitfield()
    var green: fb_bitfield = fb_bitfield()
    var blue: fb_bitfield = fb_bitfield()
    var transp: fb_bitfield = fb_bitfield()
    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)
}

struct fb_fix_screeninfo {
    var id: (Int8, Int8, Int8, Int8, Int8, Int8, Int8, Int8,
             Int8, Int8, Int8, Int8, Int8, Int8, Int8, Int8) =
        (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)
    var smem_start: UInt = 0
    var smem_len: UInt32 = 0
    var type: UInt32 = 0
    var type_aux: UInt32 = 0
    var visual: UInt32 = 0
    var xpanstep: UInt16 = 0
    var ypanstep: UInt16 = 0
    var ywrapstep: UInt16 = 0
    var line_length: UInt32 = 0
    var mmio_start: UInt = 0
    var mmio_len: UInt32 = 0
    var accel: UInt32 = 0
    var reserved: (UInt16, UInt16, UInt16) = (0, 0, 0)
}

@_silgen_name("get_vinfo")
func get_vinfo(_ fd: Int32, _ vinfo: UnsafeMutableRawPointer) -> Int32

@_silgen_name("get_finfo")
func get_finfo(_ fd: Int32, _ finfo: UnsafeMutableRawPointer) -> Int32

@_silgen_name("pan_display")
func pan_display(_ fd: Int32, _ vinfo: UnsafeMutableRawPointer) -> Int32

// ══════════════════════════════════════════════════════════════════
//  Anti-Aliased High-Resolution Back-Buffered Renderer
// ══════════════════════════════════════════════════════════════════

let AW = 600
let AH = 600
let AC = 300
let ABUFSZ = AW * AH * 4

// Geometry
let NUC_R    = 28
let INNER_R  = 120
let OUTER_R  = 200
let ELEC_R   = 12
let RING_T   = 2.0

// Draw filled disk with anti-aliasing (smooth corners)
func diskAA(_ p: UnsafeMutablePointer<UInt8>, _ cx: Double, _ cy: Double, _ r: Double, _ val: UInt8) {
    let y0 = max(0, Int(cy - r - 2))
    let y1 = min(AH - 1, Int(cy + r + 2))
    let x0 = max(0, Int(cx - r - 2))
    let x1 = min(AW - 1, Int(cx + r + 2))
    
    let rInner = r - 0.5
    let rInnerSq = rInner * rInner
    let rOuter = r + 0.5
    let rOuterSq = rOuter * rOuter
    
    let fVal = Double(val)
    for y in y0...y1 {
        let dy = Double(y) - cy
        let dySq = dy * dy
        let rowBase = y * AW * 4
        for x in x0...x1 {
            let dx = Double(x) - cx
            let distSq = dx * dx + dySq
            if distSq < rInnerSq {
                let off = rowBase + x * 4
                p[off]     = max(p[off], val)
                p[off + 1] = max(p[off + 1], val)
                p[off + 2] = max(p[off + 2], val)
            } else if distSq < rOuterSq {
                let dist = sqrt(distSq)
                let alpha = rOuter - dist
                let v = UInt8(fVal * alpha)
                let off = rowBase + x * 4
                p[off]     = max(p[off], v)
                p[off + 1] = max(p[off + 1], v)
                p[off + 2] = max(p[off + 2], v)
            }
        }
    }
}

// Draw ring outline with anti-aliasing (smooth curves)
func ringAA(_ p: UnsafeMutablePointer<UInt8>, _ cx: Double, _ cy: Double, _ r: Double, _ t: Double, _ val: UInt8) {
    let scan = r + t + 2
    let y0 = max(0, Int(cy - scan))
    let y1 = min(AH - 1, Int(cy + scan))
    let x0 = max(0, Int(cx - scan))
    let x1 = min(AW - 1, Int(cx + scan))
    
    let rInMin = r - t - 0.5
    let rInMax = r - t + 0.5
    let rOutMin = r + t - 0.5
    let rOutMax = r + t + 0.5
    
    let rInMinSq = rInMin * rInMin
    let rInMaxSq = rInMax * rInMax
    let rOutMinSq = rOutMin * rOutMin
    let rOutMaxSq = rOutMax * rOutMax
    
    let tOuter = t + 0.5
    let fVal = Double(val)
    
    for y in y0...y1 {
        let dy = Double(y) - cy
        let dySq = dy * dy
        let rowBase = y * AW * 4
        for x in x0...x1 {
            let dx = Double(x) - cx
            let d = dx * dx + dySq
            if d >= rInMaxSq && d <= rOutMinSq {
                // Fully inside the ring
                let off = rowBase + x * 4
                p[off]     = max(p[off], val)
                p[off + 1] = max(p[off + 1], val)
                p[off + 2] = max(p[off + 2], val)
            } else if (d >= rInMinSq && d < rInMaxSq) || (d > rOutMinSq && d <= rOutMaxSq) {
                // On the inner or outer edge
                let dist = sqrt(d)
                let diff = abs(dist - r)
                let alpha = tOuter - diff
                let v = UInt8(fVal * alpha)
                let off = rowBase + x * 4
                p[off]     = max(p[off], v)
                p[off + 1] = max(p[off + 1], v)
                p[off + 2] = max(p[off + 2], v)
            }
        }
    }
}

// Blit buffer to framebuffer
func blit(_ src: UnsafeMutablePointer<UInt8>,
          _ fbp: UnsafeMutablePointer<UInt8>,
          _ sx: Int, _ sy: Int,
          _ lineLen: Int, _ scrH: Int,
          _ fd: Int32, _ vinfo: UnsafeMutableRawPointer) {
    for y in 0..<AH {
        let fy = sy + y
        if fy < 0 || fy >= scrH { continue }
        memcpy(fbp + fy * lineLen + sx * 4,
               src + y * AW * 4,
               AW * 4)
    }
    _ = pan_display(fd, vinfo)
}

// ── Isolated IPC Client (talks to arkrt daemon) ──

func queryIPC(cmdId: UInt16, payload: String = "") -> String {
    let fd = socket(AF_UNIX, 1, 0)
    if fd < 0 { return "ERROR" }
    defer { close(fd) }
    
    var addr = sockaddr_un()
    addr.sun_family = sa_family_t(AF_UNIX)
    let socketPath = "/dev/arkrt.sock"
    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(fd, saPtr, socklen_t(addrSize))
        }
    }
    
    if connectResult < 0 {
        return "OFFLINE"
    }
    
    // Construct strict binary request header
    let payloadData = payload.data(using: .utf8) ?? Data()
    var request = Data()
    var bigEndianCmd = cmdId.bigEndian
    var bigEndianLen = UInt32(payloadData.count).bigEndian
    withUnsafeBytes(of: &bigEndianCmd) { request.append(contentsOf: $0) }
    withUnsafeBytes(of: &bigEndianLen) { request.append(contentsOf: $0) }
    request.append(payloadData)
    
    // Send request
    request.withUnsafeBytes { reqBytes in
        _ = write(fd, reqBytes.baseAddress, reqBytes.count)
    }
    
    // Read response
    let bufSize = 4096
    let respBuf = UnsafeMutablePointer<UInt8>.allocate(capacity: bufSize)
    defer { respBuf.deallocate() }
    
    let bytesRead = read(fd, respBuf, bufSize)
    if bytesRead < 6 {
        return "ERROR_RESP"
    }
    
    let responseBuffer = UnsafeRawBufferPointer(start: respBuf, count: bytesRead)
    let respCmd = responseBuffer.load(fromByteOffset: 0, as: UInt16.self).bigEndian
    let respLen = responseBuffer.load(fromByteOffset: 2, as: UInt32.self).bigEndian
    
    if respCmd == cmdId && bytesRead >= 6 + Int(respLen) {
        let respPayloadBytes = UnsafeRawBufferPointer(rebasing: responseBuffer[6..<(6 + Int(respLen))])
        return String(decoding: respPayloadBytes, as: UTF8.self)
    }
    
    return "INVALID_DATA"
}

// ══════════════════════════════════════════════════════════════════

func drawSwiftSplash() {
    let fd = open("/dev/fb0", O_RDWR)
    if fd < 0 { print("Error: Cannot open /dev/fb0"); return }

    var vinfo = fb_var_screeninfo()
    if get_vinfo(fd, &vinfo) < 0 { close(fd); return }

    var finfo = fb_fix_screeninfo()
    if get_finfo(fd, &finfo) < 0 { close(fd); return }

    let scrW    = Int(vinfo.xres)
    let scrH    = Int(vinfo.yres)
    let bpp     = Int(vinfo.bits_per_pixel) / 8
    let lineLen = Int(finfo.line_length)
    let scrSz   = Int(finfo.smem_len)

    let fb_ptr = mmap(nil, scrSz, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0)
    if fb_ptr == MAP_FAILED { close(fd); return }
    let fbp = fb_ptr!.bindMemory(to: UInt8.self, capacity: scrSz)

    // ── Clear entire screen to BLACK immediately ──
    memset(fbp, 0, scrSz)

    // Allocate raw pointer buffers
    let tpl  = UnsafeMutablePointer<UInt8>.allocate(capacity: ABUFSZ)  // template
    let work = UnsafeMutablePointer<UInt8>.allocate(capacity: ABUFSZ)  // workspace

    // Centered coordinates
    let sx = (scrW - AW) / 2
    let sy = (scrH - AH) / 2

    // ── Pre-render static nucleus template ──
    memset(tpl, 0, ABUFSZ)
    diskAA(tpl, Double(AC), Double(AC), Double(NUC_R), 255)

    // ── Phase 1: Spawn & Orbit Expansion (35 frames) ──
    for frame in 0..<35 {
        memset(work, 0, ABUFSZ)
        
        let t = Double(frame) / 34.0
        let easeOut = 1.0 - pow(1.0 - t, 3.0)
        
        let curInnerR = Double(INNER_R) * easeOut
        let curOuterR = Double(OUTER_R) * easeOut
        let curElR = max(1.0, Double(ELEC_R) * easeOut)
        let ringBright = UInt8(60.0 * easeOut)
        
        diskAA(work, Double(AC), Double(AC), Double(NUC_R), 255)
        
        if curInnerR > Double(NUC_R) {
            ringAA(work, Double(AC), Double(AC), curInnerR, RING_T, ringBright)
        }
        if curOuterR > Double(NUC_R) {
            ringAA(work, Double(AC), Double(AC), curOuterR, RING_T, ringBright)
        }
        
        let angle = Double(frame) * 0.10
        
        for i in 0..<2 {
            let a = angle + Double(i) * Double.pi
            let ex = Double(AC) + cos(a) * curInnerR
            let ey = Double(AC) + sin(a) * curInnerR
            diskAA(work, ex, ey, curElR, 255)
        }
        
        for i in 0..<2 {
            let a = -angle * 0.6 + Double(i) * Double.pi
            let ex = Double(AC) + cos(a) * curOuterR
            let ey = Double(AC) + sin(a) * curOuterR
            diskAA(work, ex, ey, curElR, 255)
        }
        
        blit(work, fbp, sx, sy, lineLen, scrH, fd, &vinfo)
        usleep(16666)
    }

    // ── Pre-render static stable orbit template for Phase 2 ──
    memset(tpl, 0, ABUFSZ)
    diskAA(tpl, Double(AC), Double(AC), Double(NUC_R), 255)
    ringAA(tpl, Double(AC), Double(AC), Double(INNER_R), RING_T, 60)
    ringAA(tpl, Double(AC), Double(AC), Double(OUTER_R), RING_T, 60)

    // ── Phase 2: Stable Orbiting (150 frames ≈ 2.5 seconds at 60fps) ──
    for frame in 0..<150 {
        memcpy(work, tpl, ABUFSZ)
        
        let angle = (35.0 * 0.10) + Double(frame) * 0.05
        
        for i in 0..<2 {
            let a = angle + Double(i) * Double.pi
            let ex = Double(AC) + cos(a) * Double(INNER_R)
            let ey = Double(AC) + sin(a) * Double(INNER_R)
            diskAA(work, ex, ey, Double(ELEC_R), 255)
        }
        
        for i in 0..<2 {
            let a = -angle * 0.6 + Double(i) * Double.pi
            let ex = Double(AC) + cos(a) * Double(OUTER_R)
            let ey = Double(AC) + sin(a) * Double(OUTER_R)
            diskAA(work, ex, ey, Double(ELEC_R), 255)
        }
        
        blit(work, fbp, sx, sy, lineLen, scrH, fd, &vinfo)
        usleep(16666)
    }

    // ── Phase 3: Spiral Inward & Crash (30 frames) ──
    let baseAngle = (35.0 * 0.10) + (150.0 * 0.05)
    for frame in 0..<30 {
        memset(work, 0, ABUFSZ)
        
        let t = Double(frame) / 29.0
        let easeIn = t * t
        
        let curInner = Double(INNER_R) * (1.0 - easeIn)
        let curOuter = Double(OUTER_R) * (1.0 - easeIn)
        let curElR = max(1.0, Double(ELEC_R) * (1.0 - easeIn))
        let nucG = Double(NUC_R) + easeIn * 20.0
        
        diskAA(work, Double(AC), Double(AC), nucG, 255)
        
        if curInner > nucG + 2.0 {
            ringAA(work, Double(AC), Double(AC), curInner, RING_T, UInt8(60.0 * (1.0 - t)))
        }
        if curOuter > nucG + 2.0 {
            ringAA(work, Double(AC), Double(AC), curOuter, RING_T, UInt8(60.0 * (1.0 - t)))
        }
        
        let angle = baseAngle + t * Double.pi * 6.0
        
        if curElR > 1.0 {
            for i in 0..<2 {
                let a = angle + Double(i) * Double.pi
                diskAA(work, Double(AC) + cos(a) * curInner,
                       Double(AC) + sin(a) * curInner, curElR, 255)
            }
            for i in 0..<2 {
                let a = -angle * 0.6 + Double(i) * Double.pi
                diskAA(work, Double(AC) + cos(a) * curOuter,
                       Double(AC) + sin(a) * curOuter, curElR, 255)
            }
        }
        
        blit(work, fbp, sx, sy, lineLen, scrH, fd, &vinfo)
        usleep(16666)
    }

    // ── Phase 4: Flash & Fade to Black (20 frames) ──
    let finalNucG = Double(NUC_R) + 20.0
    for frame in 0..<20 {
        memset(work, 0, ABUFSZ)
        let t = Double(frame) / 19.0
        let flashR = min(Double(AC - 1), finalNucG + t * 240.0)
        let bright = UInt8(max(0.0, 255.0 * (1.0 - t)))
        if bright > 0 {
            diskAA(work, Double(AC), Double(AC), flashR, bright)
        }
        blit(work, fbp, sx, sy, lineLen, scrH, fd, &vinfo)
        usleep(16666)
    }

    // ── Clear to BLACK ──
    memset(fbp, 0, scrSz)
    _ = pan_display(fd, &vinfo)

    // ── Splash screen ──
    print("\u{1B}[0;40m\u{1B}[2J\u{1B}[H", terminator: "")
    print("""
      SSSS  W   W  IIIII  FFFFF  TTTTT
     S      W   W    I    F        T
      SSS   W W W    I    FFF      T
         S  WW WW    I    F        T
     SSSS   W   W  IIIII  F        T
    """)
    print("\nArkOS Initialized. Drawing 'Swift' via native Swift runtime!\n")

    // Draw gradient below text
    for y in 200..<scrH {
        for x in 0..<scrW {
            let off = (x + Int(vinfo.xoffset)) * bpp +
                      (y + Int(vinfo.yoffset)) * lineLen
            fbp[off]     = UInt8((x * 255) / scrW)
            fbp[off + 1] = UInt8((y * 255) / scrH)
            fbp[off + 2] = 255 - UInt8((x * 255) / scrW)
            fbp[off + 3] = 0
        }
    }
    _ = pan_display(fd, &vinfo)

    tpl.deallocate()
    work.deallocate()
    munmap(fb_ptr, scrSz)
    close(fd)

    // Query system info from the background system service daemon (arkrt)
    let ip = queryIPC(cmdId: 102)
    let battery = queryIPC(cmdId: 103)
    let sysTime = queryIPC(cmdId: 101)
    
    print("──────────────────────────────────────────────────────")
    print("  ArkOS Service Framework Status (Via Isolated IPC):")
    print("  - Interface IP  : \(ip)")
    print("  - System Time   : \(sysTime)")
    print("  - Battery Level : \(battery)")
    print("──────────────────────────────────────────────────────\n")

    while true {
        usleep(500_000)
    }
}

drawSwiftSplash()