//! Processes out `#[cfg]` and `#[cfg_attr]` attributes from the input for the derive macro
use std::{cell::OnceCell, ops::ControlFlow};

use ::tt::TextRange;
use base_db::{Crate, SourceDatabase};
use cfg::CfgExpr;
use parser::T;
use smallvec::SmallVec;
use syntax::{
    AstNode, PreorderWithTokens, SyntaxElement, SyntaxNode, SyntaxToken, WalkEvent,
    ast::{self, HasAttrs},
};
use syntax_bridge::DocCommentDesugarMode;

use crate::{
    attrs::{AstPathExt, AttrId, expand_cfg_attr, is_item_tree_filtered_attr},
    fixup::{self, SyntaxFixupUndoInfo},
    span_map::SpanMap,
    tt::{self, DelimSpan, Span},
};

struct ItemIsCfgedOut;

#[derive(Debug)]
struct ExpandedAttrToProcess {
    attr: ast::Meta,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum NextExpandedAttrState {
    NotStarted,
    InTheMiddle,
}

#[derive(Debug)]
struct AstAttrToProcess {
    range: TextRange,
    expanded_attrs: SmallVec<[ExpandedAttrToProcess; 1]>,
    expanded_attrs_idx: usize,
    next_expanded_attr: NextExpandedAttrState,
    pound_span: Span,
    brackets_span: DelimSpan,
    /// If `Some`, this is an inner attribute.
    excl_span: Option<Span>,
}

fn macro_input_callback(
    db: &dyn SourceDatabase,
    is_derive: bool,
    censor_item_tree_attr_ids: &[AttrId],
    krate: Crate,
    default_span: Span,
    span_map: SpanMap<'_>,
) -> impl FnMut(&mut PreorderWithTokens, &WalkEvent<SyntaxElement>) -> (bool, Vec<tt::Leaf>) {
    let cfg_options = OnceCell::new();
    let cfg_options = move || *cfg_options.get_or_init(|| krate.cfg_options(db));

    let mut should_strip_attr = {
        let mut item_tree_attr_id = 0;
        let mut censor_item_tree_attr_ids_index = 0;
        move || {
            let mut result = false;
            if let Some(&next_censor_attr_id) =
                censor_item_tree_attr_ids.get(censor_item_tree_attr_ids_index)
                && next_censor_attr_id.item_tree_index() == item_tree_attr_id
            {
                censor_item_tree_attr_ids_index += 1;
                result = true;
            }
            item_tree_attr_id += 1;
            result
        }
    };

    let mut attrs = Vec::new();
    let mut attrs_idx = 0;
    let mut has_inner_attrs_owner = false;
    let mut in_attr = false;
    let mut done_with_attrs = false;
    let mut did_top_attrs = false;
    move |preorder, event| {
        match event {
            WalkEvent::Enter(SyntaxElement::Node(node)) => {
                if done_with_attrs {
                    return (true, Vec::new());
                }

                if ast::Attr::can_cast(node.kind()) {
                    in_attr = true;
                    let node_range = node.text_range();
                    while attrs
                        .get(attrs_idx)
                        .is_some_and(|it: &AstAttrToProcess| it.range != node_range)
                    {
                        attrs_idx += 1;
                    }
                } else if !in_attr && let Some(has_attrs) = ast::AnyHasAttrs::cast(node.clone()) {
                    // Attributes of the form `key = value` have `ast::Expr` in them, which returns `Some` for
                    // `AnyHasAttrs::cast()`, so we also need to check `in_attr`.

                    if has_inner_attrs_owner {
                        has_inner_attrs_owner = false;
                        return (true, Vec::new());
                    }

                    if did_top_attrs && !is_derive {
                        // Derives need all attributes handled, but attribute macros need only the top attributes handled.
                        done_with_attrs = true;
                        return (true, Vec::new());
                    }
                    did_top_attrs = true;

                    if let Some(inner_attrs_node) = has_attrs.inner_attributes_node()
                        && inner_attrs_node != *node
                    {
                        has_inner_attrs_owner = true;
                    }

                    let node_attrs = ast::attrs_including_inner(&has_attrs);

                    attrs.clear();
                    node_attrs.clone().for_each(|attr| {
                        let span_for = |token: Option<SyntaxToken>| {
                            token
                                .map(|token| span_map.span_for_range(token.text_range()))
                                .unwrap_or(default_span)
                        };
                        attrs.push(AstAttrToProcess {
                            range: attr.syntax().text_range(),
                            pound_span: span_for(attr.pound_token()),
                            brackets_span: DelimSpan {
                                open: span_for(attr.l_brack_token()),
                                close: span_for(attr.r_brack_token()),
                            },
                            excl_span: attr
                                .excl_token()
                                .map(|token| span_map.span_for_range(token.text_range())),
                            expanded_attrs: SmallVec::new(),
                            expanded_attrs_idx: 0,
                            next_expanded_attr: NextExpandedAttrState::NotStarted,
                        });
                    });

                    attrs_idx = 0;
                    let strip_current_item =
                        expand_cfg_attr(node_attrs, &cfg_options, |attr, top_attr| {
                            // Find the attr.
                            while attrs[attrs_idx].range != top_attr.syntax().text_range() {
                                attrs_idx += 1;
                            }

                            let mut strip_current_attr = false;
                            match &attr {
                                ast::Meta::CfgMeta(attr) => {
                                    if let Some(cfg_predicate) = attr.cfg_predicate() {
                                        let cfg_expr = CfgExpr::parse_from_ast(cfg_predicate);
                                        if cfg_options().check(&cfg_expr) == Some(false) {
                                            return ControlFlow::Break(ItemIsCfgedOut);
                                        }
                                        strip_current_attr = true;
                                    }
                                }
                                _ => {
                                    if attr
                                        .path()
                                        .as_one_segment()
                                        .is_none_or(|name| !is_item_tree_filtered_attr(&name))
                                    {
                                        strip_current_attr = should_strip_attr();
                                    }
                                }
                            }

                            if !strip_current_attr {
                                attrs[attrs_idx]
                                    .expanded_attrs
                                    .push(ExpandedAttrToProcess { attr });
                            }

                            ControlFlow::Continue(())
                        });
                    attrs_idx = 0;

                    if strip_current_item.is_some() {
                        preorder.skip_subtree();
                        attrs.clear();

                        'eat_comma: {
                            // If there is a comma after this node, eat it too.
                            let mut events_until_comma = 0;
                            for event in preorder.clone() {
                                match event {
                                    WalkEvent::Enter(SyntaxElement::Node(_))
                                    | WalkEvent::Leave(_) => {}
                                    WalkEvent::Enter(SyntaxElement::Token(token)) => {
                                        let kind = token.kind();
                                        if kind == T![,] {
                                            break;
                                        } else if !kind.is_trivia() {
                                            break 'eat_comma;
                                        }
                                    }
                                }
                                events_until_comma += 1;
                            }
                            preorder.nth(events_until_comma);
                        }

                        return (false, Vec::new());
                    }
                }
            }
            WalkEvent::Leave(SyntaxElement::Node(node)) => {
                if ast::Attr::can_cast(node.kind()) {
                    in_attr = false;
                    attrs_idx += 1;
                }
            }
            WalkEvent::Enter(SyntaxElement::Token(token)) => {
                if !in_attr {
                    return (true, Vec::new());
                }

                let Some(ast_attr) = attrs.get_mut(attrs_idx) else {
                    return (true, Vec::new());
                };
                let token_range = token.text_range();
                let Some(expanded_attr) = ast_attr.expanded_attrs.get(ast_attr.expanded_attrs_idx)
                else {
                    // No expanded attributes in this `ast::Attr`, or we finished them all already, either way
                    // the remaining tokens should be discarded.
                    return (false, Vec::new());
                };
                match ast_attr.next_expanded_attr {
                    NextExpandedAttrState::NotStarted => {
                        if token_range.start() >= expanded_attr.attr.syntax().text_range().start() {
                            // We started the next attribute.
                            let mut insert_tokens = Vec::with_capacity(3);
                            insert_tokens.push(tt::Leaf::Punct(tt::Punct {
                                char: '#',
                                spacing: tt::Spacing::Alone,
                                span: ast_attr.pound_span,
                            }));
                            if let Some(span) = ast_attr.excl_span {
                                insert_tokens.push(tt::Leaf::Punct(tt::Punct {
                                    char: '!',
                                    spacing: tt::Spacing::Alone,
                                    span,
                                }));
                            }
                            insert_tokens.push(tt::Leaf::Punct(tt::Punct {
                                char: '[',
                                spacing: tt::Spacing::Alone,
                                span: ast_attr.brackets_span.open,
                            }));

                            ast_attr.next_expanded_attr = NextExpandedAttrState::InTheMiddle;

                            return (true, insert_tokens);
                        } else {
                            // Before any attribute or between the attributes.
                            return (false, Vec::new());
                        }
                    }
                    NextExpandedAttrState::InTheMiddle => {
                        if token_range.start() >= expanded_attr.attr.syntax().text_range().end() {
                            // Finished the current attribute.
                            let insert_tokens = vec![tt::Leaf::Punct(tt::Punct {
                                char: ']',
                                spacing: tt::Spacing::Alone,
                                span: ast_attr.brackets_span.close,
                            })];

                            ast_attr.next_expanded_attr = NextExpandedAttrState::NotStarted;
                            ast_attr.expanded_attrs_idx += 1;

                            // It's safe to ignore the current token because between attributes
                            // there is always at least one token we skip - either the closing bracket
                            // in `#[]` or the comma in case of multiple attrs in `cfg_attr` expansion.
                            return (false, insert_tokens);
                        } else {
                            // Still in the middle.
                            return (true, Vec::new());
                        }
                    }
                }
            }
            WalkEvent::Leave(SyntaxElement::Token(_)) => {}
        }
        (true, Vec::new())
    }
}

pub(crate) fn attr_macro_input_to_token_tree(
    db: &dyn SourceDatabase,
    node: &SyntaxNode,
    span_map: SpanMap<'_>,
    span: Span,
    is_derive: bool,
    censor_item_tree_attr_ids: &[AttrId],
    krate: Crate,
) -> (tt::TopSubtree, SyntaxFixupUndoInfo) {
    let fixups = fixup::fixup_syntax(span_map, node, span, DocCommentDesugarMode::ProcMacro);
    (
        syntax_bridge::syntax_node_to_token_tree_modified(
            node,
            span_map,
            fixups.append,
            fixups.remove,
            span,
            DocCommentDesugarMode::ProcMacro,
            macro_input_callback(db, is_derive, censor_item_tree_attr_ids, krate, span, span_map),
        ),
        fixups.undo_info,
    )
}
