use bumpalo::collections::{CollectIn, Vec};
use fix_builtins::BuiltinId;
use fix_common::Symbol;
use fix_error::{Error, Result, Source};
use hashbrown::HashSet;
use hashbrown::hash_map::Entry;
use rnix::TextRange;
use rnix::ast::{self, AstToken, Expr, HasEntry};
use rowan::ast::AstNode;

use super::*;

trait Require<'id: 'ir, 'ir, Ctx: DowngradeContext<'id, 'ir>, T> {
    fn require(self, ctx: &Ctx, span: TextRange) -> Result<T>;
}

impl<'id: 'ir, 'ir, Ctx: DowngradeContext<'id, 'ir>, T> Require<'id, 'ir, Ctx, T> for Option<T> {
    #[inline]
    fn require(self, ctx: &Ctx, span: TextRange) -> Result<T> {
        self.ok_or_else(|| {
            Error::parse_error("invalid syntax".into())
                .with_source(ctx.get_current_source())
                .with_span(span)
        })
    }
}

impl<'id: 'ir, 'ir, Ctx: DowngradeContext<'id, 'ir>, T, E: std::fmt::Display>
    Require<'id, 'ir, Ctx, T> for std::result::Result<T, E>
{
    #[inline]
    fn require(self, ctx: &Ctx, span: TextRange) -> Result<T> {
        self.map_err(|e| {
            Error::parse_error(format!("invalid syntax: {e}"))
                .with_source(ctx.get_current_source())
                .with_span(span)
        })
    }
}

pub trait DowngradeContext<'id: 'ir, 'ir> {
    fn new_expr(&self, expr: Ir<'ir, GhostRoRef<'id, 'ir>>) -> GhostRoIrRef<'id, 'ir>;
    fn maybe_thunk(&mut self, ir: GhostRoIrRef<'id, 'ir>) -> GhostRoMaybeThunkRef<'id, 'ir>;

    fn intern_string(&mut self, sym: impl AsRef<str>) -> StringId;
    fn resolve_sym(&self, id: StringId) -> Symbol<'_>;
    fn lookup(&self, sym: StringId, span: TextRange) -> Result<GhostRoMaybeThunkRef<'id, 'ir>>;

    fn get_current_source(&self) -> Source;

    fn with_param_scope<F, R>(&mut self, param: StringId, f: F) -> R
    where
        F: FnOnce(&mut Self) -> R;
    fn with_let_scope<F, R>(&mut self, bindings: &[StringId], f: F) -> Result<R>
    where
        F: FnOnce(&mut Self) -> Result<(Vec<'ir, GhostRoMaybeThunkRef<'id, 'ir>>, R)>;
    fn with_with_scope<F, R>(&mut self, f: F) -> R
    where
        F: FnOnce(&mut Self) -> R;
    fn with_thunk_scope<F, R>(&mut self, f: F) -> (R, Vec<'ir, (ThunkId, GhostRoIrRef<'id, 'ir>)>)
    where
        F: FnOnce(&mut Self) -> R;

    fn bump(&self) -> &'ir bumpalo::Bump;
}

pub trait Downgrade<'id: 'ir, 'ir, Ctx: DowngradeContext<'id, 'ir>> {
    fn downgrade(self, ctx: &mut Ctx) -> Result<GhostRoIrRef<'id, 'ir>>;
}

impl<'id: 'ir, 'ir, Ctx: DowngradeContext<'id, 'ir>> Downgrade<'id, 'ir, Ctx> for Expr {
    fn downgrade(self, ctx: &mut Ctx) -> Result<GhostRoIrRef<'id, 'ir>> {
        use Expr::*;
        match self {
            Apply(apply) => apply.downgrade(ctx),
            Assert(assert) => assert.downgrade(ctx),
            Error(error) => {
                let span = error.syntax().text_range();
                Err(self::Error::downgrade_error(
                    error.to_string(),
                    ctx.get_current_source(),
                    span,
                ))
            }
            IfElse(ifelse) => ifelse.downgrade(ctx),
            Select(select) => select.downgrade(ctx),
            Str(str) => str.downgrade(ctx),
            PathAbs(path) => path.downgrade(ctx),
            PathRel(path) => path.downgrade(ctx),
            PathHome(path) => path.downgrade(ctx),
            PathSearch(path) => path.downgrade(ctx),
            Literal(lit) => lit.downgrade(ctx),
            Lambda(lambda) => lambda.downgrade(ctx),
            LegacyLet(let_) => let_.downgrade(ctx),
            LetIn(letin) => letin.downgrade(ctx),
            List(list) => list.downgrade(ctx),
            BinOp(op) => op.downgrade(ctx),
            AttrSet(attrs) => attrs.downgrade(ctx),
            UnaryOp(op) => op.downgrade(ctx),
            Ident(ident) => ident.downgrade(ctx),
            CurPos(curpos) => Ok(ctx.new_expr(Ir::CurPos(curpos.syntax().text_range()))),
            With(with) => with.downgrade(ctx),
            HasAttr(has) => has.downgrade(ctx),
            Paren(paren) => paren
                .expr()
                .require(ctx, paren.syntax().text_range())?
                .downgrade(ctx),
            Root(root) => root
                .expr()
                .require(ctx, root.syntax().text_range())?
                .downgrade(ctx),
        }
    }
}

impl<'id: 'ir, 'ir, Ctx: DowngradeContext<'id, 'ir>> Downgrade<'id, 'ir, Ctx> for ast::Assert {
    fn downgrade(self, ctx: &mut Ctx) -> Result<GhostRoIrRef<'id, 'ir>> {
        let span = self.syntax().text_range();
        let assertion = self.condition().require(ctx, span)?;
        let assertion_raw = assertion.to_string();
        let assertion = assertion.downgrade(ctx)?;
        let expr = self.body().require(ctx, span)?.downgrade(ctx)?;
        Ok(ctx.new_expr(Ir::Assert {
            assertion,
            expr,
            assertion_raw,
            span,
        }))
    }
}

