use std::borrow::Cow;
use std::collections::hash_map::{Entry, HashMap};
use std::fs::read_to_string;
use std::iter::FusedIterator;
use std::path::{Path, PathBuf};
use std::str::FromStr;
use std::sync::{Arc, OnceLock};

use parser::node::Whitespace;
use parser::{Node, Parsed};
use proc_macro2::Span;
use rustc_hash::FxBuildHasher;
use syn::punctuated::Punctuated;
use syn::spanned::Spanned;
use syn::{Attribute, Expr, ExprLit, ExprPath, Ident, Lit, LitBool, LitStr, Meta, Token};

use crate::config::{Config, SyntaxAndCache};
use crate::{CompileError, FileInfo, MsgValidEscapers, OnceMap};

#[derive(Clone)]
pub(crate) struct TemplateInput<'a> {
    pub(crate) ast: &'a syn::DeriveInput,
    pub(crate) enum_ast: Option<&'a syn::DeriveInput>,
    pub(crate) config: &'a Config,
    pub(crate) syntax: &'a SyntaxAndCache<'a>,
    pub(crate) source: &'a Source,
    pub(crate) source_span: Option<Span>,
    pub(crate) block: Option<(&'a str, Span)>,
    #[cfg(feature = "blocks")]
    pub(crate) blocks: &'a [Block],
    pub(crate) print: Print,
    pub(crate) escaper: &'a str,
    pub(crate) path: Arc<Path>,
    pub(crate) fields: Arc<[String]>,
}

