use std::{rc::Rc, cell::{RefCell, Ref}};

use crate::{utility::list::List, simulator::{machine::{NUM_INT_REGS, NUM_FP_REGS, Machine}, interrupt::InterruptStatus}};

use super::{thread::Thread, mgerror::ErrorCode, process::Process};

pub const SIMULATORSTACKSIZE: usize = 32 * 1024;

/// # Thread manager
/// 
/// An instance of this struct is responsible for managing threads on behalf of the system
#[derive(PartialEq)]
pub struct ThreadManager {
    /// Current running thread
    pub g_current_thread: Option<Rc<RefCell<Thread>>>,
    /// The thread to be destroyed next
    pub g_thread_to_be_destroyed: Option<Rc<RefCell<Thread>>>,
    /// The list of alive threads
    pub g_alive: List<Rc<RefCell<Thread>>>,
    /// Thread in ready state waiting to become active
    ready_list: List<Rc<RefCell<Thread>>>,
}

impl ThreadManager {

    /// Thread manager constructor
    pub fn new() -> Self {
        Self { 
            g_current_thread: Option::None, 
            g_thread_to_be_destroyed: Option::None, 
            g_alive: List::default(),
            ready_list: List::default(),
        }
    }

    /// Mark a thread as aready, but not necessarily running yet.
    /// 
    /// Put it in the ready list, for later scheduling onto the CPU.
    /// 
    /// ## Pamameter
    /// 
    /// **thread** is the thread to be put on the read list
    pub fn ready_to_run(&mut self, thread: Rc<RefCell<Thread>>) {
        self.ready_list.push(thread);
    }

    /// Return the next thread to be scheduled onto the CPU.
    /// If there are no ready threads, return Option::None
    /// 
    /// Thread is removed from the ready list.
    /// 
    /// **return** Thread thread to be scheduled
    pub fn find_next_to_run(&mut self) -> Option<Rc<RefCell<Thread>>> {
        self.ready_list.pop()
    }

    /// Dispatch the CPU to next_thread. Save the state of the old thread 
    /// and load the state of the new thread.
    /// 
    /// We assume the state of the previously running thread has already been changed from running to blocked or ready.
    /// 
    /// Global variable g_current_thread become next_thread
    /// 
    /// ## Parameter
    /// 
    /// **next_thread** thread to dispatch to the CPU
    pub fn switch_to(&mut self, machine: &mut Machine, next_thread: Rc<RefCell<Thread>>) {
        match self.get_g_current_thread() {
            Some(old) => {
                let old1 = Rc::clone(old);
                let old2 = Rc::clone(old);
                self.thread_save_processor_state(machine, old1);
                // old_thread.save_simulator_state();
                if old2 != next_thread {
                    self.thread_restore_processor_state(machine, Rc::clone(&next_thread));
                    // next_thread.restore_simulator_state();
                    self.set_g_current_thread(Some(next_thread));
                }
            },
            None => {
                self.thread_restore_processor_state(machine, Rc::clone(&next_thread));
                // next_thread.restore_simulator_state();
                self.set_g_current_thread(Some(next_thread));
            }
        }
    }

    /// Start a thread, attaching it to a process
    pub fn start_thread(&mut self, thread: Rc<RefCell<Thread>>, owner: Process, func_pc: u64, sp_loc: u64, argument: i64) {
        let mut thread_m = thread.borrow_mut();
        assert_eq!(thread_m.process, Option::None);
        thread_m.process = Option::Some(owner);
        let ptr = sp_loc; // todo addrspace
        thread_m.init_thread_context(func_pc, ptr, argument);
        let base_stack_addr: [i8; SIMULATORSTACKSIZE] = [0; SIMULATORSTACKSIZE]; // todo AllocBoundedArray
        thread_m.init_simulator_context(base_stack_addr);
        thread_m.process.as_mut().unwrap().num_thread += 1;
        self.get_g_alive().push(Rc::clone(&thread));
        self.ready_to_run(Rc::clone(&thread));
    }

    /// Wait for another thread to finish its execution
    pub fn thread_join(&mut self, machine: &mut Machine, id_thread: Rc<RefCell<Thread>>) {
        while self.get_g_alive().contains(&Rc::clone(&id_thread)) {
            self.thread_yield(machine, Rc::clone(&id_thread));
        }
    }

    /// Relinquish the CPU if any other thread is runnable.
    /// 
    /// Cannot use yield as a function name -> reserved name in rust
    pub fn thread_yield(&mut self, machine: &mut Machine, thread: Rc<RefCell<Thread>>) {
        let old_status = machine.interrupt.set_status(crate::simulator::interrupt::InterruptStatus::InterruptOff);
            
        assert_eq!(Option::Some(Rc::clone(&thread)), self.g_current_thread);
        let next_thread = self.find_next_to_run();
        if let Some(next_thread) = next_thread {
            self.ready_to_run(thread);
            self.switch_to(machine, next_thread);
        }
        machine.interrupt.set_status(old_status);    
    }

