use crate::{constants::OpType, util::{logger, self}};
// use crate::util::logger;
use color_eyre::Result;
use eyre::eyre;
mod syscalls;

fn stack_pop(stack: &mut Vec<u64>, pos: &(String, u32, u32)) -> Result<u64> {
    match stack.pop() {
        Some(i) => Ok(i),
        None => {
            util::logger::pos_error(&pos.clone(), "Stack underflow");
            Err(eyre!("Stack underflow"))
        },
    }
}

pub fn run(tokens: Vec<crate::constants::Operator>) -> Result<()>{
    let mut stack: Vec<u64> = Vec::new();
    let mut ti = 0;
    let mut mem: Vec<u8> = vec![0; crate::compile::MEM_SZ as usize];
    // for token in &tokens {
    //     println!("{{typ: \"{:?}\", val: {}, jmp: {}}}", token.typ, token.value, token.jmp);

    // }
    while ti < tokens.len() {
        let token = &tokens[ti];
        let pos = token.pos.clone();
        // println!("{:?}", token.typ);
        match token.typ {
            
            // stack 
            OpType::Push => {
                stack.push(token.value as u64);
                ti += 1;
            },
            OpType::Drop => {
                stack.pop();
                ti += 1;
            },
            OpType::Dup => {
                let a = stack_pop(&mut stack, &pos)?;
                stack.push(a);
                stack.push(a);
                ti += 1;
            },
            OpType::Dup2 => {
                let a = stack_pop(&mut stack, &pos)?;
                let b = stack_pop(&mut stack, &pos)?;
                stack.push(b);
                stack.push(a);
                stack.push(b);
                stack.push(a);
                ti += 1;
            }
            OpType::Rot => {
                let a = stack_pop(&mut stack, &pos)?;
                let b = stack_pop(&mut stack, &pos)?;
                let c = stack_pop(&mut stack, &pos)?;
                stack.push(b);
                stack.push(a);
                stack.push(c);
                ti += 1;
            }
            OpType::Swap => {
                let a = stack_pop(&mut stack, &pos)?;
                let b = stack_pop(&mut stack, &pos)?;
                stack.push(a);
                stack.push(b);
                ti += 1;
            }
            OpType::Over => {
                let a = stack_pop(&mut stack, &pos)?;
                let b = stack_pop(&mut stack, &pos)?;
                stack.push(b);
                stack.push(a);
                stack.push(b);
                ti += 1;
            }

            OpType::Print => {
                let a = stack_pop(&mut stack, &pos)?;
                println!("{a}");
                // let _ = io::stdout().flush();
                ti += 1;
            },
            // mem

            OpType::Mem => {
                stack.push(0);
                ti += 1;
            }
            OpType::Load8 => {
                let a = stack_pop(&mut stack, &pos)?;
                let byte = mem[a as usize];
                stack.push(byte as u64);
                ti += 1;
            }
            OpType::Store8 => {
                let val = stack_pop(&mut stack, &pos)?;
                let addr = stack_pop(&mut stack, &pos)?;

                mem[addr as usize] = (val & 0xFF) as u8;
                ti += 1;
            }

            // math
            OpType::Plus => {
                let a = stack_pop(&mut stack, &pos)?;
                let b = stack_pop(&mut stack, &pos)?;
                stack.push(b + a);
                ti += 1;
            },
            OpType::Minus => {
                let a = stack_pop(&mut stack, &pos)?;
                let b = stack_pop(&mut stack, &pos)?;
                stack.push(b - a);
                ti += 1;
            },
            OpType::Equals => {
                let a = stack_pop(&mut stack, &pos)?;
                let b = stack_pop(&mut stack, &pos)?;
                stack.push((b == a) as u64);
                ti += 1;
            },
            OpType::Gt => {
                let a = stack_pop(&mut stack, &pos)?;
                let b = stack_pop(&mut stack, &pos)?;
                stack.push((b > a) as u64);
                ti += 1;
            },
            OpType::Lt => {
                let a = stack_pop(&mut stack, &pos)?;
                let b = stack_pop(&mut stack, &pos)?;
                stack.push((b < a) as u64);
                ti += 1;
            },

            OpType::Band => {
                let a = stack_pop(&mut stack, &pos)?;
                let b = stack_pop(&mut stack, &pos)?;
                stack.push((a & b) as u64);
                ti += 1;
            }

            OpType::Bor => {
                let a = stack_pop(&mut stack, &pos)?;
                let b = stack_pop(&mut stack, &pos)?;
                stack.push((a | b) as u64);
                ti += 1;
            }

            OpType::Shr => {
                let a = stack_pop(&mut stack, &pos)?;
                let b = stack_pop(&mut stack, &pos)?;
                stack.push((b >> a) as u64);
                ti += 1;
            }

            OpType::Shl => {
                let a = stack_pop(&mut stack, &pos)?;
                let b = stack_pop(&mut stack, &pos)?;
                stack.push((b << a) as u64);
                ti += 1;
            }
            
            OpType::Div => {
                let a = stack_pop(&mut stack, &pos)?;
                let b = stack_pop(&mut stack, &pos)?;
                stack.push((b / a) as u64);
                ti += 1;
            }
            OpType::Mul => {
                let a = stack_pop(&mut stack, &pos)?;
                let b = stack_pop(&mut stack, &pos)?;
                stack.push((b * a) as u64);
                ti += 1;
            }


            // blocks
            OpType::If => {
                let a = stack_pop(&mut stack, &pos)?;
                if a == 0 {
                    // println!("If({ti}) => t: {:?} j: {}", tokens[token.jmp as usize].typ, token.jmp);
                    ti = (token.jmp) as usize;
                } else {
                    ti += 1;
                }
            },
            OpType::Else => {
                // println!("Else({ti}) => t: {:?} j: {}", tokens[token.jmp as usize].typ, token.jmp);
                ti = (token.jmp) as usize;
            },
            OpType::End => {
                // println!("End({ti}) => t: {:?} j: {}", tokens[token.jmp as usize].typ, token.jmp);
                ti = (token.jmp) as usize;
            }
            OpType::While => {
                ti += 1;
            }
            OpType::Do => {
                let a = stack.pop().unwrap();
                if a == 0 {
                    ti = (token.jmp) as usize;
                } else {
                    ti += 1;
                }
            }            
            OpType::Syscall0 => {
                todo!();
                // ti += 1;
            },
            OpType::Syscall1 => {
                todo!();
                // ti += 1;
            },
            OpType::Syscall2 => {
                todo!();
                // ti += 1;
            },
            OpType::Syscall3 => {
                let rax = stack_pop(&mut stack, &pos)?;
                let rdi = stack_pop(&mut stack, &pos)?;
                let rsi = stack_pop(&mut stack, &pos)?;
                let rdx = stack_pop(&mut stack, &pos)?;
                // println!("yes");
                let ret = match rax {
                    1 => syscalls::sys_write(rax, rdi, rsi, rdx, &mem),
                    _ => {
                        logger::error(format!("Syscall(3) #{} is not implemented", rax).as_str());
                        return Err(eyre!("Syscall not implemented"));
                    }
                };
                stack.push(ret);
                // println!("{}", stack.len());
                ti += 1;
            },
            OpType::Syscall4 => {
                todo!();
                // ti += 1;
            },
            OpType::Syscall5 => {
                todo!();
                // ti += 1;
            },
            OpType::Syscall6 => {
                todo!();
                // ti += 1;
            },
        }
    }
    Ok(())
}