impl TemplateInput<'_> {
    /// Extract the template metadata from the `DeriveInput` structure. This
    /// mostly recovers the data for the `TemplateInput` fields from the
    /// `template()` attribute list fields.
    pub(crate) fn new<'n>(
        ast: &'n syn::DeriveInput,
        enum_ast: Option<&'n syn::DeriveInput>,
        config: &'n Config,
        args: &'n TemplateArgs,
    ) -> Result<TemplateInput<'n>, CompileError> {
        let TemplateArgs {
            source: (source, source_span),
            block,
            #[cfg(feature = "blocks")]
            blocks,
            print,
            escaping,
            ext,
            ext_span,
            syntax,
            ..
        } = args;

        // Validate the `source` and `ext` value together, since they are
        // related. In case `source` was used instead of `path`, the value
        // of `ext` is merged into a synthetic `path` value here.
        let path = match (&source, &ext) {
            (Source::Path(path), _) => config.find_template(path, None, None)?,
            (&Source::Source(_), Some(ext)) => {
                PathBuf::from(format!("{}.{}", ast.ident, ext)).into()
            }
            (&Source::Source(_), None) => {
                return Err(CompileError::no_file_info(
                    #[cfg(not(feature = "code-in-doc"))]
                    "must include `ext` attribute when using `source` attribute",
                    #[cfg(feature = "code-in-doc")]
                    "must include `ext` attribute when using `source` or `in_doc` attribute",
                    None,
                ));
            }
        };

        // Validate syntax
        let syntax = syntax.as_deref().map_or_else(
            || Ok(config.syntaxes.get(config.default_syntax).unwrap()),
            |s| {
                config.syntaxes.get(s).ok_or_else(|| {
                    CompileError::no_file_info(format_args!("syntax `{s}` is undefined"), None)
                })
            },
        )?;

        // Match extension against defined output formats

        let escaping = escaping
            .as_deref()
            .or_else(|| path.extension().and_then(|s| s.to_str()))
            .unwrap_or_default();

        let escaper = config
            .escapers
            .iter()
            .find_map(|(extensions, path)| {
                extensions
                    .contains(&Cow::Borrowed(escaping))
                    .then_some(path.as_ref())
            })
            .ok_or_else(|| {
                CompileError::no_file_info(
                    format_args!(
                        "no escaper defined for extension '{escaping}'. You can define an escaper \
                        in the config file (named `askama.toml` by default). {}",
                        MsgValidEscapers(&config.escapers),
                    ),
                    *ext_span,
                )
            })?;

        let empty_punctuated = Punctuated::new();
        let fields = match ast.data {
            syn::Data::Struct(ref struct_) => {
                if let syn::Fields::Named(ref fields) = &struct_.fields {
                    &fields.named
                } else {
                    &empty_punctuated
                }
            }
            syn::Data::Union(ref union_) => &union_.fields.named,
            syn::Data::Enum(_) => &empty_punctuated,
        }
        .iter()
        .map(|f| match &f.ident {
            Some(ident) => ident.to_string(),
            None => unreachable!("we checked that we are using a struct"),
        })
        .collect::<Vec<_>>();

        Ok(TemplateInput {
            ast,
            enum_ast,
            config,
            syntax,
            source,
            source_span: *source_span,
            block: block.as_ref().map(|(block, span)| (block.as_str(), *span)),
            #[cfg(feature = "blocks")]
            blocks: blocks.as_slice(),
            print: *print,
            escaper,
            path,
            fields: fields.into(),
        })
    }

    pub(crate) fn find_used_templates(
        &self,
        map: &mut HashMap<Arc<Path>, Arc<Parsed>, FxBuildHasher>,
    ) -> Result<(), CompileError> {
        let (source, source_path) = match &self.source {
            Source::Source(s) => (s.clone(), None),
            Source::Path(_) => (
                get_template_source(&self.path, None)?,
                Some(Arc::clone(&self.path)),
            ),
        };

        let mut dependency_graph = Vec::new();
        let mut check = vec![(Arc::clone(&self.path), source, source_path)];
        while let Some((path, source, source_path)) = check.pop() {
            let parsed = match self.syntax.parse(Arc::clone(&source), source_path) {
                Ok(parsed) => parsed,
                Err(err) => {
                    let msg = err
                        .message
                        .unwrap_or_else(|| "failed to parse template source".into());
                    let file_path = err
                        .file_path
                        .as_deref()
                        .unwrap_or(Path::new("<source attribute>"));
                    let file_info =
                        FileInfo::new(file_path, Some(&source), Some(&source[err.offset..]));
                    return Err(CompileError::new(msg, Some(file_info)));
                }
            };

            let mut top = true;
            let mut nested = vec![parsed.nodes()];
            while let Some(nodes) = nested.pop() {
                for n in nodes {
                    let mut add_to_check = |new_path: Arc<Path>| -> Result<(), CompileError> {
                        if let Entry::Vacant(e) = map.entry(new_path) {
                            // Add a dummy entry to `map` in order to prevent adding `path`
                            // multiple times to `check`.
                            let new_path = e.key();
                            let source = parsed.source();
                            let source = get_template_source(
                                new_path,
                                Some((
                                    &path,
                                    source,
                                    n.span().as_suffix_of(source).unwrap_or_default(),
                                )),
                            )?;
                            check.push((new_path.clone(), source, Some(new_path.clone())));
                            e.insert(Arc::default());
                        }
                        Ok(())
                    };

                    match n {
                        Node::Extends(extends) if top => {
                            let extends = self.config.find_template(
                                extends.path,
                                Some(&path),
                                Some(FileInfo::of(extends.span(), &path, &parsed)),
                            )?;
                            let dependency_path = (path.clone(), extends.clone());
                            if path == extends {
                                // We add the path into the graph to have a better looking error.
                                dependency_graph.push(dependency_path);
                                return cyclic_graph_error(&dependency_graph);
                            } else if dependency_graph.contains(&dependency_path) {
                                return cyclic_graph_error(&dependency_graph);
                            }
                            dependency_graph.push(dependency_path);
                            add_to_check(extends)?;
                        }
                        Node::Macro(m) if top => {
                            nested.push(&m.nodes);
                        }
                        Node::Import(import) if top => {
                            let import = self.config.find_template(
                                import.path,
                                Some(&path),
                                Some(FileInfo::of(import.span(), &path, &parsed)),
                            )?;
                            add_to_check(import)?;
                        }
                        Node::FilterBlock(f) => {
                            nested.push(&f.nodes);
                        }
                        Node::Include(include) => {
                            let include = self.config.find_template(
                                include.path,
                                Some(&path),
                                Some(FileInfo::of(include.span(), &path, &parsed)),
                            )?;
                            add_to_check(include)?;
                        }
                        Node::BlockDef(b) => {
                            nested.push(&b.nodes);
                        }
                        Node::If(i) => {
                            for cond in &i.branches {
                                nested.push(&cond.nodes);
                            }
                        }
                        Node::Loop(l) => {
                            nested.push(&l.body);
                            nested.push(&l.else_nodes);
                        }
                        Node::Match(m) => {
                            for arm in &m.arms {
                                nested.push(&arm.nodes);
                            }
                        }
                        Node::Lit(_)
                        | Node::Comment(_)
                        | Node::Expr(_, _)
                        | Node::Call(_)
                        | Node::Extends(_)
                        | Node::Let(_)
                        | Node::Import(_)
                        | Node::Macro(_)
                        | Node::Raw(_)
                        | Node::Continue(_)
                        | Node::Break(_) => {}
                    }
                }
                top = false;
            }
            map.insert(path, parsed);
        }
        Ok(())
    }
}

