//! 中断服务例程
//!
//! # 中断处理总流程
//!
//! * 中断发生时，CPU首先完成以下工作：
//!     * 设置rsp的值（Ring3->0 或 DoubleFault，在TSS中设置）
//!     * 向栈中push一些值（Ring0时3项，Ring3时5项，某些中断还有错误码）
//!     * 跳转到`vector{i}`符号（位于`vector.asm`）
//! * 进入中断服务例程后，完成以下工作：
//!     * `vector{i}`向栈中push空错误码（如CPU没有做）和中断号
//!     * 跳转到`__alltraps`（位于`trap.asm`）
//!     * `__alltraps`向栈中push全部寄存器的值
//!     * 调用`rust_trap`，并把此时的rsp传过来，也就是`TrapFrame`的指针
//! * `rust_trap`完成以下工作：
//!     * 根据tf中的中断号，再次分发到具体的中断处理函数。
//!       一些函数可能会调用switch()，切换到其它线程执行，在某一时刻再切换回来。
//!     * 如果需要，执行进程调度
//! * `__alltraps`完成以下工作：
//!     * 检查tf中的cs段，如果是用户态，向TSS中设置下一次中断时重置rsp的值，使其指向该用户线程的内核栈
//!     * 从栈中pop全部寄存器的值，pop中断号和错误码
//!     * 执行iret，CPU从栈中pop一些值（若其中的CS是Ring0，3项，否则5项），重置rip和rsp（Ring3时）
//!
//! ``` mermaid
//! sequenceDiagram
//!	activate CPU
//!	Note right of CPU: set rsp (user)
//!	Note right of CPU: push something
//!	deactivate CPU
//!
//!	CPU ->> +ASM: jmp vector_i
//!	Note right of ASM: push error_code & trap_num
//!
//!	ASM ->> ASM: jmp alltraps
//!	Note right of ASM: push registers
//!
//!	ASM ->> +Rust: call rust_trap(rsp)
//!    Note right of Rust: handle the trap
//!
//!	opt schedule
//!	Rust ->> +NewThread: switch
//!	Note left of NewThread: forkret:
//!    NewThread -->> -ASM: ret
//!    Note left of ASM: trapret:
//!    ASM -->> +NewThread: from another trap
//!    NewThread ->> -Rust: switch
//!	end
//!
//!	Rust -->> -ASM: ret
//!    Note left of ASM: trapret:
//!
//!    opt CS is user mode
//!	ASM ->> +Rust: call set_return_rsp
//!	Note right of Rust: set in TSS
//!	Rust -->> -ASM: ret
//!	end
//!
//!	Note right of ASM: pop registers
//!	Note right of ASM: pop error_code & trap_num
//!	ASM -->> -CPU: iret
//!
//!	activate CPU
//!	Note right of CPU: pop something
//!	Note right of CPU: set rsp (user)
//!	deactivate CPU
//! ```

use super::consts::*;
use super::TrapFrame;
use crate::drivers::DRIVERS;
use bitflags::*;
use log::*;

global_asm!(include_str!("trap.asm"));
global_asm!(include_str!("vector.asm"));

#[allow(non_upper_case_globals)]
#[no_mangle]
pub extern "C" fn rust_trap(tf: &mut TrapFrame) {
    trace!(
        "Interrupt: {:#x} @ CPU{}",
        tf.trap_num,
        super::super::cpu::id()
    );
    // Dispatch
    match tf.trap_num as u8 {
        Breakpoint => breakpoint(),
        DoubleFault => double_fault(tf),
        PageFault => page_fault(tf),
        IRQ0...63 => {
            let irq = tf.trap_num as u8 - IRQ0;
            super::ack(irq); // must ack before switching
            match irq {
                Timer => crate::trap::timer(),
                Keyboard => keyboard(),
                COM1 => com1(),
                COM2 => com2(),
                IDE => ide(),
                _ => {
                    for driver in DRIVERS.read().iter() {
                        if driver.try_handle_interrupt(Some(irq.into())) == true {
                            debug!("driver processed interrupt");
                            return;
                        }
                    }
                    warn!("unhandled external IRQ number: {}", irq);
                }
            }
        }
        Syscall32 => syscall32(tf),
        InvalidOpcode => invalid_opcode(tf),
        DivideError | GeneralProtectionFault => error(tf),
        _ => panic!("Unhandled interrupt {:x}", tf.trap_num),
    }
}

