use std::rc::Rc;

use hashbrown::HashMap;

use crate::env::VmEnv;
use crate::ir::{DowngradeContext, Ir};
use crate::ty::common::Const;
use crate::ty::internal::{PrimOp, Value};
use crate::vm::VM;

pub fn ir_env(ctx: &mut DowngradeContext) -> HashMap<usize, Ir> {
    let mut map = HashMap::new();
    map.insert(ctx.new_sym("true"), ctx.new_const(Const::Bool(true)).ir());
    map.insert(ctx.new_sym("false"), ctx.new_const(Const::Bool(false)).ir());

    map
}

pub fn vm_env<'gc>(vm: &VM) -> Rc<VmEnv<'gc>> {
    let primops = [
        PrimOp::new("add", 2, |args, _| {
            let Ok([mut first, second]): Result<[Value; 2], _> = args.try_into() else {
                unreachable!()
            };
            first.add(second);
            first.ok()
        }),
        PrimOp::new("sub", 2, |args, _| {
            let Ok([mut first, mut second]): Result<[Value; 2], _> = args.try_into() else {
                unreachable!()
            };
            second.neg();
            first.add(second);
            first.ok()
        }),
        PrimOp::new("mul", 2, |args, _| {
            let Ok([mut first, second]): Result<[Value; 2], _> = args.try_into() else {
                unreachable!()
            };
            first.mul(second);
            first.ok()
        }),
        PrimOp::new("div", 2, |args, _| {
            let Ok([mut first, second]): Result<[Value; 2], _> = args.try_into() else {
                unreachable!()
            };
            first.div(second)?;
            first.ok()
        }),
        PrimOp::new("lessThan", 2, |args, _| {
            let Ok([mut first, second]): Result<[Value; 2], _> = args.try_into() else {
                unreachable!()
            };
            first.lt(second);
            first.ok()
        }),
        /* PrimOp::new("seq", 2, |args, vm| {
            let Ok([mut first, second]): Result<[_; 2]> = args.try_into() else {
                unreachable!()
            };
            first.force(vm).unwrap();
            second.ok()
        }),
        PrimOp::new("deepSeq", 2, |args, vm| {
            let Ok([mut first, second]): Result<[_; 2]> = args.try_into() else {
                unreachable!()
            };
            first.force_deep(vm).unwrap();
            second.ok()
        }), */
    ];

    let mut env_map = HashMap::new();
    env_map.insert(vm.new_sym("true"), Value::Bool(true));
    env_map.insert(vm.new_sym("false"), Value::Bool(false));

    let mut map = HashMap::new();
    for primop in primops {
        let primop = Rc::new(primop);
        env_map.insert(
            vm.new_sym(format!("__{}", primop.name)),
            Value::PrimOp(primop.clone()),
        );
        map.insert(vm.new_sym(primop.name), Value::PrimOp(primop));
    }
    let sym = vm.new_sym("builtins");
    /* let mut attrs = CoW::new(AttrSet::new(map));
    unsafe {
        attrs.make_cyclic(|attrs, this| {
            let _ = attrs.push_attr(sym, Value::AttrSet(this));
        });
    }
    let builtins = Value::AttrSet(attrs);

    env_map.insert(sym, builtins); */
    // TODO:
    // VmEnv::new(Gc::new(mc, env_map))
    VmEnv::new(Vec::new())
}