Lập Trình Native Bằng Rust Trên Stock OS Của Máy TrimUI

use std::fs::{File, OpenOptions};
use std::os::unix::fs::OpenOptionsExt;
use std::os::unix::io::AsRawFd;
use std::ptr;
use std::thread;
use std::time::{Duration, Instant};

const SCREEN_WIDTH: usize = 1280;
const SCREEN_HEIGHT: usize = 720;

fn main() {
    println!("Khởi động TrimUI Rust Native App...");

    let mmap_len = SCREEN_WIDTH * SCREEN_HEIGHT * 4;
    let mut back_buffer = vec![0u32; SCREEN_WIDTH * SCREEN_HEIGHT];

    // 1. Mở Framebuffer /dev/fb0 với cờ O_SYNC
    let fb_file = match OpenOptions::new()
        .read(true)
        .write(true)
        .custom_flags(libc::O_SYNC)
        .open("/dev/fb0")
    {
        Ok(f) => f,
        Err(e) => {
            eprintln!("Lỗi: Không thể mở /dev/fb0: {}", e);
            return;
        }
    };

    let fd = fb_file.as_raw_fd();
    let mmap_ptr = unsafe {
        libc::mmap(
            ptr::null_mut(),
            mmap_len,
            libc::PROT_READ | libc::PROT_WRITE,
            libc::MAP_SHARED,
            fd,
            0,
        )
    };

    if mmap_ptr == libc::MAP_FAILED {
        eprintln!("Lỗi: mmap thất bại");
        return;
    }

    // 2. Mở thiết bị tay cầm non-blocking
    let input_file = OpenOptions::new()
        .read(true)
        .custom_flags(libc::O_NONBLOCK)
        .open("/dev/input/event0")
        .ok();

    let mut frame_count: u32 = 0;
    let start_time = Instant::now();

    println!("Bắt đầu Game Loop 60 FPS. Bấm MENU hoặc B để thoát.");

    'main_loop: loop {
        let frame_start = Instant::now();
        frame_count = frame_count.wrapping_add(1);

        // A. Kiểm tra sự kiện nút bấm từ evdev
        if let Some(ref dev) = input_file {
            let mut ev: libc::input_event = unsafe { std::mem::zeroed() };
            let size = std::mem::size_of::<libc::input_event>();
            let bytes = unsafe {
                libc::read(dev.as_raw_fd(), &mut ev as *mut _ as *mut libc::c_void, size)
            };

            if bytes as usize >= size && ev.type_ == 1 && (ev.value == 1 || ev.value == 2) {
                // Mã 316 = Phím MENU, Mã 304 = Phím B
                if ev.code == 316 || ev.code == 304 {
                    println!("Nhận phím thoát (code: {}). Đang đóng app...", ev.code);
                    break 'main_loop;
                }
            }
        }

        // B. Vẽ đồ họa vào Back Buffer trong RAM (Hiệu ứng Gradient sống động)
        let t = (frame_count as f32 * 0.05).sin();
        let r_shift = ((t + 1.0) * 127.0) as u32;

        for y in 0..SCREEN_HEIGHT {
            let row_offset = y * SCREEN_WIDTH;
            let g = (y * 255 / SCREEN_HEIGHT) as u32;
            for x in 0..SCREEN_WIDTH {
                let b = (x * 255 / SCREEN_WIDTH) as u32;
                // Định dạng màu 32-bit: 0xFF_RR_GG_BB
                let color = 0xFF000000 | (r_shift << 16) | (g << 8) | b;
                back_buffer[row_offset + x] = color;
            }
        }

        // C. Sao chép tức thời từ RAM sang LCD Framebuffer (Double-buffering)
        unsafe {
            ptr::copy_nonoverlapping(
                back_buffer.as_ptr() as *const u8,
                mmap_ptr as *mut u8,
                mmap_len,
            );
        }

        // D. Khóa nhịp 60 FPS (~16.6ms mỗi frame)
        let elapsed = frame_start.elapsed();
        if elapsed < Duration::from_millis(16) {
            thread::sleep(Duration::from_millis(16) - elapsed);
        }
    }

    // 3. DỌN DẸP SẠCH SẼ KHI THOÁT
    unsafe {
        ptr::write_bytes(mmap_ptr, 0, mmap_len); // Xóa màn hình đen
        libc::munmap(mmap_ptr, mmap_len);        // Hủy ánh xạ bộ nhớ
    }

    let total_secs = start_time.elapsed().as_secs_f32();
    let avg_fps = frame_count as f32 / total_secs;
    println!("Ứng dụng đã thoát an toàn. FPS trung bình: {:.1}", avg_fps);
}