impl<'id: 'ir, 'ir, Ctx: DowngradeContext<'id, 'ir>> Downgrade<'id, 'ir, Ctx> for ast::IfElse {
    fn downgrade(self, ctx: &mut Ctx) -> Result<GhostRoIrRef<'id, 'ir>> {
        let span = self.syntax().text_range();
        let cond = self.condition().require(ctx, span)?.downgrade(ctx)?;
        let consq = self.body().require(ctx, span)?.downgrade(ctx)?;
        let alter = self.else_body().require(ctx, span)?.downgrade(ctx)?;
        Ok(ctx.new_expr(Ir::If { cond, consq, alter }))
    }
}

macro_rules! path {
    ($ty:ident) => {
        impl<'id: 'ir, 'ir, Ctx: DowngradeContext<'id, 'ir>> Downgrade<'id, 'ir, Ctx> for ast::$ty {
            fn downgrade(self, ctx: &mut Ctx) -> Result<GhostRoIrRef<'id, 'ir>> {
                downgrade_path(self.parts(), ctx)
            }
        }
    };
}
path!(PathAbs);
path!(PathRel);
path!(PathHome);
impl<'id: 'ir, 'ir, Ctx: DowngradeContext<'id, 'ir>> Downgrade<'id, 'ir, Ctx> for ast::PathSearch {
    fn downgrade(self, ctx: &mut Ctx) -> Result<GhostRoIrRef<'id, 'ir>> {
        let span = self.syntax().text_range();
        let path = {
            let temp = self.content().require(ctx, span)?;
            let text = temp.text();
            let id = ctx.intern_string(&text[1..text.len() - 1]);
            let expr = ctx.new_expr(Ir::Str(id));
            ctx.maybe_thunk(expr)
        };
        // HACK: disgusting eww
        let find_file = ctx.new_expr(Ir::Builtin(BuiltinId::FindFile));
        let sym = ctx.intern_string("nixPath");
        let nix_path = ctx.new_expr(Ir::BuiltinConst(sym));
        let nix_path = ctx.maybe_thunk(nix_path);
        let call = ctx.new_expr(Ir::Call {
            func: find_file,
            arg: nix_path,
            span,
        });
        Ok(ctx.new_expr(Ir::Call {
            func: call,
            arg: path,
            span,
        }))
    }
}

impl<'id: 'ir, 'ir, Ctx: DowngradeContext<'id, 'ir>> Downgrade<'id, 'ir, Ctx> for ast::Str {
    fn downgrade(self, ctx: &mut Ctx) -> Result<GhostRoIrRef<'id, 'ir>> {
        let normalized = self.normalized_parts();
        let is_single_literal = normalized.len() == 1
            && matches!(normalized.first(), Some(ast::InterpolPart::Literal(_)));

        let bump = ctx.bump();
        let mut parts = normalized.into_iter().map(|part| match part {
            ast::InterpolPart::Literal(lit) => {
                let id = ctx.intern_string(lit);
                Ok(ctx.new_expr(Ir::Str(id)))
            }
            ast::InterpolPart::Interpolation(interpol) => interpol
                .expr()
                .require(ctx, interpol.syntax().text_range())?
                .downgrade(ctx),
        });

        Ok(if is_single_literal {
            parts.next().expect("is_single_literal checked")?
        } else {
            let parts = parts.collect_in::<Result<_>>(bump)?;
            ctx.new_expr(Ir::ConcatStrings {
                parts,
                force_string: true,
            })
        })
    }
}

impl<'id: 'ir, 'ir, Ctx: DowngradeContext<'id, 'ir>> Downgrade<'id, 'ir, Ctx> for ast::Literal {
    fn downgrade(self, ctx: &mut Ctx) -> Result<GhostRoIrRef<'id, 'ir>> {
        let span = self.syntax().text_range();
        let expr = match self.kind() {
            ast::LiteralKind::Integer(int) => Ir::Int(int.value().require(ctx, span)?),
            ast::LiteralKind::Float(float) => Ir::Float(float.value().require(ctx, span)?),
            ast::LiteralKind::Uri(uri) => {
                let id = ctx.intern_string(uri.syntax().text());
                Ir::Str(id)
            }
        };
        Ok(ctx.new_expr(expr))
    }
}

impl<'id: 'ir, 'ir, Ctx: DowngradeContext<'id, 'ir>> Downgrade<'id, 'ir, Ctx> for ast::Ident {
    fn downgrade(self, ctx: &mut Ctx) -> Result<GhostRoIrRef<'id, 'ir>> {
        let span = self.syntax().text_range();
        let text = self.ident_token().require(ctx, span)?.to_string();
        let sym = ctx.intern_string(text);
        ctx.lookup(sym, span)
            .map(|thunk| ctx.new_expr(Ir::MaybeThunk(thunk)))
    }
}

impl<'id: 'ir, 'ir, Ctx: DowngradeContext<'id, 'ir>> Downgrade<'id, 'ir, Ctx> for ast::AttrSet {
    fn downgrade(self, ctx: &mut Ctx) -> Result<GhostRoIrRef<'id, 'ir>> {
        let rec = self.rec_token().is_some();
        if !rec {
            let attrs = downgrade_attrs(self, ctx)?;
            return Ok(ctx.new_expr(Ir::AttrSet {
                stcs: attrs.stcs,
                dyns: attrs.dyns,
            }));
        }

        let entries: Vec<'ir, _> = self.entries().collect_in(ctx.bump());
        downgrade_rec_bindings(entries, ctx)
    }
}

impl<'id: 'ir, 'ir, Ctx: DowngradeContext<'id, 'ir>> Downgrade<'id, 'ir, Ctx> for ast::List {
    fn downgrade(self, ctx: &mut Ctx) -> Result<GhostRoIrRef<'id, 'ir>> {
        let bump = ctx.bump();
        let items = self
            .items()
            .map(|item| {
                let id = item.downgrade(ctx)?;
                Ok(ctx.maybe_thunk(id))
            })
            .collect_in::<Result<_>>(bump)?;
        Ok(ctx.new_expr(Ir::List { items }))
    }
}