pub(crate) enum AnyTemplateArgs {
    Struct(TemplateArgs),
    Enum {
        enum_args: Option<PartialTemplateArgs>,
        vars_args: Vec<Option<PartialTemplateArgs>>,
        has_default_impl: bool,
    },
}

impl AnyTemplateArgs {
    pub(crate) fn new(ast: &syn::DeriveInput) -> Result<Self, CompileError> {
        let syn::Data::Enum(enum_data) = &ast.data else {
            return Ok(Self::Struct(TemplateArgs::new(ast)?));
        };

        let enum_args = PartialTemplateArgs::new(ast, &ast.attrs, false)?;
        let vars_args = enum_data
            .variants
            .iter()
            .map(|variant| PartialTemplateArgs::new(ast, &variant.attrs, true))
            .collect::<Result<Vec<_>, _>>()?;
        if vars_args.is_empty() {
            return Ok(Self::Struct(TemplateArgs::from_partial(ast, enum_args)?));
        }

        let mut needs_default_impl = vars_args.len();
        let enum_source = enum_args.as_ref().and_then(|v| v.source.as_ref());
        for (variant, var_args) in enum_data.variants.iter().zip(&vars_args) {
            if var_args
                .as_ref()
                .and_then(|v| v.source.as_ref())
                .or(enum_source)
                .is_none()
            {
                return Err(CompileError::new_with_span(
                    #[cfg(not(feature = "code-in-doc"))]
                    "either all `enum` variants need a `path` or `source` argument, \
                    or the `enum` itself needs a default implementation",
                    #[cfg(feature = "code-in-doc")]
                    "either all `enum` variants need a `path`, `source` or `in_doc` argument, \
                    or the `enum` itself needs a default implementation",
                    None,
                    Some(variant.ident.span()),
                ));
            } else if !var_args.is_none() {
                needs_default_impl -= 1;
            }
        }

        Ok(Self::Enum {
            enum_args,
            vars_args,
            has_default_impl: needs_default_impl > 0,
        })
    }

    pub(crate) fn take_crate_name(&mut self) -> Option<ExprPath> {
        match self {
            AnyTemplateArgs::Struct(template_args) => template_args.crate_name.take(),
            AnyTemplateArgs::Enum { enum_args, .. } => {
                if let Some(PartialTemplateArgs { crate_name, .. }) = enum_args {
                    crate_name.take()
                } else {
                    None
                }
            }
        }
    }
}

#[cfg(feature = "blocks")]
pub(crate) struct Block {
    pub(crate) name: String,
    pub(crate) span: Span,
}

pub(crate) struct TemplateArgs {
    pub(crate) source: (Source, Option<Span>),
    block: Option<(String, Span)>,
    #[cfg(feature = "blocks")]
    blocks: Vec<Block>,
    print: Print,
    escaping: Option<String>,
    ext: Option<String>,
    ext_span: Option<Span>,
    syntax: Option<String>,
    config: Option<String>,
    crate_name: Option<ExprPath>,
    pub(crate) whitespace: Option<Whitespace>,
    pub(crate) template_span: Option<Span>,
    pub(crate) config_span: Option<Span>,
}

impl TemplateArgs {
    pub(crate) fn new(ast: &syn::DeriveInput) -> Result<Self, CompileError> {
        Self::from_partial(ast, PartialTemplateArgs::new(ast, &ast.attrs, false)?)
    }

