iOS Integration

import SwiftUI

struct ContentView: View {
    @StateObject private var state = EmulatorState()
    
    var body: some View {
        ZStack {
            if state.romLoaded {
                EmulatorView(state: state)
            } else {
                RomLoadingView(state: state)
            }
        }
        .onAppear {
            // Create emulator instance
            _ = state.emulator.create()
            
            // Try to restore last session
            state.tryRestoreLastSession()
        }
    }
}

class EmulatorState: ObservableObject {
    let emulator = EmulatorBridge()
    @Published var romLoaded = false
    @Published var isRunning = false
    @Published var screenImage: CGImage?
    
    init() {
        // Initialize backend from saved preference
        if let preferred = EmulatorPreferences.getEffectiveBackend() {
            _ = EmulatorBridge.setBackend(preferred)
        }
    }
    
    deinit {
        emulator.destroy()
    }
}

// Load ROM from Data
func loadRom(_ data: Data, name: String) {
    let result = emulator.loadRom(data)
    
    if result == 0 {
        romLoaded = true
        romName = name
        romSize = data.count
        
        // Try to restore saved state
        let hash = StateManager.shared.romHash(data)
        if StateManager.shared.loadState(emulator: emulator, romHash: hash) {
            print("State restored")
        } else {
            print("No saved state, waiting for ON key press")
        }
        
        isRunning = true
        startEmulation()
    } else {
        print("Failed to load ROM: error \(result)")
    }
}

func startEmulation() {
    emulationTask = Task.detached(priority: .userInitiated) { [weak self] in
        guard let self = self else { return }
        
        while !Task.isCancelled {
            let running = await MainActor.run { self.isRunning }
            guard running else {
                try? await Task.sleep(nanoseconds: 16_000_000)  // 16ms
                continue
            }
            
            let frameStart = Date()
            
            // Run 800,000 cycles per frame (48MHz / 60 FPS)
            let cycles = await MainActor.run { self.cyclesPerTick }  // 800,000
            let executed = self.emulator.runCycles(cycles)
            
            await MainActor.run {
                self.totalCyclesExecuted += Int64(executed)
                self.frameCounter += 1
                self.screenImage = self.emulator.makeImage()
                self.isLcdOn = self.emulator.isLcdOn()
            }
            
            // Cap at 60 FPS
            let elapsed = Date().timeIntervalSince(frameStart)
            let remaining = 0.016 - elapsed
            if remaining > 0 {
                try? await Task.sleep(nanoseconds: UInt64(remaining * 1_000_000_000))
            }
        }
    }
}

func stopEmulation() {
    emulationTask?.cancel()
    emulationTask = nil
}

// Get screen image
if let screenImage = state.screenImage {
    Image(decorative: screenImage, scale: 1.0)
        .interpolation(.none)  // Nearest-neighbor for pixels
        .aspectRatio(contentMode: .fit)
        .frame(width: 320, height: 240)
} else {
    // Black screen (LCD off)
    Rectangle()
        .fill(Color.black)
        .frame(width: 320, height: 240)
}

func makeImage() -> CGImage? {
    let (fb, w, h) = framebuffer()
    guard let fb = fb, w > 0, h > 0 else { return nil }
    
    let colorSpace = CGColorSpaceCreateDeviceRGB()
    let bitmapInfo = CGBitmapInfo(
        rawValue: CGImageAlphaInfo.premultipliedFirst.rawValue | 
                  CGBitmapInfo.byteOrder32Little.rawValue
    )
    
    guard let context = CGContext(
        data: UnsafeMutableRawPointer(mutating: fb),
        width: Int(w),
        height: Int(h),
        bitsPerComponent: 8,
        bytesPerRow: Int(w) * 4,
        space: colorSpace,
        bitmapInfo: bitmapInfo.rawValue
    ) else { return nil }
    
    return context.makeImage()
}

// Press a key
emulator.setKey(row: 6, col: 0, down: true)  // ENTER key

// Release a key
emulator.setKey(row: 6, col: 0, down: false)

// Example: Handle key press in a button
Button("ENTER") {
    emulator.setKey(row: 6, col: 0, down: true)
}
.simultaneousGesture(
    DragGesture(minimumDistance: 0)
        .onEnded { _ in
            emulator.setKey(row: 6, col: 0, down: false)
        }
)

// Save state
func saveState() -> Bool {
    guard let hash = currentRomHash else { return false }
    
    if let stateData = emulator.saveState() {
        return StateManager.shared.saveState(
            stateData,
            romHash: hash
        )
    }
    return false
}