impl<'id: 'ir, 'ir, Ctx: DowngradeContext<'id, 'ir>> Downgrade<'id, 'ir, Ctx> for ast::BinOp {
    fn downgrade(self, ctx: &mut Ctx) -> Result<GhostRoIrRef<'id, 'ir>> {
        let span = self.syntax().text_range();
        let lhs = self.lhs().require(ctx, span)?.downgrade(ctx)?;
        let rhs = self.rhs().require(ctx, span)?.downgrade(ctx)?;
        let kind = self.operator().require(ctx, span)?.into();
        Ok(ctx.new_expr(Ir::BinOp { lhs, rhs, kind }))
    }
}

impl<'id: 'ir, 'ir, Ctx: DowngradeContext<'id, 'ir>> Downgrade<'id, 'ir, Ctx> for ast::HasAttr {
    fn downgrade(self, ctx: &mut Ctx) -> Result<GhostRoIrRef<'id, 'ir>> {
        let span = self.syntax().text_range();
        let lhs = self.expr().require(ctx, span)?.downgrade(ctx)?;
        let rhs = downgrade_attrpath(self.attrpath().require(ctx, span)?, ctx)?;
        Ok(ctx.new_expr(Ir::HasAttr { lhs, rhs }))
    }
}

impl<'id: 'ir, 'ir, Ctx: DowngradeContext<'id, 'ir>> Downgrade<'id, 'ir, Ctx> for ast::UnaryOp {
    fn downgrade(self, ctx: &mut Ctx) -> Result<GhostRoIrRef<'id, 'ir>> {
        let span = self.syntax().text_range();
        let rhs = self.expr().require(ctx, span)?.downgrade(ctx)?;
        let kind = self.operator().require(ctx, span)?.into();
        Ok(ctx.new_expr(Ir::UnOp { rhs, kind }))
    }
}

impl<'id: 'ir, 'ir, Ctx: DowngradeContext<'id, 'ir>> Downgrade<'id, 'ir, Ctx> for ast::Select {
    fn downgrade(self, ctx: &mut Ctx) -> Result<GhostRoIrRef<'id, 'ir>> {
        let span = self.syntax().text_range();
        let expr = self.expr().require(ctx, span)?.downgrade(ctx)?;
        let attrpath = downgrade_attrpath(self.attrpath().require(ctx, span)?, ctx)?;
        let default = self
            .default_expr()
            .map(|expr| expr.downgrade(ctx))
            .transpose()?;
        let span = self.syntax().text_range();
        Ok(ctx.new_expr(Ir::Select {
            expr,
            attrpath,
            default,
            span,
        }))
    }
}

impl<'id: 'ir, 'ir, Ctx: DowngradeContext<'id, 'ir>> Downgrade<'id, 'ir, Ctx> for ast::LegacyLet {
    fn downgrade(self, ctx: &mut Ctx) -> Result<GhostRoIrRef<'id, 'ir>> {
        let span = self.syntax().text_range();
        let entries: Vec<'ir, _> = self.entries().collect_in(ctx.bump());
        let attrset_expr = downgrade_let_bindings(entries, ctx, |ctx, binding_keys| {
            let mut stcs = HashMap::new_in(ctx.bump());
            let dyns = Vec::new_in(ctx.bump());

            for sym in binding_keys {
                let expr = ctx.lookup(*sym, rnix::TextRange::default())?;
                stcs.insert(*sym, (expr, rnix::TextRange::default()));
            }

            Ok(ctx.new_expr(Ir::AttrSet { stcs, dyns }))
        })?;

        let body_sym = ctx.intern_string("body");
        Ok(ctx.new_expr(Ir::Select {
            expr: attrset_expr,
            attrpath: Vec::from_iter_in(
                [Attr::Str(body_sym, rnix::TextRange::default())],
                ctx.bump(),
            ),
            default: None,
            span,
        }))
    }
}

impl<'id: 'ir, 'ir, Ctx: DowngradeContext<'id, 'ir>> Downgrade<'id, 'ir, Ctx> for ast::LetIn {
    fn downgrade(self, ctx: &mut Ctx) -> Result<GhostRoIrRef<'id, 'ir>> {
        let entries: Vec<'ir, _> = self.entries().collect_in(ctx.bump());
        let span = self.syntax().text_range();
        let body_expr = self.body().require(ctx, span)?;

        downgrade_let_bindings(entries, ctx, |ctx, _binding_keys| body_expr.downgrade(ctx))
    }
}

impl<'id: 'ir, 'ir, Ctx: DowngradeContext<'id, 'ir>> Downgrade<'id, 'ir, Ctx> for ast::With {
    fn downgrade(self, ctx: &mut Ctx) -> Result<GhostRoIrRef<'id, 'ir>> {
        let span = self.syntax().text_range();
        let namespace = self.namespace().require(ctx, span)?.downgrade(ctx)?;
        let namespace = ctx.maybe_thunk(namespace);

        let body_expr = self.body().require(ctx, span)?;
        let (body, thunks) =
            ctx.with_thunk_scope(|ctx| ctx.with_with_scope(|ctx| body_expr.downgrade(ctx)));
        let body = body?;

        Ok(ctx.new_expr(Ir::With {
            namespace,
            body,
            thunks,
        }))
    }
}

