use std::io::{Error, ErrorKind::Other, Result};
use std::collections::HashMap;
use std::fs::File;
use std::path::PathBuf;
use std::io::Read;

const TXT_TEMPLATE: &'static str = include_str!("../templates/index.txt");
const HTML_TEMPLATE: &'static str = include_str!("../templates/index.html");
const GMI_TEMPLATE: &'static str = include_str!("../templates/index.gmi");
const RSS_TEMPLATE: &'static str = include_str!("../templates/feed.xml");

// Parse and Render

pub enum Token {
    Text(String),
    DisplayDirective { content: String },
    ConditionalDirective { condition: String, children: Vec<Token>},
    IteratorDirective { collection: String, member_label: String, children: Vec<Token> }
}

impl std::fmt::Display for Token {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        match self {
            Token::Text(label) => write!(f, "Text {}", label),
            Token::DisplayDirective{content} => write!(f, "DisplayDirective {}", content),
            Token::ConditionalDirective{condition, children} => {
                write!(f, "ConditionalDirective {} [[[\n", condition)?;
                for child in children {
                    write!(f, "\t{}\n", child)?;
                }
                write!(f, "\n]]]")
            },
            Token::IteratorDirective{collection, member_label, children} => {
                write!(f, "{} in {}\n", collection, member_label)?;
                for child in children {
                    write!(f, "\t{}\n", child)?;
                }
                write!(f, "\n]]]")
            },
        }
    }
}

#[derive(Clone)]
pub enum TemplateValue {
    String(String),
    Unsigned(u64),
    Bool(bool),
    Collection(Vec<TemplateContext>),
    Context(TemplateContext)
}

impl TemplateValue {
    fn render(&self) -> String {
        match self {
            TemplateValue::String(string) => string.to_string(),
            TemplateValue::Unsigned(number) => format!("{}", number),
            TemplateValue::Bool(bool) => format!("{}", bool),
            _ => "".to_string()
        }
    }
}

pub type TemplateContext = HashMap<String, TemplateValue>;

struct TemplateContextGetter {}
impl TemplateContextGetter {
    fn get(context: &TemplateContext, path: &str) -> Option<TemplateValue> {
        let path_parts: Vec<&str> = path.split('.').collect();
        TemplateContextGetter::recursively_get_value(context, &path_parts)
    }

    fn recursively_get_value(context: &TemplateContext, path: &[&str]) -> Option<TemplateValue> {
        match context.get(path[0]) {
            Some(TemplateValue::Context(next)) if path.len() > 1 => TemplateContextGetter::recursively_get_value(next, &path[1..]),
            Some(value) if path.len() == 1 => Some(value.clone()),
            _ => None
        }
    }
}

pub struct ParsedTemplate {
    pub tokens: Vec<Token>
}

impl ParsedTemplate {
    pub fn render(&self, context: &TemplateContext) -> Result<String> {
        ParsedTemplate::render_tokens(&self.tokens, context)
    }

    pub fn render_tokens(tokens: &Vec<Token>, context: &TemplateContext) -> Result<String> {
        let mut rendered_template: String = String::new();
        for token in tokens {
            match token {
                Token::Text(contents) => rendered_template.push_str(&contents),
                Token::DisplayDirective { content } => {
                    let value = TemplateContextGetter::get(context, &content)
                        .ok_or_else(|| Error::new(Other, format!("{} is not a valid key", content)))?;
                    rendered_template.push_str(&value.render());
                },
                Token::ConditionalDirective { condition, children} => {
                    let mut negator = false;
                    let mut condition = condition.to_string();
                    if condition.starts_with('!') {
                        negator = true;
                        condition = condition[1..].to_string();
                    }

                    let value = TemplateContextGetter::get(context, &condition)
                        .ok_or_else(|| Error::new(Other, format!("{} is not a valid key", condition)))?;

                    match value {
                        TemplateValue::Bool(value) => {
                            if negator ^ value {
                                rendered_template.push_str(&ParsedTemplate::render_tokens(children, context)?)
                            }
                            Ok(())
                        },
                        _ => Err(Error::new(Other, format!("{} is not a boolean value", condition))),
                    }?;
                },
                Token::IteratorDirective { collection, member_label, children } => {
                    let value = TemplateContextGetter::get(context, &collection)
                        .ok_or_else(|| Error::new(Other, format!("{} is not a valid key", collection)))?;

                    match value {
                        TemplateValue::Collection(collection) => {
                            for member in collection {
                                let mut child_context = context.clone();
                                child_context.insert(
                                    member_label.to_string(),
                                    TemplateValue::Context(member)
                                );
                                rendered_template.push_str(&ParsedTemplate::render_tokens(&children, &child_context)?)
                            }
                            Ok(())
                        },
                        _ => Err(Error::new(Other, format!("{} is not a collection", collection))),
                    }?;
                }
            }
        }
        Ok(rendered_template)
    }
}