    pub(crate) fn from_partial(
        ast: &syn::DeriveInput,
        args: Option<PartialTemplateArgs>,
    ) -> Result<Self, CompileError> {
        let Some(args) = args else {
            return Err(CompileError::new_with_span(
                "no attribute `template` found",
                None,
                Some(ast.ident.span()),
            ));
        };
        Ok(Self {
            source: match args.source {
                Some(PartialTemplateArgsSource::Path(s)) => {
                    (Source::Path(s.value().into()), Some(s.span()))
                }
                Some(PartialTemplateArgsSource::Source(s)) => {
                    (Source::Source(s.value().into()), Some(s.span()))
                }
                #[cfg(feature = "code-in-doc")]
                Some(PartialTemplateArgsSource::InDoc(span, source)) => (source, Some(span)),
                None => {
                    return Err(CompileError::no_file_info(
                        #[cfg(not(feature = "code-in-doc"))]
                        "specify one template argument `path` or `source`",
                        #[cfg(feature = "code-in-doc")]
                        "specify one template argument `path`, `source` or `in_doc`",
                        Some(args.template.span()),
                    ));
                }
            },
            block: args.block.map(|value| (value.value(), value.span())),
            #[cfg(feature = "blocks")]
            blocks: args
                .blocks
                .unwrap_or_default()
                .into_iter()
                .map(|value| Block {
                    name: value.value(),
                    span: value.span(),
                })
                .collect(),
            print: args.print.unwrap_or_default(),
            escaping: args.escape.map(|value| value.value()),
            ext: args.ext.as_ref().map(|value| value.value()),
            ext_span: args.ext.as_ref().map(|value| value.span()),
            syntax: args.syntax.map(|value| value.value()),
            config: args.config.as_ref().map(|value| value.value()),
            crate_name: args.crate_name,
            whitespace: args.whitespace,
            template_span: Some(args.template.span()),
            config_span: args.config.as_ref().map(|value| value.span()),
        })
    }

    pub(crate) fn fallback() -> Self {
        Self {
            source: (Source::Source("".into()), None),
            block: None,
            #[cfg(feature = "blocks")]
            blocks: vec![],
            print: Print::default(),
            escaping: None,
            ext: Some("txt".to_string()),
            ext_span: None,
            syntax: None,
            config: None,
            crate_name: None,
            whitespace: None,
            template_span: None,
            config_span: None,
        }
    }

    pub(crate) fn config_path(&self) -> Option<&str> {
        self.config.as_deref()
    }
}

/// Try to find the source in the comment, in a `askama` code block.
///
/// This is only done if no path or source was given in the `#[template]` attribute.
#[cfg(feature = "code-in-doc")]
fn source_from_docs(
    span: Span,
    docs: &[&Attribute],
    ast: &syn::DeriveInput,
) -> Result<(Source, Option<Span>), CompileError> {
    let (source_span, source) = collect_comment_blocks(span, docs, ast)?;
    let source = strip_common_ws_prefix(source);
    let source = collect_askama_code_blocks(span, ast, source)?;
    Ok((source, source_span))
}

#[cfg(feature = "code-in-doc")]
fn collect_comment_blocks(
    span: Span,
    docs: &[&Attribute],
    ast: &syn::DeriveInput,
) -> Result<(Option<Span>, String), CompileError> {
    let mut source_span: Option<Span> = None;
    let mut assign_span = |kv: &syn::MetaNameValue| {
        // FIXME: uncomment once <https://github.com/rust-lang/rust/issues/54725> is stable
        // let new_span = kv.path.span();
        // source_span = Some(match source_span {
        //     Some(cur_span) => cur_span.join(new_span).unwrap_or(cur_span),
        //     None => new_span,
        // });

        if source_span.is_none() {
            source_span = Some(kv.path.span());
        }
    };

    let mut source = String::new();
    for a in docs {
        // is a comment?
        let Meta::NameValue(kv) = &a.meta else {
            continue;
        };
        if !kv.path.is_ident("doc") {
            continue;
        }

        // is an understood comment, e.g. not `#[doc = inline_str(…)]`
        let mut value = &kv.value;
        let value = loop {
            match value {
                Expr::Lit(lit) => break lit,
                Expr::Group(group) => value = &group.expr,
                _ => continue,
            }
        };
        let Lit::Str(value) = &value.lit else {
            continue;
        };

        assign_span(kv);
        source.push_str(value.value().as_str());
        source.push('\n');
    }
    if source.is_empty() {
        return Err(no_askama_code_block(span, ast));
    }

    Ok((source_span, source))
}