impl<'id: 'ir, 'ir, Ctx: DowngradeContext<'id, 'ir>> Downgrade<'id, 'ir, Ctx> for ast::Lambda {
    fn downgrade(self, ctx: &mut Ctx) -> Result<GhostRoIrRef<'id, 'ir>> {
        let span = self.syntax().text_range();
        let raw_param = self.param().require(ctx, span)?;
        let body_ast = self.body().require(ctx, span)?;

        struct Ret<'id, 'ir> {
            param: Option<Param<'ir>>,
            body: GhostRoIrRef<'id, 'ir>,
        }

        let (ret, thunks) = ctx.with_thunk_scope(|ctx| {
            let param;
            let body;

            match raw_param {
                ast::Param::IdentParam(id) => {
                    let param_sym = ctx.intern_string(id.to_string());
                    param = None;

                    body = ctx.with_param_scope(param_sym, |ctx| body_ast.downgrade(ctx))?;
                }
                ast::Param::Pattern(pattern) => {
                    let alias = pattern
                        .pat_bind()
                        .map(|alias| {
                            let ident = alias.ident().require(ctx, alias.syntax().text_range())?;
                            Ok::<_, std::boxed::Box<Error>>(ctx.intern_string(ident.to_string()))
                        })
                        .transpose()?;

                    let ellipsis = pattern.ellipsis_token().is_some();
                    let pat_entries = pattern.pat_entries();

                    let PatternBindings {
                        body: inner_body,
                        required,
                        optional,
                    } = downgrade_pattern_bindings(pat_entries, alias, ctx, |ctx, _| {
                        body_ast.clone().downgrade(ctx)
                    })?;

                    param = Some(Param {
                        required,
                        optional,
                        ellipsis,
                    });

                    body = inner_body;
                }
            }

            Result::Ok(Ret { param, body })
        });
        let Ret { param, body } = ret?;

        Ok(ctx.new_expr(Ir::Func {
            body,
            param,
            thunks,
        }))
    }
}

impl<'id: 'ir, 'ir, Ctx: DowngradeContext<'id, 'ir>> Downgrade<'id, 'ir, Ctx> for ast::Apply {
    fn downgrade(self, ctx: &mut Ctx) -> Result<GhostRoIrRef<'id, 'ir>> {
        let span = self.syntax().text_range();
        let func = self.lambda().require(ctx, span)?.downgrade(ctx)?;
        let arg = self.argument().require(ctx, span)?.downgrade(ctx)?;
        let arg = ctx.maybe_thunk(arg);
        let span = self.syntax().text_range();
        Ok(ctx.new_expr(Ir::Call { func, arg, span }))
    }
}

enum PendingValue<'ir> {
    Expr(ast::Expr),
    InheritFrom(ast::Expr, StringId, TextRange),
    InheritScope(StringId, TextRange),
    Set(PendingAttrSet<'ir>),
    ExtendedRecAttrSet {
        base: ast::AttrSet,
        extensions: Vec<'ir, ast::Entry>,
    },
}

struct PendingAttrSet<'ir> {
    stcs: HashMap<'ir, StringId, (PendingValue<'ir>, TextRange)>,
    dyns: Vec<'ir, (ast::Attr, PendingValue<'ir>, TextRange)>,
}

impl<'id: 'ir, 'ir> PendingAttrSet<'ir> {
    fn new_in(bump: &'ir bumpalo::Bump) -> Self {
        Self {
            stcs: HashMap::new_in(bump),
            dyns: Vec::new_in(bump),
        }
    }

    fn insert(
        &mut self,
        path: &[ast::Attr],
        value: ast::Expr,
        ctx: &mut impl DowngradeContext<'id, 'ir>,
    ) -> Result<()> {
        let first = path.first().expect("empty attrpath passed. this is a bug");
        let rest = &path[1..];
        let span = first.syntax().text_range();

        match first {
            ast::Attr::Ident(ident) => {
                let sym = ctx.intern_string(ident.to_string());
                self.insert_static(sym, span, rest, value, ctx)
            }
            ast::Attr::Str(string) => {
                let parts = string.normalized_parts();
                if parts.len() == 1
                    && let ast::InterpolPart::Literal(lit) =
                        parts.into_iter().next().expect("len checked")
                {
                    let sym = ctx.intern_string(lit);
                    return self.insert_static(sym, span, rest, value, ctx);
                }
                self.insert_dynamic(first.clone(), span, rest, value, ctx)
            }
            ast::Attr::Dynamic(_) => self.insert_dynamic(first.clone(), span, rest, value, ctx),
        }
    }

    fn insert_static(
        &mut self,
        sym: StringId,
        span: TextRange,
        path: &[ast::Attr],
        value: ast::Expr,
        ctx: &mut impl DowngradeContext<'id, 'ir>,
    ) -> Result<()> {
        if !path.is_empty() {
            match self.stcs.entry(sym) {
                Entry::Occupied(mut entry) => {
                    let (existing, existing_span) = entry.get_mut();

                    if let PendingValue::Expr(ast::Expr::AttrSet(attrset)) = existing
                        && attrset.rec_token().is_some()
                    {
                        let base = attrset.clone();
                        let ext_entry = make_attrpath_value_entry(
                            Vec::from_iter_in(path.iter().cloned(), ctx.bump()),
                            value,
                        );
                        *existing = PendingValue::ExtendedRecAttrSet {
                            base,
                            extensions: Vec::from_iter_in([ext_entry], ctx.bump()),
                        };
                        return Ok(());
                    }

                    if let PendingValue::ExtendedRecAttrSet { extensions, .. } = existing {
                        let ext_entry = make_attrpath_value_entry(
                            Vec::from_iter_in(path.iter().cloned(), ctx.bump()),
                            value,
                        );
                        extensions.push(ext_entry);
                        return Ok(());
                    }

                    let nested = Self::ensure_pending_set(existing, ctx, *existing_span)?;
                    nested.insert(path, value, ctx)
                }
                Entry::Vacant(entry) => {
                    let mut nested = PendingAttrSet::new_in(ctx.bump());
                    nested.insert(path, value, ctx)?;
                    entry.insert((PendingValue::Set(nested), span));
                    Ok(())
                }
            }
        } else {
            match self.stcs.entry(sym) {
                Entry::Occupied(mut entry) => {
                    let (existing, existing_span) = entry.get_mut();
                    Self::merge_value(existing, *existing_span, value, span, ctx)
                }
                Entry::Vacant(entry) => {
                    entry.insert((PendingValue::Expr(value), span));
                    Ok(())
                }
            }
        }
    }

    fn insert_dynamic(
        &mut self,
        attr: ast::Attr,
        span: TextRange,
        path: &[ast::Attr],
        value: ast::Expr,
        ctx: &mut impl DowngradeContext<'id, 'ir>,
    ) -> Result<()> {
        if !path.is_empty() {
            let mut nested = PendingAttrSet::new_in(ctx.bump());
            nested.insert_dynamic(
                path[0].clone(),
                path[0].syntax().text_range(),
                &path[1..],
                value,
                ctx,
            )?;
            self.dyns.push((attr, PendingValue::Set(nested), span));
        } else {
            self.dyns.push((attr, PendingValue::Expr(value), span));
        }
        Ok(())
    }

