use proc_macro2::{TokenStream, TokenTree};
use proc_macro_error::SpanRange;

#[derive(Debug)]
pub enum Markup {
    Block(Block),
    Literal {
        content: String,
        span: SpanRange,
    },
    Symbol {
        symbol: TokenStream,
    },
    Splice {
        expr: TokenStream,
        outer_span: SpanRange,
    },
    Element {
        name: TokenStream,
        attrs: Attrs,
        body: ElementBody,
    },
    Let {
        at_span: SpanRange,
        tokens: TokenStream,
    },
    Special {
        segments: Vec<Special>,
    },
    Match {
        at_span: SpanRange,
        head: TokenStream,
        arms: Vec<MatchArm>,
        arms_span: SpanRange,
    },
}

impl Markup {
    pub fn span(&self) -> SpanRange {
        match *self {
            Markup::Block(ref block) => block.span(),
            Markup::Literal { span, .. } => span,
            Markup::Symbol { ref symbol } => span_tokens(symbol.clone()),
            Markup::Splice { outer_span, .. } => outer_span,
            Markup::Element { ref name, ref body, .. } => {
                let name_span = span_tokens(name.clone());
                name_span.join_range(body.span())
            },
            Markup::Let { at_span, ref tokens } => {
                at_span.join_range(span_tokens(tokens.clone()))
            },
            Markup::Special { ref segments } => {
                join_ranges(segments.iter().map(Special::span))
            },
            Markup::Match { at_span, arms_span, .. } => {
                at_span.join_range(arms_span)
            },
        }
    }
}

pub type Attrs = Vec<Attr>;

#[derive(Debug)]
pub enum Attr {
    Class {
        dot_span: SpanRange,
        name: Markup,
        toggler: Option<Toggler>,
    },
    Id {
        hash_span: SpanRange,
        name: Markup,
    },
    Attribute {
        attribute: Attribute,
    },
}

impl Attr {
    pub fn span(&self) -> SpanRange {
        match *self {
            Attr::Class { dot_span, ref name, ref toggler } => {
                let name_span = name.span();
                let dot_name_span = dot_span.join_range(name_span);
                if let Some(toggler) = toggler {
                    dot_name_span.join_range(toggler.cond_span)
                } else {
                    dot_name_span
                }
            },
            Attr::Id { hash_span, ref name } => {
                let name_span = name.span();
                hash_span.join_range(name_span)
            },
            Attr::Attribute { ref attribute } => attribute.span(),
        }
    }
}

#[derive(Debug)]
pub enum ElementBody {
    Void { semi_span: SpanRange },
    Block { block: Block },
}

impl ElementBody {
    pub fn span(&self) -> SpanRange {
        match *self {
            ElementBody::Void { semi_span } => semi_span,
            ElementBody::Block { ref block } => block.span(),
        }
    }
}

#[derive(Debug)]
pub struct Block {
    pub markups: Vec<Markup>,
    pub outer_span: SpanRange,
}

impl Block {
    pub fn span(&self) -> SpanRange {
        self.outer_span
    }
}

#[derive(Debug)]
pub struct Special {
    pub at_span: SpanRange,
    pub head: TokenStream,
    pub body: Block,
}

impl Special {
    pub fn span(&self) -> SpanRange {
        let body_span = self.body.span();
        self.at_span.join_range(body_span)
    }
}

#[derive(Debug)]
pub struct Attribute {
    pub name: TokenStream,
    pub attr_type: AttrType,
}

impl Attribute {
    fn span(&self) -> SpanRange {
        let name_span = span_tokens(self.name.clone());
        if let Some(attr_type_span) = self.attr_type.span() {
            name_span.join_range(attr_type_span)
        } else {
            name_span
        }
    }
}

#[derive(Debug)]
pub enum AttrType {
    Normal {
        value: Markup,
    },
    Empty {
        toggler: Option<Toggler>,
    },
}

impl AttrType {
    fn span(&self) -> Option<SpanRange> {
        match *self {
            AttrType::Normal { ref value } => Some(value.span()),
            AttrType::Empty { ref toggler } => toggler.as_ref().map(Toggler::span),
        }
    }
}

#[derive(Debug)]
pub struct Toggler {
    pub cond: TokenStream,
    pub cond_span: SpanRange,
}

impl Toggler {
    fn span(&self) -> SpanRange {
        self.cond_span
    }
}

#[derive(Debug)]
pub struct MatchArm {
    pub head: TokenStream,
    pub body: Block,
}

pub fn span_tokens<I: IntoIterator<Item=TokenTree>>(tokens: I) -> SpanRange {
    join_ranges(tokens.into_iter().map(|s| SpanRange::single_span(s.span())))
}

pub fn join_ranges<I: IntoIterator<Item=SpanRange>>(ranges: I) -> SpanRange {
    let mut iter = ranges.into_iter();
    let first = match iter.next() {
        Some(span) => span,
        None => return SpanRange::call_site(),
    };
    let last = iter.last().unwrap_or(first);
    first.join_range(last)
}