//! K415: malformed UTF-8 is rejected as a line, not dispatched or printed raw.
use super::*;
use turkos_kernel::serial_console::{ConsoleEvent, SerialConsole};

const RXFE: u32 = 1 << 4;
const DATA_ERROR: u32 = 0x0f00;

fn fail(reason: &str) -> ! {
    write_str("TURKOS/UTF8-FAIL: ");
    write_line(reason);
    park()
}

fn ticks() -> u64 {
    let value: u64;
    unsafe {
        asm!("mrs {value}, CNTPCT_EL0", value = out(reg) value, options(nomem, nostack, preserves_flags))
    };
    value
}

fn prompt(number: u64) {
    write_str("TURKOS/UTF8-PROMPT: NUMBER=0x");
    write_hex(number as usize);
    write_str("\r\n");
}

fn write_bytes_hex(bytes: &[u8]) {
    for byte in bytes {
        write_hex_byte(*byte);
    }
}

pub(super) fn smoke_test() {
    let base = UART_BASE.load(Ordering::Relaxed);
    let frequency: u64;
    unsafe {
        asm!("mrs {value}, CNTFRQ_EL0", value = out(reg) frequency, options(nomem, nostack, preserves_flags))
    };
    if frequency == 0 {
        fail("zero counter frequency");
    }
    let mut console = SerialConsole::new();
    let mut stage = 0usize;
    let mut index = 0usize;
    let mut suppressed = 0usize;
    prompt(console.prompts());
    write_line("TURKOS/UTF8: READY");
    loop {
        let deadline = ticks()
            .checked_add(frequency.saturating_mul(5))
            .unwrap_or(u64::MAX);
        while unsafe { read_volatile((base + 0x18) as *const u32) } & RXFE != 0 {
            if ticks() >= deadline {
                fail("input timeout");
            }
            core::hint::spin_loop();
        }
        let data = unsafe { read_volatile(base as *const u32) };
        if data & DATA_ERROR != 0 {
            fail("PL011 data error");
        }
        let byte = data as u8;
        let event = match console.feed(byte) {
            ConsoleEvent::Input => "INPUT",
            ConsoleEvent::SuppressedLf => {
                suppressed += 1;
                "SUPPRESS"
            }
            ConsoleEvent::InvalidUtf8 {
                prompt: number,
                bytes,
                len,
            } => {
                if stage != 0 && stage != 2 {
                    fail("invalid UTF-8 stage");
                }
                if core::str::from_utf8(&bytes[..len]).is_ok() {
                    fail("valid bytes misclassified");
                }
                write_str("TURKOS/UTF8-ERROR: STAGE=0x");
                write_hex(stage);
                write_str(" LENGTH=0x");
                write_hex(len);
                write_str(" HEX=");
                write_bytes_hex(&bytes[..len]);
                write_str("\r\n");
                prompt(number);
                stage += 1;
                "INVALID"
            }
            ConsoleEvent::Help { prompt: number } => {
                if stage != 1 {
                    fail("help stage");
                }
                write_line("TURKOS/UTF8-HELP: COUNT=0x1");
                prompt(number);
                stage += 1;
                "HELP"
            }
            ConsoleEvent::Unhandled(bytes, len) => {
                if stage != 3 || core::str::from_utf8(&bytes[..len]).is_err() {
                    fail("valid UTF-8 control stage");
                }
                write_str("TURKOS/UTF8-VALID-UNKNOWN: HEX=");
                write_bytes_hex(&bytes[..len]);
                write_str("\r\n");
                prompt(console.prompts());
                stage += 1;
                "UNHANDLED"
            }
            ConsoleEvent::Echo {
                prompt: number,
                bytes,
                len,
            } => {
                if stage != 4 || &bytes[..len] != b"OK" {
                    fail("echo stage or bytes");
                }
                write_line("TURKOS/UTF8-ECHO: HEX=4f4b");
                prompt(number);
                stage += 1;
                "ECHO"
            }
            _ => fail("unexpected command or overlong line"),
        };
        write_str("TURKOS/UTF8-BYTE: INDEX=0x");
        write_hex(index);
        write_str(" VALUE=0x");
        write_hex(byte as usize);
        write_str(" EVENT=");
        write_str(event);
        write_str(" PROMPTS=0x");
        write_hex(console.prompts() as usize);
        write_str("\r\n");
        index += 1;
        if index > 64 {
            fail("too many input bytes");
        }
        if stage == 5 {
            if console.prompts() != 6
                || console.invalid_utf8() != 2
                || console.unknowns() != 1
                || console.helps() != 1
                || console.echos() != 1
                || console.waits() != 0
                || console.runs() != 0
                || suppressed != 1
            {
                fail("UTF-8 accounting");
            }
            write_line(
                "TURKOS/UTF8: PASS INVALID=0x2 UNKNOWN=0x1 HELPS=0x1 ECHOS=0x1 PROMPTS=0x6 SUPPRESSED=0x1",
            );
            park();
        }
    }
}