fn breakpoint() {
    error!("\nEXCEPTION: Breakpoint");
}

fn double_fault(tf: &TrapFrame) {
    error!("\nEXCEPTION: Double Fault\n{:#x?}", tf);
    loop {}
}

fn page_fault(tf: &mut TrapFrame) {
    let addr: usize;
    unsafe {
        asm!("mov %cr2, $0" : "=r" (addr));
    }

    bitflags! {
        struct PageError: u8 {
            const PRESENT = 1 << 0;
            const WRITE = 1 << 1;
            const USER = 1 << 2;
            const RESERVED_WRITE = 1 << 3;
            const INST = 1 << 4;
        }
    }
    let code = PageError::from_bits(tf.error_code as u8).unwrap();

    if crate::memory::handle_page_fault(addr) {
        return;
    }
    error!("\nEXCEPTION: Page Fault @ {:#x}, code: {:?}", addr, code);
    error(tf);
}

fn keyboard() {
    use crate::arch::driver::keyboard;
    use pc_keyboard::{DecodedKey, KeyCode};
    trace!("\nInterupt: Keyboard");
    if let Some(key) = keyboard::receive() {
        match key {
            DecodedKey::Unicode(c) => crate::trap::serial(c),
            DecodedKey::RawKey(code) => {
                let s = match code {
                    KeyCode::ArrowUp => "\u{1b}[A",
                    KeyCode::ArrowDown => "\u{1b}[B",
                    KeyCode::ArrowRight => "\u{1b}[C",
                    KeyCode::ArrowLeft => "\u{1b}[D",
                    _ => "",
                };
                for c in s.chars() {
                    crate::trap::serial(c);
                }
            }
        }
    }
}

fn com1() {
    use crate::arch::driver::serial::*;
    trace!("\nInterupt: COM1");
    crate::trap::serial(COM1.lock().receive() as char);
}

fn com2() {
    use crate::arch::driver::serial::*;
    trace!("\nInterupt: COM2");
    COM2.lock().receive();
}

fn ide() {
    trace!("\nInterupt: IDE");
}

#[no_mangle]
pub extern "C" fn syscall(tf: &mut TrapFrame) {
    trace!("\nInterupt: Syscall {:#x?}", tf.rax);
    let ret = crate::syscall::syscall(tf.rax, [tf.rdi, tf.rsi, tf.rdx, tf.r10, tf.r8, tf.r9], tf);
    tf.rax = ret as usize;
}

fn syscall32(tf: &mut TrapFrame) {
    trace!("\nInterupt: Syscall {:#x?}", tf.rax);
    let ret = crate::syscall::syscall(tf.rax, [tf.rdx, tf.rcx, tf.rbx, tf.rdi, tf.rsi, 0], tf);
    tf.rax = ret as usize;
}

/// Support `syscall` instruction
fn invalid_opcode(tf: &mut TrapFrame) {
    let opcode = unsafe { (tf.rip as *mut u16).read() };
    const SYSCALL_OPCODE: u16 = 0x05_0f;
    if opcode == SYSCALL_OPCODE {
        tf.rip += 2; // must before syscall
        syscall(tf);
    } else {
        crate::trap::error(tf);
    }
}

fn error(tf: &TrapFrame) {
    crate::trap::error(tf);
}

#[no_mangle]
pub unsafe extern "C" fn set_return_rsp(tf: *const TrapFrame) {
    use crate::arch::gdt::Cpu;
    Cpu::current().set_ring0_rsp(tf.add(1) as usize);
}