//! K417: real PL011 overlong command rejection and owned event lifetime.
use super::*;
use turkos_kernel::serial_console::{ConsoleEvent, SerialConsole};
use turkos_kernel::serial_rx::CAPACITY;

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

fn fail(reason: &str) -> ! {
    write_str("TURKOS/RANGE-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 hex_bytes(bytes: &[u8]) {
    for byte in bytes {
        write_hex_byte(*byte);
    }
}

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

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 saved = [0; CAPACITY];
    let mut saved_len = 0usize;
    let mut stage = 0usize;
    let mut variant = false;
    let mut line_bytes = 0usize;
    let mut index = 0usize;
    prompt(console.prompts());
    write_line("TURKOS/RANGE: 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;
        if byte != b'\n' && byte != b'\r' {
            line_bytes += 1;
        }
        let event = match console.feed(byte) {
            ConsoleEvent::Input => "INPUT",
            ConsoleEvent::Echo {
                prompt: number,
                bytes,
                len,
            } => {
                if stage == 0 {
                    if &bytes[..len] == b"A B" {
                        variant = false;
                    } else if &bytes[..len] == b"X Y" {
                        variant = true;
                    } else {
                        fail("first owned echo bytes");
                    }
                    saved = bytes;
                    saved_len = len;
                } else if stage != 2 || &bytes[..len] != b"OK" {
                    fail("recovered echo bytes or stage");
                }
                write_str("TURKOS/RANGE-ECHO: STAGE=0x");
                write_hex(stage);
                write_str(" HEX=");
                hex_bytes(&bytes[..len]);
                write_str("\r\n");
                prompt(number);
                stage += 1;
                line_bytes = 0;
                "ECHO"
            }
            ConsoleEvent::TooLong => {
                if stage != 1 || line_bytes != if variant { 18 } else { 17 } {
                    fail("overlong range not rejected");
                }
                if &saved[..saved_len] != if variant { b"X Y" } else { b"A B" } {
                    fail("prior event changed during discarded line");
                }
                write_str("TURKOS/RANGE-REJECT: BYTES=0x");
                write_hex(line_bytes);
                write_str("\r\n");
                prompt(console.prompts());
                stage += 1;
                line_bytes = 0;
                "TOOLONG"
            }
            ConsoleEvent::Cat {
                prompt: number,
                bytes,
                len,
            } => {
                if stage != 3 || &bytes[..len] != b"MOTD" {
                    fail("cat argument bytes or stage");
                }
                write_line("TURKOS/RANGE-CAT: HEX=4d4f5444");
                prompt(number);
                stage += 1;
                line_bytes = 0;
                "CAT"
            }
            _ => fail("unexpected command"),
        };
        write_str("TURKOS/RANGE-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 > 80 {
            fail("too many input bytes");
        }
        if stage == 4 {
            if &saved[..saved_len] != if variant { b"X Y" } else { b"A B" } {
                fail("prior event changed after later commands");
            }
            if console.prompts() != 5
                || console.echos() != 2
                || console.cats() != 1
                || console.unknowns() != 0
                || console.malformed_arguments() != 0
            {
                fail("range accounting");
            }
            write_str("TURKOS/RANGE-SAVED: HEX=");
            hex_bytes(&saved[..saved_len]);
            write_str("\r\n");
            write_line("TURKOS/RANGE: PASS ECHOS=0x2 CATS=0x1 REJECTS=0x1 PROMPTS=0x5");
            park();
        }
    }
}