use fix_builtins::PrimOpPhase;
use fix_error::Error;
use gc_arena::{Gc, Mutation, RefLock};
use smallvec::SmallVec;

use crate::value::*;
use crate::{BytecodeReader, Step, Vm, VmRuntimeCtx, VmRuntimeCtxExt};

impl<'gc> Vm<'gc> {
    pub(crate) fn primop_seq(
        &mut self,
        reader: &mut BytecodeReader<'_>,
        mc: &Mutation<'gc>,
    ) -> Step {
        // stack: [e1, e2] - force e1, return e2
        self.force_slot(1, reader, mc)?;
        let e2 = self.pop();
        let _ = self.pop();
        self.return_from_primop(e2, reader)
    }

    pub(crate) fn primop_abort(
        &mut self,
        ctx: &mut impl VmRuntimeCtx,
        reader: &mut BytecodeReader<'_>,
        mc: &Mutation<'gc>,
    ) -> Step {
        // stack: [msg] - force msg, then abort with it
        self.force_slot(0, reader, mc)?;
        let msg_val = self.peek_forced(0);
        let msg = ctx.get_string(msg_val).unwrap_or("<non-string-value>");
        self.finish_err(Error::eval_error(format!(
            "evaluation aborted with the following error message: '{msg}'"
        )))
    }

    pub(crate) fn primop_deep_seq_force_top(
        &mut self,
        reader: &mut BytecodeReader<'_>,
        mc: &Mutation<'gc>,
    ) -> Step {
        // stack: [e1, e2] - force e1, return e2
        self.force_slot(1, reader, mc)?;

        let e1 = self.peek_forced(1);

        let children: SmallVec<_> = if let Some(attrs) = e1.as_gc::<AttrSet>() {
            let attrs = &attrs.entries;
            if attrs.is_empty() {
                SmallVec::new()
            } else {
                attrs.iter().map(|&(_, v)| v).collect()
            }
        } else if let Some(list) = e1.as_gc::<List<'gc>>() {
            let inner = list.inner.borrow();
            if inner.is_empty() {
                SmallVec::new()
            } else {
                inner.iter().copied().collect()
            }
        } else {
            SmallVec::new()
        };

        if children.is_empty() {
            let e2 = self.pop();
            let _ = self.pop();
            return self.return_from_primop(e2, reader);
        }

        let count = children.len() as i32;
        let seen: Gc<'gc, List<'gc>> = Gc::new(mc, List::default());
        let worklist: Gc<'gc, List<'gc>> = List::new(mc, children);