    fn ensure_pending_set<'a>(
        value: &'a mut PendingValue<'ir>,
        ctx: &mut impl DowngradeContext<'id, 'ir>,
        span: TextRange,
    ) -> Result<&'a mut PendingAttrSet<'ir>> {
        match value {
            PendingValue::Set(set) => Ok(set),
            PendingValue::Expr(expr) => {
                if let ast::Expr::AttrSet(attrset) = expr {
                    let mut nested = PendingAttrSet::new_in(ctx.bump());
                    nested.collect_entries(attrset.entries(), ctx)?;
                    *value = PendingValue::Set(nested);
                    match value {
                        PendingValue::Set(set) => Ok(set),
                        _ => unreachable!(),
                    }
                } else {
                    Err(Error::downgrade_error(
                        "attribute already defined but is not an attribute set".to_string(),
                        ctx.get_current_source(),
                        span,
                    ))
                }
            }
            PendingValue::ExtendedRecAttrSet { .. } => Err(Error::downgrade_error(
                "cannot add nested attributes to rec attribute set with extensions".to_string(),
                ctx.get_current_source(),
                span,
            )),
            PendingValue::InheritFrom(..) | PendingValue::InheritScope(..) => {
                Err(Error::downgrade_error(
                    "attribute already defined (inherited)".to_string(),
                    ctx.get_current_source(),
                    span,
                ))
            }
        }
    }

    fn merge_value(
        existing: &mut PendingValue<'ir>,
        existing_span: TextRange,
        new_value: ast::Expr,
        new_span: TextRange,
        ctx: &mut impl DowngradeContext<'id, 'ir>,
    ) -> Result<()> {
        match existing {
            PendingValue::Set(existing_set) => {
                if let ast::Expr::AttrSet(new_attrset) = new_value {
                    existing_set.collect_entries(new_attrset.entries(), ctx)
                } else {
                    Err(Error::downgrade_error(
                        "attribute already defined as attribute set".to_string(),
                        ctx.get_current_source(),
                        new_span,
                    ))
                }
            }
            PendingValue::Expr(existing_expr) => {
                if let ast::Expr::AttrSet(existing_attrset) = existing_expr {
                    if let ast::Expr::AttrSet(new_attrset) = new_value {
                        let is_rec = existing_attrset.rec_token().is_some();
                        if is_rec {
                            let base = existing_attrset.clone();
                            let extensions: Vec<'ir, _> =
                                new_attrset.entries().collect_in(ctx.bump());
                            *existing = PendingValue::ExtendedRecAttrSet { base, extensions };
                            Ok(())
                        } else {
                            let mut merged = PendingAttrSet::new_in(ctx.bump());
                            merged.collect_entries(existing_attrset.entries(), ctx)?;
                            merged.collect_entries(new_attrset.entries(), ctx)?;
                            *existing = PendingValue::Set(merged);
                            Ok(())
                        }
                    } else {
                        Err(Error::downgrade_error(
                            "attribute already defined as attribute set".to_string(),
                            ctx.get_current_source(),
                            new_span,
                        ))
                    }
                } else {
                    Err(Error::downgrade_error(
                        "attribute already defined".to_string(),
                        ctx.get_current_source(),
                        existing_span,
                    ))
                }
            }
            PendingValue::ExtendedRecAttrSet { extensions, .. } => {
                if let ast::Expr::AttrSet(new_attrset) = new_value {
                    extensions.extend(new_attrset.entries());
                    Ok(())
                } else {
                    Err(Error::downgrade_error(
                        "attribute already defined as attribute set".to_string(),
                        ctx.get_current_source(),
                        new_span,
                    ))
                }
            }
            PendingValue::InheritFrom(..) | PendingValue::InheritScope(..) => {
                Err(Error::downgrade_error(
                    "attribute already defined (inherited)".to_string(),
                    ctx.get_current_source(),
                    existing_span,
                ))
            }
        }
    }

    fn collect_entries(
        &mut self,
        entries: impl Iterator<Item = ast::Entry>,
        ctx: &mut impl DowngradeContext<'id, 'ir>,
    ) -> Result<()> {
        for entry in entries {
            match entry {
                ast::Entry::Inherit(inherit) => {
                    self.collect_inherit(inherit, ctx)?;
                }
                ast::Entry::AttrpathValue(value) => {
                    let span = value.syntax().text_range();
                    let attrpath = value.attrpath().require(ctx, span)?;
                    let path: Vec<'ir, _> = attrpath.attrs().collect_in(ctx.bump());
                    let expr = value.value().require(ctx, span)?;
                    self.insert(&path, expr, ctx)?;
                }
            }
        }
        Ok(())
    }

    fn collect_inherit(
        &mut self,
        inherit: ast::Inherit,
        ctx: &mut impl DowngradeContext<'id, 'ir>,
    ) -> Result<()> {
        let from = inherit
            .from()
            .map(|f| {
                let span = f.syntax().text_range();
                f.expr().require(ctx, span)
            })
            .transpose()?;
        for attr in inherit.attrs() {
            let span = attr.syntax().text_range();
            let sym = match &attr {
                ast::Attr::Ident(ident) => ctx.intern_string(ident.to_string()),
                ast::Attr::Str(s) => {
                    let parts = s.normalized_parts();
                    if parts.len() == 1
                        && let ast::InterpolPart::Literal(lit) =
                            parts.into_iter().next().expect("len checked")
                    {
                        ctx.intern_string(lit)
                    } else {
                        return Err(Error::downgrade_error(
                            "dynamic attributes not allowed in inherit".to_string(),
                            ctx.get_current_source(),
                            span,
                        ));
                    }
                }
                ast::Attr::Dynamic(_) => {
                    return Err(Error::downgrade_error(
                        "dynamic attributes not allowed in inherit".to_string(),
                        ctx.get_current_source(),
                        span,
                    ));
                }
            };

            if self.stcs.contains_key(&sym) {
                return Err(Error::downgrade_error(
                    format!("attribute '{}' already defined", ctx.resolve_sym(sym)),
                    ctx.get_current_source(),
                    span,
                ));
            }

            let pending_value = if let Some(ref from_expr) = from {
                PendingValue::InheritFrom(from_expr.clone(), sym, span)
            } else {
                PendingValue::InheritScope(sym, span)
            };

            self.stcs.insert(sym, (pending_value, span));
        }
        Ok(())
    }
}