#[cfg(feature = "code-in-doc")]
fn no_askama_code_block(span: Span, ast: &syn::DeriveInput) -> CompileError {
    let kind = match &ast.data {
        syn::Data::Struct(_) => "struct",
        syn::Data::Enum(_) => "enum",
        // actually unreachable: `union`s are rejected by `TemplateArgs::new()`
        syn::Data::Union(_) => "union",
    };
    CompileError::no_file_info(
        format_args!(
            "when using `in_doc` with the value `true`, the {kind}'s documentation needs a \
             `askama` code block"
        ),
        Some(span),
    )
}

#[cfg(feature = "code-in-doc")]
fn strip_common_ws_prefix(source: String) -> String {
    let mut common_prefix_iter = source
        .lines()
        .filter_map(|s| Some(&s[..s.find(|c: char| !c.is_ascii_whitespace())?]));
    let mut common_prefix = common_prefix_iter.next().unwrap_or_default();
    for p in common_prefix_iter {
        if common_prefix.is_empty() {
            break;
        }
        let ((pos, _), _) = common_prefix
            .char_indices()
            .zip(p.char_indices())
            .take_while(|(l, r)| l == r)
            .last()
            .unwrap_or_default();
        common_prefix = &common_prefix[..pos];
    }
    if common_prefix.is_empty() {
        return source;
    }

    source
        .lines()
        .flat_map(|s| [s.get(common_prefix.len()..).unwrap_or_default(), "\n"])
        .collect()
}

#[cfg(feature = "code-in-doc")]
fn collect_askama_code_blocks(
    span: Span,
    ast: &syn::DeriveInput,
    source: String,
) -> Result<Source, CompileError> {
    use pulldown_cmark::{CodeBlockKind, Event, Parser, Tag, TagEnd};

    let mut tmpl_source = String::new();
    let mut in_askama_code = false;
    let mut had_askama_code = false;
    for e in Parser::new(&source) {
        match (in_askama_code, e) {
            (false, Event::Start(Tag::CodeBlock(CodeBlockKind::Fenced(s)))) => {
                if s.split(",")
                    .any(|s| JINJA_EXTENSIONS.contains(&s.trim_ascii()))
                {
                    in_askama_code = true;
                    had_askama_code = true;
                }
            }
            (true, Event::End(TagEnd::CodeBlock)) => in_askama_code = false,
            (true, Event::Text(text)) => tmpl_source.push_str(&text),
            _ => {}
        }
    }
    if !had_askama_code {
        return Err(no_askama_code_block(span, ast));
    }

    if tmpl_source.ends_with('\n') {
        tmpl_source.pop();
    }
    Ok(Source::Source(tmpl_source.into()))
}

struct ResultIter<I, E>(Result<I, Option<E>>);

impl<I: IntoIterator, E> From<Result<I, E>> for ResultIter<I::IntoIter, E> {
    fn from(value: Result<I, E>) -> Self {
        Self(match value {
            Ok(i) => Ok(i.into_iter()),
            Err(e) => Err(Some(e)),
        })
    }
}

impl<I: Iterator, E> Iterator for ResultIter<I, E> {
    type Item = Result<I::Item, E>;

    fn next(&mut self) -> Option<Self::Item> {
        match &mut self.0 {
            Ok(iter) => Some(Ok(iter.next()?)),
            Err(err) => Some(Err(err.take()?)),
        }
    }
}

impl<I: FusedIterator, E> FusedIterator for ResultIter<I, E> {}

#[derive(Debug, Clone, Hash, PartialEq)]
pub(crate) enum Source {
    Path(Arc<str>),
    Source(Arc<str>),
}

#[derive(Clone, Copy, Debug, PartialEq, Hash)]
pub(crate) enum Print {
    All,
    Ast,
    Code,
    None,
}

impl Default for Print {
    fn default() -> Self {
        Self::None
    }
}

impl FromStr for Print {
    type Err = String;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s {
            "all" => Ok(Self::All),
            "ast" => Ok(Self::Ast),
            "code" => Ok(Self::Code),
            "none" => Ok(Self::None),
            _ => Err(format!("invalid value for `print` option: {s}")),
        }
    }
}