        let e2 = self.pop();
        let _ = self.pop();
        self.push(e2);
        self.push(Value::new_gc(seen));
        self.push(Value::new_gc(worklist));
        self.push(Value::new_inline(count));
        reader.set_pc(PrimOpPhase::DeepSeqPush.ip() as usize);
        Step::Continue(())
    }

    pub(crate) fn primop_deep_seq_push(
        &mut self,
        reader: &mut BytecodeReader<'_>,
        mc: &Mutation<'gc>,
    ) -> Step {
        // stack: [e2, seen, worklist, counter]
        #[allow(clippy::unwrap_used)]
        let counter = self.peek(0).as_inline::<i32>().unwrap();
        if counter == 0 {
            let _ = self.pop(); // counter
            let _ = self.pop(); // worklist
            let _ = self.pop(); // seen
            let val = self.pop();
            return self.return_from_primop(val, reader);
        }

        #[allow(clippy::unwrap_used)]
        let worklist = self.peek_forced(1).as_gc::<List<'gc>>().unwrap();
        #[allow(clippy::unwrap_used)]
        let item = worklist.unlock(mc).borrow_mut().pop().unwrap();
        self.replace(0, Value::new_inline(counter - 1));
        self.push(item);

        // force item at TOS, resume at DeepSeqLoop after force
        self.force_slot_to_pc(0, reader, mc, PrimOpPhase::DeepSeqLoop.ip() as usize)?;
        reader.set_pc(PrimOpPhase::DeepSeqLoop.ip() as usize);
        Step::Continue(())
    }

    pub(crate) fn primop_deep_seq_loop(
        &mut self,
        reader: &mut BytecodeReader<'_>,
        mc: &Mutation<'gc>,
    ) -> Step {
        // stack after pop: [e2, seen, worklist, counter]
        let item = self.pop();
        #[allow(clippy::unwrap_used)]
        let counter = self.peek(0).as_inline::<i32>().unwrap();

        let mut added: usize = 0;
        if let Some(attrs) = item.as_gc::<AttrSet>() {
            let attrs = &attrs.entries;
            #[allow(clippy::unwrap_used)]
            let seen = self.peek_forced(2).as_gc::<List<'gc>>().unwrap();
            if !self.is_value_in_seen(seen, item) {
                self.add_value_to_seen(seen, mc, item);
                #[allow(clippy::unwrap_used)]
                let worklist = self.peek_forced(1).as_gc::<List<'gc>>().unwrap();
                {
                    let mut wl = worklist.unlock(mc).borrow_mut();
                    for &(_, v) in attrs.iter() {
                        wl.push(v);
                    }
                    added = attrs.len();
                }
            }
        } else if let Some(list) = item.as_gc::<List<'gc>>() {
            #[allow(clippy::unwrap_used)]
            let seen = self.peek_forced(2).as_gc::<List<'gc>>().unwrap();
            if !self.is_value_in_seen(seen, item) {
                self.add_value_to_seen(seen, mc, item);
                #[allow(clippy::unwrap_used)]
                let worklist = self.peek_forced(1).as_gc::<List<'gc>>().unwrap();
                {
                    let inner = list.inner.borrow();
                    let mut wl = worklist.unlock(mc).borrow_mut();
                    for &v in inner.iter() {
                        wl.push(v);
                    }
                    added = inner.len();
                }
            }
        }

        self.replace(0, Value::new_inline(counter + added as i32));
        reader.set_pc(PrimOpPhase::DeepSeqPush.ip() as usize);
        Step::Continue(())
    }

    pub(crate) fn primop_force_result_shallow(
        &mut self,
        ctx: &mut impl VmRuntimeCtx,
        reader: &mut BytecodeReader<'_>,
        mc: &Mutation<'gc>,
    ) -> Step {
        self.force_slot(0, reader, mc)?;
        let val = self.peek_forced(0);

        let (count, has_children) = if let Some(attrs) = val.as_gc::<AttrSet>() {
            let len = attrs.entries.len();
            (len, len > 0)
        } else if let Some(list) = val.as_gc::<List<'gc>>() {
            let len = list.inner.borrow().len();
            (len, len > 0)
        } else {
            (0, false)
        };

        if !has_children {
            let val = self.pop();
            return self.finish_ok(ctx.convert_value(val));
        }

        self.push(Value::new_inline(0i32));
        self.push(Value::new_inline(count as i32));
        reader.set_pc(PrimOpPhase::ForceResultShallowPush.ip() as usize);
        Step::Continue(())
    }

    pub(crate) fn primop_force_result_shallow_push(
        &mut self,
        ctx: &mut impl VmRuntimeCtx,
        reader: &mut BytecodeReader<'_>,
        mc: &Mutation<'gc>,
    ) -> Step {
        #[allow(clippy::unwrap_used)]
        let idx = self.peek(1).as_inline::<i32>().unwrap();
        #[allow(clippy::unwrap_used)]
        let len = self.peek(0).as_inline::<i32>().unwrap();

        if idx == len {
            let _ = self.pop(); // len
            let _ = self.pop(); // idx
            let val = self.pop();
            return self.finish_ok(ctx.convert_value(val));
        }

        let val = self.peek_forced(2);
        let child = if let Some(attrs) = val.as_gc::<AttrSet>() {
            attrs.entries.get(idx as usize).map(|&(_, v)| v)
        } else if let Some(list) = val.as_gc::<List<'gc>>() {
            list.inner.borrow().get(idx as usize).copied()
        } else {
            None
        };

        if let Some(child) = child {
            self.replace(1, Value::new_inline(idx + 1));
            self.push(child);
            self.force_slot_to_pc(
                0,
                reader,
                mc,
                PrimOpPhase::ForceResultShallowLoop.ip() as usize,
            )?;
            reader.set_pc(PrimOpPhase::ForceResultShallowLoop.ip() as usize);
        }
        Step::Continue(())
    }

    pub(crate) fn primop_force_result_shallow_loop(
        &mut self,
        reader: &mut BytecodeReader<'_>,
        _mc: &Mutation<'gc>,
    ) -> Step {
        let _ = self.pop(); // forced child
        reader.set_pc(PrimOpPhase::ForceResultShallowPush.ip() as usize);
        Step::Continue(())
    }

    pub(crate) fn primop_force_result_deep_finish(
        &mut self,
        ctx: &mut impl VmRuntimeCtx,
        reader: &mut BytecodeReader<'_>,
        mc: &Mutation<'gc>,
    ) -> Step {
        let val = self.force_and_retry::<StrictValue>(reader, mc)?;
        self.finish_ok(ctx.convert_value(val.relax()))
    }

    fn is_value_in_seen(&self, seen: Gc<'gc, List<'gc>>, val: Value<'gc>) -> bool {
        if !is_container(val) {
            return false;
        }
        let target = val.to_bits();
        for &v in seen.inner.borrow().iter() {
            if v.to_bits() == target {
                return true;
            }
        }
        false
    }

    fn add_value_to_seen(&self, seen: Gc<'gc, List<'gc>>, mc: &Mutation<'gc>, val: Value<'gc>) {
        if is_container(val) {
            seen.unlock(mc).borrow_mut().push(val);
        }
    }

    pub(crate) fn primop_call_pattern(
        &mut self,
        ctx: &mut impl VmRuntimeCtx,
        reader: &mut BytecodeReader<'_>,
        mc: &Mutation<'gc>,
    ) -> Step {
        let (func, attrset) = self.force_and_retry::<(Gc<Closure>, Gc<AttrSet>)>(reader, mc)?;

        let Closure {
            ip,
            n_locals,
            env,
            pattern,
        } = *func;
        let Some(pattern) = pattern else {
            unreachable!()
        };
        // TODO: get function name
        // TODO: param spans
        if !pattern.ellipsis {
            for key in pattern.required.iter().copied() {
                if attrset.lookup(key).is_none() {
                    let name = ctx.resolve_string(key);
                    return self.finish_err(Error::eval_error(format!(
                        "function 'anonymous lambda' called without required argument '{name}'"
                    )));
                }
            }
            for &(key, _) in attrset.entries.iter() {
                let is_expected =
                    pattern.required.contains(&key) || pattern.optional.contains(&key);
                if !is_expected {
                    let name = ctx.resolve_string(key);
                    return self.finish_err(Error::eval_error(format!(
                        "function 'anonymous lambda' called with unexpected argument '{name}'"
                    )));
                }
            }
        }

        let new_env = Gc::new(
            mc,
            RefLock::new(Env::with_arg(Value::new_gc(attrset), n_locals, env)),
        );
        reader.set_pc(ip as usize);
        self.env = new_env;

        Step::Continue(())
    }
}

fn is_container(val: Value<'_>) -> bool {
    val.is::<AttrSet>() || val.is::<List<'_>>()
}