use std::any::{Any, TypeId};
use std::collections::HashMap;
use std::sync::Arc;
use std::thread::JoinHandle;
use std::time::Duration;

use crate::asm::data::literal::{Addr, Value};
use crate::asm::instr::op::EvalRes;
use crate::runtime::frame::{CallStack, StackFrame, REG_COUNT, status::StatusFlags};
use crate::runtime::program::Program;
use crate::runtime::fault::Fault;
use crate::asm::data::{Rd, SrcDisp, Register, Wr, DstDisp};
use crate::runtime::run_thread::state::RunState;

#[derive(Clone, Copy, Eq, PartialEq, Debug, Ord, PartialOrd)]
pub struct ThreadToken(pub u32);

pub struct RunThread {
    pub(crate) info: ThreadInfo,
    pub(crate) state: RunState,
}

pub struct ThreadInfo {
    /// Thread ID
    pub id: ThreadToken,
    /// Program to run
    pub program: Arc<Program>,
    /// Program to run
    pub cycle_time: Duration,
}

pub mod state;

impl RunThread {
    pub fn new(id: ThreadToken, program: Arc<Program>, pc: Addr, args: &[u64]) -> Self {
        Self {
            info: ThreadInfo {
                id,
                program,
                cycle_time: Duration::default(),
            },
            state: RunState {
                frame: StackFrame::new(pc, args),
                call_stack: vec![],
                ext_data: Default::default(),
            },
        }
    }

    pub fn set_speed(&mut self, cycle_time : Duration) {
        self.info.cycle_time = cycle_time;
    }

    pub fn start(self) -> JoinHandle<()> {
        std::thread::spawn(move || {
            self.run();
        })
    }

    fn run(mut self) {
        'run: loop {
            match self.eval_op() {
                Ok(EvalRes { cycles, advance }) => {
                    std::thread::sleep(self.info.cycle_time * (cycles as u32));
                    trace!("Step {}; Status = {}", advance, self.state.frame.status);
                    self.state.frame.pc.advance(advance);
                    if self.state.frame.status.invalid {
                        warn!("Operation failed with INVALID status!");
                    }
                }
                Err(Fault::Halt) => {
                    info!("Program ended.");
                    break 'run;
                }
                Err(e) => {
                    error!("Fault: {:?}", e);
                    break 'run;
                }
            }
        }
    }
}