fn cyclic_graph_error(dependency_graph: &[(Arc<Path>, Arc<Path>)]) -> Result<(), CompileError> {
    Err(CompileError::no_file_info(
        format_args!(
            "cyclic dependency in graph {:#?}",
            dependency_graph
                .iter()
                .map(|e| format!("{:#?} --> {:#?}", e.0, e.1))
                .collect::<Vec<String>>()
        ),
        None,
    ))
}

pub(crate) fn get_template_source(
    tpl_path: &Arc<Path>,
    import_from: Option<(&Arc<Path>, &str, &str)>,
) -> Result<Arc<str>, CompileError> {
    static CACHE: OnceLock<OnceMap<Arc<Path>, Arc<str>>> = OnceLock::new();

    CACHE.get_or_init(OnceMap::default).get_or_try_insert(
        tpl_path,
        |tpl_path| match read_to_string(tpl_path) {
            Ok(mut source) => {
                if source.ends_with('\n') {
                    let _ = source.pop();
                }
                Ok((Arc::clone(tpl_path), Arc::from(source)))
            }
            Err(err) => Err(CompileError::new(
                format_args!(
                    "unable to open template file '{}': {err}",
                    tpl_path.to_str().unwrap(),
                ),
                import_from.map(|(node_file, file_source, node_source)| {
                    FileInfo::new(node_file, Some(file_source), Some(node_source))
                }),
            )),
        },
        Arc::clone,
    )
}

pub(crate) struct PartialTemplateArgs {
    pub(crate) template: Ident,
    pub(crate) source: Option<PartialTemplateArgsSource>,
    pub(crate) block: Option<LitStr>,
    pub(crate) print: Option<Print>,
    pub(crate) escape: Option<LitStr>,
    pub(crate) ext: Option<LitStr>,
    pub(crate) syntax: Option<LitStr>,
    pub(crate) config: Option<LitStr>,
    pub(crate) whitespace: Option<Whitespace>,
    pub(crate) crate_name: Option<ExprPath>,
    #[cfg(feature = "blocks")]
    pub(crate) blocks: Option<Vec<LitStr>>,
}

#[derive(Clone)]
pub(crate) enum PartialTemplateArgsSource {
    Path(LitStr),
    Source(LitStr),
    #[cfg(feature = "code-in-doc")]
    InDoc(Span, Source),
}

impl PartialTemplateArgsSource {
    pub(crate) fn span(&self) -> Span {
        match self {
            Self::Path(s) => s.span(),
            Self::Source(s) => s.span(),
            #[cfg(feature = "code-in-doc")]
            Self::InDoc(s, _) => s.span(),
        }
    }
}