    /// Put the thread to sleep and relinquish the processor
    pub fn thread_sleep(&mut self, machine: &mut Machine, thread: Rc<RefCell<Thread>>) {
        assert_eq!(Option::Some(Rc::clone(&thread)), self.g_current_thread);
        assert_eq!(machine.interrupt.get_status(), InterruptStatus::InterruptOff);

        let mut next_thread = self.find_next_to_run();
        while next_thread.is_none() {
            eprintln!("Nobody to run => idle");
            machine.interrupt.idle();
            next_thread = self.find_next_to_run();
        }
        self.switch_to(machine, Rc::clone(&next_thread.unwrap()));
        
    }

    /// Finish the execution of the thread and prepare its deallocation
    pub fn thread_finish(&mut self, machine: &mut Machine, thread: Rc<RefCell<Thread>>) {
        let old_status = machine.interrupt.set_status(InterruptStatus::InterruptOff);
        self.g_thread_to_be_destroyed = Option::Some(Rc::clone(&thread));
        self.g_alive.remove(Rc::clone(&thread));
        // g_objets_addrs->removeObject(self.thread) // a ajouté plus tard
        self.thread_sleep(machine, Rc::clone(&thread));
        machine.interrupt.set_status(old_status);
    }

	/// Save the CPU state of a user program on a context switch.
    pub fn thread_save_processor_state(&mut self, machine: &mut Machine, thread: Rc<RefCell<Thread>>) {
        let mut t = thread.borrow_mut();
        for i in 0..NUM_INT_REGS {
            t.thread_context.int_registers[i] = machine.read_int_register(i);
        }
        for i in 0..NUM_FP_REGS {
            t.thread_context.float_registers[i] = machine.read_fp_register(i);
        }
        t.thread_context.pc = machine.pc;
    }

    /// Restore the CPU state of a user program on a context switch.
    pub fn thread_restore_processor_state(&self, machine: &mut Machine, thread: Rc<RefCell<Thread>>) {
        let t: Ref<_> = thread.borrow();
        for i in 0..NUM_INT_REGS {
            machine.write_int_register(i, t.thread_context.int_registers[i]);
        }
        machine.pc = t.thread_context.pc;
    }

    /// Currently running thread
    pub fn get_g_current_thread(&mut self) -> &Option<Rc<RefCell<Thread>>> {
        &self.g_current_thread
    }

    /// Thread to be destroyed by [...]
    /// 
    /// TODO: Finish the comment with the relevant value
    pub fn get_g_thread_to_be_destroyed(&mut self) -> &Option<Rc<RefCell<Thread>>> {
        &self.g_thread_to_be_destroyed
    }

    /// List of alive threads
    pub fn get_g_alive(&mut self) -> &mut List<Rc<RefCell<Thread>>> {
        &mut self.g_alive
    }

    /// Set currently running thread
    pub fn set_g_current_thread(&mut self, thread: Option<Rc<RefCell<Thread>>>) {
        self.g_current_thread = thread
    }

    /// Set thread to be destroyed next
    pub fn set_g_thread_to_be_destroyed(&mut self, thread: Option<Rc<RefCell<Thread>>>) {
        self.g_thread_to_be_destroyed = thread
    }

}

#[cfg(test)]
mod test {
    use std::{rc::Rc, cell::RefCell};

    use crate::{simulator::{machine::Machine, loader}, kernel::{system::System, thread::Thread, process::Process}};

    #[test]
    #[ignore = "Pas encore terminé, contient des bugs"]
    fn test_thread_context() {
        let mut machine = Machine::init_machine();
        let (loader, ptr) = loader::Loader::new("./test/riscv_instructions/simple_arithmetics/unsigned_addition", &mut machine, 0).expect("IO Error");
        let start_pc = loader.elf_header.entrypoint;
        let system = &mut System::default();

        let thread1 = Thread::new("th1");
        let thread1 = Rc::new(RefCell::new(thread1));
        system.get_thread_manager().get_g_alive().push(Rc::clone(&thread1));

        let owner = Process { num_thread: 0 };
        system.get_thread_manager().start_thread(Rc::clone(&thread1), owner, start_pc, ptr, -1);
        debug_assert_eq!(thread1.borrow_mut().thread_context.pc, start_pc);

        let to_run = system.get_thread_manager().find_next_to_run().unwrap();
        debug_assert_eq!(to_run, Rc::clone(&thread1));
        debug_assert!(system.get_thread_manager().get_g_alive().contains(&Rc::clone(&thread1)));

        system.get_thread_manager().switch_to(&mut machine, Rc::clone(&to_run));
        debug_assert_eq!(system.get_thread_manager().g_current_thread, Option::Some(Rc::clone(&thread1)));
        debug_assert_eq!(machine.pc, start_pc);

        machine.run();
    }

}