fn make_attrpath_value_entry<'ir>(path: Vec<'ir, ast::Attr>, value: ast::Expr) -> ast::Entry {
    use rnix::{NixLanguage, SyntaxKind};
    use rowan::{GreenNodeBuilder, Language, NodeOrToken};

    let mut builder = GreenNodeBuilder::new();
    builder.start_node(NixLanguage::kind_to_raw(SyntaxKind::NODE_ATTRPATH_VALUE));

    builder.start_node(NixLanguage::kind_to_raw(SyntaxKind::NODE_ATTRPATH));
    for attr in path {
        fn add_node(builder: &mut GreenNodeBuilder, node: &rowan::SyntaxNode<NixLanguage>) {
            for child in node.children_with_tokens() {
                match child {
                    NodeOrToken::Node(n) => {
                        builder.start_node(NixLanguage::kind_to_raw(n.kind()));
                        add_node(builder, &n);
                        builder.finish_node();
                    }
                    NodeOrToken::Token(t) => {
                        builder.token(NixLanguage::kind_to_raw(t.kind()), t.text());
                    }
                }
            }
        }
        builder.start_node(NixLanguage::kind_to_raw(attr.syntax().kind()));
        add_node(&mut builder, attr.syntax());
        builder.finish_node();
    }
    builder.finish_node();

    builder.token(NixLanguage::kind_to_raw(SyntaxKind::TOKEN_ASSIGN), "=");

    builder.start_node(NixLanguage::kind_to_raw(value.syntax().kind()));
    fn add_node_value(builder: &mut GreenNodeBuilder, node: &rowan::SyntaxNode<NixLanguage>) {
        for child in node.children_with_tokens() {
            match child {
                NodeOrToken::Node(n) => {
                    builder.start_node(NixLanguage::kind_to_raw(n.kind()));
                    add_node_value(builder, &n);
                    builder.finish_node();
                }
                NodeOrToken::Token(t) => {
                    builder.token(NixLanguage::kind_to_raw(t.kind()), t.text());
                }
            }
        }
    }
    add_node_value(&mut builder, value.syntax());
    builder.finish_node();

    builder.token(NixLanguage::kind_to_raw(SyntaxKind::TOKEN_SEMICOLON), ";");

    builder.finish_node();

    let green = builder.finish();
    let node = rowan::SyntaxNode::<NixLanguage>::new_root(green);
    ast::Entry::cast(node).expect("constructed valid Entry node")
}

struct FinalizedAttrSet<'id, 'ir> {
    stcs: HashMap<'ir, StringId, (GhostRoMaybeThunkRef<'id, 'ir>, TextRange)>,
    dyns: Vec<
        'ir,
        (
            GhostRoIrRef<'id, 'ir>,
            GhostRoMaybeThunkRef<'id, 'ir>,
            TextRange,
        ),
    >,
}

fn downgrade_attrs<'id, 'ir>(
    attrs: impl ast::HasEntry + AstNode,
    ctx: &mut impl DowngradeContext<'id, 'ir>,
) -> Result<FinalizedAttrSet<'id, 'ir>> {
    let mut pending = PendingAttrSet::new_in(ctx.bump());
    pending.collect_entries(attrs.entries(), ctx)?;
    finalize_pending_set::<_, true>(pending, &HashMap::new_in(ctx.bump()), ctx)
}

fn downgrade_attr<'id, 'ir>(
    attr: ast::Attr,
    ctx: &mut impl DowngradeContext<'id, 'ir>,
) -> Result<Attr<GhostRoIrRef<'id, 'ir>>> {
    use ast::Attr::*;
    use ast::InterpolPart::*;
    match attr {
        Ident(ident) => Ok(Attr::Str(
            ctx.intern_string(ident.to_string()),
            ident.syntax().text_range(),
        )),
        Str(string) => {
            let parts = string.normalized_parts();
            let span = string.syntax().text_range();
            if parts.is_empty() {
                Ok(Attr::Str(ctx.intern_string(""), span))
            } else if parts.len() == 1 {
                match parts.into_iter().next().expect("len checked") {
                    Literal(ident) => Ok(Attr::Str(ctx.intern_string(ident), span)),
                    Interpolation(interpol) => Ok(Attr::Dynamic(
                        interpol
                            .expr()
                            .require(ctx, interpol.syntax().text_range())?
                            .downgrade(ctx)?,
                        span,
                    )),
                }
            } else {
                let bump = ctx.bump();
                let parts = parts
                    .into_iter()
                    .map(|part| match part {
                        Literal(lit) => {
                            let id = ctx.intern_string(lit);
                            Ok(ctx.new_expr(Ir::Str(id)))
                        }
                        Interpolation(interpol) => interpol
                            .expr()
                            .require(ctx, interpol.syntax().text_range())?
                            .downgrade(ctx),
                    })
                    .collect_in::<Result<Vec<'ir, _>>>(bump)?;
                Ok(Attr::Dynamic(
                    ctx.new_expr(Ir::ConcatStrings {
                        parts,
                        force_string: true,
                    }),
                    span,
                ))
            }
        }
        Dynamic(dynamic) => {
            let span = dynamic.syntax().text_range();
            Ok(Attr::Dynamic(
                dynamic.expr().require(ctx, span)?.downgrade(ctx)?,
                span,
            ))
        }
    }
}