// Load state
func loadState() {
    guard let hash = currentRomHash else { return }
    
    if StateManager.shared.loadState(
        emulator: emulator,
        romHash: hash
    ) {
        print("State restored")
    }
}

// Lifecycle integration
class AppState: ObservableObject {
    var emulatorState: EmulatorState?
    
    func handleScenePhaseChange(_ phase: ScenePhase) {
        switch phase {
        case .background:
            // Save state when going to background
            _ = emulatorState?.saveState()
        case .active:
            // Resume emulation
            emulatorState?.isRunning = true
        default:
            break
        }
    }
}

// Load ROM first
emulator.loadRom(romData)

// Inject program files BEFORE powering on
if let programData = try? Data(contentsOf: programURL) {
    let count = emulator.sendFile(programData)
    
    if count >= 0 {
        print("Injected \(count) entries")
    } else {
        print("Failed to inject file: error \(count)")
    }
}

// Now power on - programs will appear in the PRGM menu
emulator.powerOn()

// Get available backends
let backends = EmulatorBridge.getAvailableBackends()  // ["rust", "cemu"]

// Check if switching is available
if EmulatorBridge.isBackendSwitchingAvailable() {
    // Get current backend
    let current = EmulatorBridge.getCurrentBackend()  // "rust"
    
    // Switch backend (must destroy current instance first)
    emulator.destroy()
    
    if EmulatorBridge.setBackend("cemu") {
        // Recreate emulator with new backend
        _ = emulator.create()
        
        // Reload ROM
        _ = emulator.loadRom(romData)
    }
}

typedef struct Emu Emu;

// Lifecycle
Emu* emu_create(void);
void emu_destroy(Emu* emu);

// ROM loading
int32_t emu_load_rom(Emu* emu, const uint8_t* data, size_t size);
int32_t emu_send_file(Emu* emu, const uint8_t* data, size_t size);

// Execution
void emu_reset(Emu* emu);
void emu_power_on(Emu* emu);
int32_t emu_run_cycles(Emu* emu, int32_t cycles);

// Display
const uint32_t* emu_framebuffer(Emu* emu, int32_t* out_width, int32_t* out_height);
uint8_t emu_get_backlight(Emu* emu);
uint8_t emu_is_lcd_on(Emu* emu);

// Input
void emu_set_key(Emu* emu, int32_t row, int32_t col, uint8_t down);

// State persistence
size_t emu_save_state_size(Emu* emu);
int32_t emu_save_state(Emu* emu, uint8_t* out_data, size_t size);
int32_t emu_load_state(Emu* emu, const uint8_t* data, size_t size);

// Backend management
const char* emu_backend_get_available(void);
int emu_backend_count(void);
const char* emu_backend_get_current(void);
int emu_backend_set(const char* name);

class EmulatorBridge {
    private var handle: OpaquePointer?
    private let lock = NSLock()
    
    func create() -> Bool {
        lock.lock()
        defer { lock.unlock() }
        
        handle = emu_create()
        return handle != nil
    }
    
    func loadRom(_ data: Data) -> Int32 {
        lock.lock()
        defer { lock.unlock() }
        
        guard let h = handle else { return -1 }
        
        return data.withUnsafeBytes { bytes in
            guard let ptr = bytes.baseAddress?.assumingMemoryBound(to: UInt8.self) else {
                return -2
            }
            return emu_load_rom(h, ptr, data.count)
        }
    }
    
    func runCycles(_ cycles: Int32) -> Int32 {
        lock.lock()
        defer { lock.unlock() }
        
        guard let h = handle else { return 0 }
        return emu_run_cycles(h, cycles)
    }
}

#ifndef Calc_Bridging_Header_h
#define Calc_Bridging_Header_h

#import "emu.h"

#endif

// Real-time (1x speed)
var cyclesPerTick: Int32 { Int32(800_000) }

// With speed multiplier
var speedMultiplier: Float = 1.0
var cyclesPerTick: Int32 {
    Int32(800_000 * speedMultiplier)
}

if emulator.isLcdOn() {
    screenImage = emulator.makeImage()
} else {
    // Show black screen
    screenImage = nil
}

@Environment(\.scenePhase) var scenePhase

var body: some View {
    // ...
    .onChange(of: scenePhase) { phase in
        switch phase {
        case .background:
            state.isRunning = false
            _ = state.saveState()
        case .active:
            state.isRunning = true
        default:
            break
        }
    }
}