//! K416: real PL011 argument parsing, rejection and recovery acceptance.
use super::*;
use turkos_kernel::serial_console::{ArgumentError, ConsoleEvent, SerialConsole};

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

fn fail(reason: &str) -> ! {
    write_str("TURKOS/ARGS-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/ARGS-PROMPT: NUMBER=0x");
    write_hex(number as usize);
    write_str("\r\n");
}

fn hex_bytes(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 variant = false;
    let mut index = 0usize;
    let mut suppressed = 0usize;
    prompt(console.prompts());
    write_line("TURKOS/ARGS: 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::Echo {
                prompt: number,
                bytes,
                len,
            } => {
                let value = &bytes[..len];
                let expected: &[u8] = match stage {
                    0 if value == b"A  B C" => {
                        variant = false;
                        b"A  B C"
                    }
                    0 if value == b"x y" => {
                        variant = true;
                        b"x y"
                    }
                    1 if variant => b"A B",
                    1 => b"A B",
                    4 => b"",
                    5 => b"OK",
                    _ => fail("echo stage"),
                };
                if value != expected {
                    fail("echo argument bytes");
                }
                write_str("TURKOS/ARGS-ECHO: STAGE=0x");
                write_hex(stage);
                write_str(" HEX=");
                hex_bytes(value);
                write_str("\r\n");
                prompt(number);
                stage += 1;
                "ECHO"
            }
            ConsoleEvent::MalformedArguments {
                prompt: number,
                bytes,
                len,
                reason,
            } => {
                if stage != 2 {
                    fail("malformed stage");
                }
                let expected = if variant {
                    ArgumentError::DanglingEscape
                } else {
                    ArgumentError::UnclosedQuote
                };
                if reason != expected {
                    fail("malformed reason");
                }
                write_str("TURKOS/ARGS-ERROR: REASON=");
                write_str(if variant { "ESCAPE" } else { "QUOTE" });
                write_str(" HEX=");
                hex_bytes(&bytes[..len]);
                write_str("\r\n");
                prompt(number);
                stage += 1;
                "MALFORMED"
            }
            ConsoleEvent::Help { prompt: number } => {
                if stage != 3 {
                    fail("help stage");
                }
                write_line("TURKOS/ARGS-HELP: COUNT=0x1");
                prompt(number);
                stage += 1;
                "HELP"
            }
            _ => fail("unexpected command or overlong line"),
        };
        write_str("TURKOS/ARGS-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 > 100 {
            fail("too many input bytes");
        }
        if stage == 6 {
            if console.prompts() != 7
                || console.echos() != 4
                || console.helps() != 1
                || console.malformed_arguments() != 1
                || console.unknowns() != 0
                || console.invalid_utf8() != 0
                || suppressed != 1
            {
                fail("argument accounting");
            }
            write_line(
                "TURKOS/ARGS: PASS ECHOS=0x4 MALFORMED=0x1 HELPS=0x1 PROMPTS=0x7 SUPPRESSED=0x1",
            );
            park();
        }
    }
}