fn downgrade_attrpath<'id, 'ir>(
    attrpath: ast::Attrpath,
    ctx: &mut impl DowngradeContext<'id, 'ir>,
) -> Result<Vec<'ir, Attr<GhostRoIrRef<'id, 'ir>>>> {
    let bump = ctx.bump();
    attrpath
        .attrs()
        .map(|attr| downgrade_attr(attr, ctx))
        .collect_in::<Result<Vec<'ir, _>>>(bump)
}

struct PatternBindings<'id, 'ir> {
    body: GhostRoIrRef<'id, 'ir>,
    required: Vec<'ir, (StringId, TextRange)>,
    optional: Vec<'ir, (StringId, TextRange)>,
}

fn downgrade_pattern_bindings<'id, 'ir, Ctx>(
    pat_entries: impl Iterator<Item = ast::PatEntry>,
    alias: Option<StringId>,
    ctx: &mut Ctx,
    body_fn: impl FnOnce(&mut Ctx, &[StringId]) -> Result<GhostRoIrRef<'id, 'ir>>,
) -> Result<PatternBindings<'id, 'ir>>
where
    Ctx: DowngradeContext<'id, 'ir>,
{
    struct Param {
        sym: StringId,
        sym_span: TextRange,
        default: Option<ast::Expr>,
        span: TextRange,
    }
    let mut seen_params = HashSet::new();
    let bump = ctx.bump();
    let mut params = Vec::new_in(bump);
    let mut keys = Vec::new_in(bump);
    for entry in pat_entries {
        let ident = entry.ident().require(ctx, entry.syntax().text_range())?;
        let sym_span = ident.syntax().text_range();
        let sym = ctx.intern_string(ident.syntax().text().to_string());
        let default = entry.default();
        let span = entry.syntax().text_range();

        if !seen_params.insert(sym) {
            return Err(Error::downgrade_error(
                format!("duplicate parameter '{}'", ctx.resolve_sym(sym)),
                ctx.get_current_source(),
                span,
            ));
        }
        params.push(Param {
            sym,
            sym_span,
            default,
            span,
        });
        keys.push(sym);
    }

    if let Some(alias_sym) = alias {
        keys.push(alias_sym);
    }

    let mut required = Vec::new_in(bump);
    let mut optional = Vec::new_in(bump);
    for &Param {
        sym,
        sym_span,
        ref default,
        ..
    } in params.iter()
    {
        if default.is_none() {
            required.push((sym, sym_span));
        } else {
            optional.push((sym, sym_span));
        }
    }

    let arg = ctx.new_expr(Ir::Arg { layer: 0 });
    let arg_thunk = ctx.maybe_thunk(arg);
    ctx.with_let_scope(&keys, |ctx| {
        let vals = params
            .into_iter()
            .map(|param| {
                let Param {
                    sym,
                    sym_span,
                    default,
                    span,
                } = param;
                let default = default.map(|default| default.downgrade(ctx)).transpose()?;

                let expr = ctx.new_expr(Ir::Select {
                    expr: arg,
                    attrpath: Vec::from_iter_in([Attr::Str(sym, sym_span)], bump),
                    default,
                    span,
                });
                Ok(ctx.maybe_thunk(expr))
            })
            .chain(alias.into_iter().map(|_| Ok(arg_thunk)))
            .collect_in::<Result<_>>(bump)?;

        let body = body_fn(ctx, &keys)?;

        Ok((
            vals,
            PatternBindings {
                body,
                required,
                optional,
            },
        ))
    })
}

fn downgrade_let_bindings<'id, 'ir, Ctx, F>(
    entries: Vec<'ir, ast::Entry>,
    ctx: &mut Ctx,
    body_fn: F,
) -> Result<GhostRoIrRef<'id, 'ir>>
where
    Ctx: DowngradeContext<'id, 'ir>,
    F: FnOnce(&mut Ctx, &[StringId]) -> Result<GhostRoIrRef<'id, 'ir>>,
{
    downgrade_rec_attrs_impl::<_, _, false>(entries, ctx, |ctx, binding_keys, _dyns| {
        body_fn(ctx, binding_keys)
    })
}

fn downgrade_rec_bindings<'id, 'ir, Ctx>(
    entries: Vec<'ir, ast::Entry>,
    ctx: &mut Ctx,
) -> Result<GhostRoIrRef<'id, 'ir>>
where
    Ctx: DowngradeContext<'id, 'ir>,
{
    downgrade_rec_attrs_impl::<_, _, true>(entries, ctx, |ctx, binding_keys, dyns| {
        let mut stcs = HashMap::new_in(ctx.bump());
        let dyns = Vec::from_iter_in(dyns.iter().cloned(), ctx.bump());

        for sym in binding_keys {
            let expr = ctx.lookup(*sym, rnix::TextRange::default())?;
            stcs.insert(*sym, (expr, rnix::TextRange::default()));
        }

        Ok(ctx.new_expr(Ir::AttrSet { stcs, dyns }))
    })
}

fn downgrade_rec_attrs_impl<'id, 'ir, Ctx, F, const ALLOW_DYN: bool>(
    entries: Vec<'ir, ast::Entry>,
    ctx: &mut Ctx,
    body_fn: F,
) -> Result<GhostRoIrRef<'id, 'ir>>
where
    Ctx: DowngradeContext<'id, 'ir>,
    F: FnOnce(
        &mut Ctx,
        &[StringId],
        &[(
            GhostRoIrRef<'id, 'ir>,
            GhostRoMaybeThunkRef<'id, 'ir>,
            TextRange,
        )],
    ) -> Result<GhostRoIrRef<'id, 'ir>>,
{
    let mut pending = PendingAttrSet::new_in(ctx.bump());
    pending.collect_entries(entries.iter().cloned(), ctx)?;

    let binding_syms = collect_binding_syms::<_, ALLOW_DYN>(&pending, ctx)?;
    let keys: Vec<'ir, _> = binding_syms.into_iter().collect_in(ctx.bump());

    let inherit_lookups = collect_inherit_lookups(&entries, ctx)?;

    ctx.with_let_scope(&keys, |ctx| {
        let finalized = finalize_pending_set::<_, ALLOW_DYN>(pending, &inherit_lookups, ctx)?;
        let vals = {
            let mut temp = Vec::with_capacity_in(keys.len(), ctx.bump());
            for sym in &keys {
                temp.push(finalized.stcs.get(sym).expect("WTF").0);
            }
            temp
        };
        body_fn(ctx, &keys, &finalized.dyns).map(|body| (vals, body))
    })
}