// implement PartialTemplateArgs::new()
const _: () = {
    impl PartialTemplateArgs {
        pub(crate) fn new(
            ast: &syn::DeriveInput,
            attrs: &[Attribute],
            is_enum_variant: bool,
        ) -> Result<Option<Self>, CompileError> {
            new(ast, attrs, is_enum_variant)
        }
    }

    #[inline]
    fn new(
        ast: &syn::DeriveInput,
        attrs: &[Attribute],
        is_enum_variant: bool,
    ) -> Result<Option<PartialTemplateArgs>, CompileError> {
        // FIXME: implement once <https://github.com/rust-lang/rfcs/pull/3715> is stable
        if let syn::Data::Union(data) = &ast.data {
            return Err(CompileError::new_with_span(
                "askama templates are not supported for `union` types, only `struct` and `enum`",
                None,
                Some(data.union_token.span),
            ));
        }

        #[cfg(feature = "code-in-doc")]
        let mut meta_docs = vec![];

        let mut this = PartialTemplateArgs {
            template: Ident::new("template", Span::call_site()),
            source: None,
            block: None,
            print: None,
            escape: None,
            ext: None,
            syntax: None,
            config: None,
            whitespace: None,
            crate_name: None,
            #[cfg(feature = "blocks")]
            blocks: None,
        };
        let mut has_data = false;

        for attr in attrs {
            let Some(ident) = attr.path().get_ident() else {
                continue;
            };
            if ident == "template" {
                this.template = ident.clone();
                has_data = true;
            } else {
                #[cfg(feature = "code-in-doc")]
                if ident == "doc" {
                    meta_docs.push(attr);
                }
                continue;
            }

            let args = attr
                .parse_args_with(<Punctuated<Meta, Token![,]>>::parse_terminated)
                .map_err(|e| {
                    CompileError::no_file_info(
                        format_args!("unable to parse template arguments: {e}"),
                        Some(attr.path().span()),
                    )
                })?;
            for arg in args {
                let pair = match arg {
                    Meta::NameValue(pair) => pair,
                    v => {
                        return Err(CompileError::no_file_info(
                            "unsupported attribute argument",
                            Some(v.span()),
                        ));
                    }
                };
                let ident = match pair.path.get_ident() {
                    Some(ident) => ident,
                    None => unreachable!("not possible in syn::Meta::NameValue(…)"),
                };

                if ident == "askama" {
                    if is_enum_variant {
                        return Err(CompileError::no_file_info(
                            "template attribute `askama` can only be used on the `enum`, \
                            not its variants",
                            Some(ident.span()),
                        ));
                    }
                    ensure_only_once(ident, &mut this.crate_name)?;
                    this.crate_name = Some(get_exprpath(ident, pair.value)?);
                    continue;
                } else if ident == "blocks" {
                    if !cfg!(feature = "blocks") {
                        return Err(CompileError::no_file_info(
                            "enable feature `blocks` to use `blocks` argument",
                            Some(ident.span()),
                        ));
                    } else if is_enum_variant {
                        return Err(CompileError::no_file_info(
                            "template attribute `blocks` can only be used on the `enum`, \
                            not its variants",
                            Some(ident.span()),
                        ));
                    }
                    #[cfg(feature = "blocks")]
                    {
                        ensure_only_once(ident, &mut this.blocks)?;
                        this.blocks = Some(
                            get_exprarray(ident, pair.value)?
                                .elems
                                .into_iter()
                                .map(|value| get_strlit(ident, get_lit(ident, value)?))
                                .collect::<Result<_, _>>()?,
                        );
                        continue;
                    }
                }

                let value = get_lit(ident, pair.value)?;

                if ident == "path" {
                    ensure_source_only_once(ident, &this.source)?;
                    this.source = Some(PartialTemplateArgsSource::Path(get_strlit(ident, value)?));
                } else if ident == "source" {
                    ensure_source_only_once(ident, &this.source)?;
                    this.source =
                        Some(PartialTemplateArgsSource::Source(get_strlit(ident, value)?));
                } else if ident == "in_doc" {
                    let value = get_boollit(ident, value)?;
                    if !value.value() {
                        continue;
                    }
                    ensure_source_only_once(ident, &this.source)?;

                    #[cfg(not(feature = "code-in-doc"))]
                    {
                        return Err(CompileError::no_file_info(
                            "enable feature `code-in-doc` to use `in_doc` argument",
                            Some(ident.span()),
                        ));
                    }
                    #[cfg(feature = "code-in-doc")]
                    {
                        this.source = Some(PartialTemplateArgsSource::InDoc(
                            value.span(),
                            Source::Path("".into()),
                        ));
                    }
                } else if ident == "block" {
                    set_strlit_pair(ident, value, &mut this.block)?;
                } else if ident == "print" {
                    set_parseable_string(ident, value, &mut this.print)?;
                } else if ident == "escape" {
                    set_strlit_pair(ident, value, &mut this.escape)?;
                } else if ident == "ext" {
                    set_strlit_pair(ident, value, &mut this.ext)?;
                } else if ident == "syntax" {
                    set_strlit_pair(ident, value, &mut this.syntax)?;
                } else if ident == "config" {
                    set_strlit_pair(ident, value, &mut this.config)?;
                } else if ident == "whitespace" {
                    set_parseable_string(ident, value, &mut this.whitespace)?;
                } else {
                    return Err(CompileError::no_file_info(
                        format_args!("unsupported template attribute `{ident}` found"),
                        Some(ident.span()),
                    ));
                }
            }
        }
        if !has_data {
            return Ok(None);
        }

        #[cfg(feature = "code-in-doc")]
        if let Some(PartialTemplateArgsSource::InDoc(lit_span, _)) = this.source {
            let (source, doc_span) = source_from_docs(lit_span, &meta_docs, ast)?;
            this.source = Some(PartialTemplateArgsSource::InDoc(
                doc_span.unwrap_or(lit_span),
                source,
            ));
        }

        Ok(Some(this))
    }

    fn set_strlit_pair(
        name: &Ident,
        value: ExprLit,
        dest: &mut Option<LitStr>,
    ) -> Result<(), CompileError> {
        ensure_only_once(name, dest)?;
        *dest = Some(get_strlit(name, value)?);
        Ok(())
    }

    fn set_parseable_string<T: FromStr<Err: ToString>>(
        name: &Ident,
        value: ExprLit,
        dest: &mut Option<T>,
    ) -> Result<(), CompileError> {
        ensure_only_once(name, dest)?;
        let str_value = get_strlit(name, value)?;
        *dest = Some(
            str_value
                .value()
                .parse()
                .map_err(|msg| CompileError::no_file_info(msg, Some(str_value.span())))?,
        );
        Ok(())
    }

    fn ensure_only_once<T>(name: &Ident, dest: &mut Option<T>) -> Result<(), CompileError> {
        if dest.is_none() {
            Ok(())
        } else {
            Err(CompileError::no_file_info(
                format_args!("template attribute `{name}` already set"),
                Some(name.span()),
            ))
        }
    }

    fn get_lit(name: &Ident, mut expr: Expr) -> Result<ExprLit, CompileError> {
        loop {
            match expr {
                Expr::Lit(lit) => return Ok(lit),
                Expr::Group(group) => expr = *group.expr,
                v => {
                    return Err(CompileError::no_file_info(
                        format_args!("template attribute `{name}` expects a literal"),
                        Some(v.span()),
                    ));
                }
            }
        }
    }

    fn get_strlit(name: &Ident, value: ExprLit) -> Result<LitStr, CompileError> {
        if let Lit::Str(s) = value.lit {
            Ok(s)
        } else {
            Err(CompileError::no_file_info(
                format_args!("template attribute `{name}` expects a string literal"),
                Some(value.lit.span()),
            ))
        }
    }

    fn get_boollit(name: &Ident, value: ExprLit) -> Result<LitBool, CompileError> {
        if let Lit::Bool(s) = value.lit {
            Ok(s)
        } else {
            Err(CompileError::no_file_info(
                format_args!("template attribute `{name}` expects a boolean value"),
                Some(value.lit.span()),
            ))
        }
    }

    fn get_exprpath(name: &Ident, mut expr: Expr) -> Result<ExprPath, CompileError> {
        loop {
            match expr {
                Expr::Path(path) => return Ok(path),
                Expr::Group(group) => expr = *group.expr,
                v => {
                    return Err(CompileError::no_file_info(
                        format_args!("template attribute `{name}` expects a path or identifier"),
                        Some(v.span()),
                    ));
                }
            }
        }
    }

    #[cfg(feature = "blocks")]
    fn get_exprarray(name: &Ident, mut expr: Expr) -> Result<syn::ExprArray, CompileError> {
        loop {
            match expr {
                Expr::Array(array) => return Ok(array),
                Expr::Group(group) => expr = *group.expr,
                v => {
                    return Err(CompileError::no_file_info(
                        format_args!("template attribute `{name}` expects an array"),
                        Some(v.span()),
                    ));
                }
            }
        }
    }

    fn ensure_source_only_once(
        name: &Ident,
        source: &Option<PartialTemplateArgsSource>,
    ) -> Result<(), CompileError> {
        if source.is_some() {
            return Err(CompileError::no_file_info(
                #[cfg(feature = "code-in-doc")]
                "must specify `source`, `path` or `is_doc` exactly once",
                #[cfg(not(feature = "code-in-doc"))]
                "must specify `source` or `path` exactly once",
                Some(name.span()),
            ));
        }
        Ok(())
    }
};

#[cfg(feature = "code-in-doc")]
const JINJA_EXTENSIONS: &[&str] = &["askama", "j2", "jinja", "jinja2", "rinja"];

#[test]
fn get_source() {
    let path = Config::new("", None, None, None, None)
        .and_then(|config| config.find_template("b.html", None, None))
        .unwrap();
    assert_eq!(get_template_source(&path, None).unwrap(), "bar".into());
}