pub fn parse(template: &str) -> Option<ParsedTemplate> {
    let mut tokens = Vec::new();
    tokenize(template, &mut tokens).ok()?;
    Some(ParsedTemplate {
        tokens
    })
}

fn tokenize(template: &str, tokens: &mut Vec<Token>) -> Result<()> {
    let mut remaining_template = template;

    while !remaining_template.is_empty() && remaining_template.contains("{{") {
        let directive_start_index = remaining_template.find("{{")
            .ok_or_else(|| Error::new(Other, "Was expecting at least one tag opener"))?;
        if directive_start_index > 0 {
            let text = remaining_template[..directive_start_index].to_string();
            tokens.push(Token::Text(text.to_string()));
        }
        remaining_template = &remaining_template[directive_start_index..];

        let directive_end_index = remaining_template.find("}}")
            .ok_or_else(|| Error::new(Other, "Was expecting }} after {{"))? + 2;
        let directive = &remaining_template[..directive_end_index];
        remaining_template = &remaining_template[directive_end_index..];

        let directive_type = directive.chars().nth(2).unwrap();
        match directive_type {
            // Simple Directives
            '=' => {
                let content = directive[3..directive.len() - 2].trim();
                tokens.push(Token::DisplayDirective{
                    content: content.to_string()
                });
            },
            // Block Directives
            '?' | '~' => {
                let content = directive[3..directive.len() - 2].trim();
                let mut children = Vec::new();

                match directive_type {
                    '?' => {
                        let closing_block = remaining_template.find("{{?}}").unwrap();
                        let directive_block = &remaining_template[..closing_block];
                        remaining_template = &remaining_template[closing_block + 5..];
                        tokenize(directive_block, &mut children)?;
                        tokens.push(Token::ConditionalDirective{
                            condition: content.to_string(),
                            children
                        });
                    },
                    '~' => {
                        let parts: Vec<_> = content.splitn(2, ':').collect();
                        let closing_block = remaining_template.find("{{~}}").unwrap();
                        let directive_block = &remaining_template[..closing_block];
                        remaining_template = &remaining_template[closing_block + 5..];
                        tokenize(directive_block, &mut children)?;
                        if parts.len() == 2 {
                            tokens.push(Token::IteratorDirective {
                                collection: parts[0].trim().to_string(),
                                member_label: parts[1].trim().to_string(),
                                children
                            });
                        }
                    },
                    _ => unreachable!()
                }
            },
            _ => unreachable!()
        }
    }
    tokens.push(Token::Text(remaining_template.to_string()));
    Ok(())
}

// File helpers.

pub fn find(template_directory: &PathBuf, filename: &str) -> Option<String> {
    let template_path = template_directory.join(filename);
    if template_path.exists() {
        let mut contents = String::new();
        if File::open(template_path).ok()?.read_to_string(&mut contents).is_ok() {
            return Some(contents);
        }
    }
    find_default(filename)
}

fn find_default(filename: &str) -> Option<String> {
    match filename {
        "index.txt" => Some(TXT_TEMPLATE.to_string()),
        "index.html" => Some(HTML_TEMPLATE.to_string()),
        "index.gmi" => Some(GMI_TEMPLATE.to_string()),
        "index.rss" => Some(RSS_TEMPLATE.to_string()),
        &_ => None
    }
}