fn collect_inherit_lookups<'id: 'ir, 'ir, Ctx: DowngradeContext<'id, 'ir>>(
    entries: &[ast::Entry],
    ctx: &mut Ctx,
) -> Result<HashMap<'ir, StringId, (GhostRoMaybeThunkRef<'id, 'ir>, TextRange)>> {
    let mut inherit_lookups = HashMap::new_in(ctx.bump());
    for entry in entries {
        if let ast::Entry::Inherit(inherit) = entry
            && inherit.from().is_none()
        {
            for attr in inherit.attrs() {
                if let ast::Attr::Ident(ident) = attr {
                    let attr_span = ident.syntax().text_range();
                    let sym = ctx.intern_string(ident.to_string());
                    let expr = ctx.lookup(sym, attr_span)?;
                    inherit_lookups.insert(sym, (expr, attr_span));
                }
            }
        }
    }
    Ok(inherit_lookups)
}

fn collect_binding_syms<'id: 'ir, 'ir, Ctx: DowngradeContext<'id, 'ir>, const ALLOW_DYN: bool>(
    pending: &PendingAttrSet,
    ctx: &mut Ctx,
) -> Result<HashSet<StringId>> {
    let mut binding_syms = HashSet::new();

    for (sym, (_, span)) in &pending.stcs {
        if !binding_syms.insert(*sym) {
            return Err(Error::downgrade_error(
                format!("attribute '{}' already defined", ctx.resolve_sym(*sym)),
                ctx.get_current_source(),
                *span,
            ));
        }
    }

    Ok(binding_syms)
}

fn finalize_pending_set<'id, 'ir, Ctx: DowngradeContext<'id, 'ir>, const ALLOW_DYN: bool>(
    pending: PendingAttrSet,
    inherit_lookups: &HashMap<StringId, (GhostRoMaybeThunkRef<'id, 'ir>, TextRange)>,
    ctx: &mut Ctx,
) -> Result<FinalizedAttrSet<'id, 'ir>> {
    let mut stcs = HashMap::new_in(ctx.bump());
    let mut dyns = Vec::new_in(ctx.bump());

    for (sym, (value, value_span)) in pending.stcs {
        let expr = finalize_pending_value::<_, ALLOW_DYN>(value, inherit_lookups, ctx)?;
        stcs.insert(sym, (ctx.maybe_thunk(expr), value_span));
    }

    if ALLOW_DYN {
        for (attr, value, value_span) in pending.dyns {
            let key_id = downgrade_attr(attr, ctx)?;
            let key_expr = match key_id {
                Attr::Dynamic(id, _) => id,
                Attr::Str(sym, _attr_span) => ctx.new_expr(Ir::Str(sym)),
            };
            let value = finalize_pending_value::<_, ALLOW_DYN>(value, inherit_lookups, ctx)?;
            dyns.push((key_expr, ctx.maybe_thunk(value), value_span));
        }
    }

    Ok(FinalizedAttrSet { stcs, dyns })
}

fn finalize_pending_value<'id, 'ir, Ctx: DowngradeContext<'id, 'ir>, const ALLOW_DYN: bool>(
    value: PendingValue,
    inherit_lookups: &HashMap<StringId, (GhostRoMaybeThunkRef<'id, 'ir>, TextRange)>,
    ctx: &mut Ctx,
) -> Result<GhostRoIrRef<'id, 'ir>> {
    match value {
        PendingValue::Expr(expr) => expr.downgrade(ctx),
        PendingValue::InheritFrom(from_expr, sym, span) => {
            let from = Downgrade::downgrade(from_expr, ctx)?;
            Ok(ctx.new_expr(Ir::Select {
                expr: from,
                attrpath: Vec::from_iter_in([Attr::Str(sym, span)], ctx.bump()),
                default: None,
                span,
            }))
        }
        PendingValue::InheritScope(sym, span) => {
            if let Some(&(expr, _)) = inherit_lookups.get(&sym) {
                Ok(ctx.new_expr(Ir::MaybeThunk(expr)))
            } else {
                ctx.lookup(sym, span)
                    .map(|val| ctx.new_expr(Ir::MaybeThunk(val)))
            }
        }
        PendingValue::Set(set) => {
            let attrset = finalize_pending_set::<_, ALLOW_DYN>(set, inherit_lookups, ctx)?;
            Ok(ctx.new_expr(Ir::AttrSet {
                stcs: attrset.stcs,
                dyns: attrset.dyns,
            }))
        }
        PendingValue::ExtendedRecAttrSet {
            base, extensions, ..
        } => {
            let mut all_entries: Vec<'ir, _> = base.entries().collect_in(ctx.bump());
            all_entries.extend(extensions);
            downgrade_rec_bindings(all_entries, ctx)
        }
    }
}

fn downgrade_path<'id, 'ir>(
    parts: impl IntoIterator<Item = ast::InterpolPart<ast::PathContent>>,
    ctx: &mut impl DowngradeContext<'id, 'ir>,
) -> Result<GhostRoIrRef<'id, 'ir>> {
    let bump = ctx.bump();
    let parts = parts
        .into_iter()
        .map(|part| match part {
            ast::InterpolPart::Literal(lit) => {
                let id = ctx.intern_string(lit.text());
                Ok(ctx.new_expr(Ir::Str(id)))
            }
            ast::InterpolPart::Interpolation(interpol) => interpol
                .expr()
                .require(ctx, interpol.syntax().text_range())?
                .downgrade(ctx),
        })
        .collect_in::<Result<Vec<'ir, _>>>(bump)?;
    let expr = if parts.len() == 1 {
        parts.into_iter().next().expect("length checked")
    } else {
        ctx.new_expr(Ir::ConcatStrings {
            parts,
            force_string: false,
        })
    };
    Ok(ctx.new_expr(Ir::Path(expr)))
}