use std::path::{PathBuf,Path};
use std::collections::HashMap;
use core::error::Error;
use std::time::SystemTime;

mod lexer;
mod parser;
mod position;
mod error;
pub mod context;

pub use derive::DeepCrowMappable;

pub use error::{DeepCrowError,Result};
pub use position::*;
pub use context::{Context,Value,MappedStructure,StatefulContext,MappedValue,MappedList,MappedHash};

#[derive(Debug)]
pub struct DeepCrow {
    views: HashMap<String, View>,
    sources: Vec<ViewSource>,
}

#[derive(PartialEq,Eq,Debug,Clone)]
pub enum ViewSource {
    File {
        path: PathBuf,
        loaded: SystemTime,
    },
    Static,
    External {
        key: String,
    },
}

#[derive(Debug)]
struct View {
    name: String,
    source: usize,
    outputs: Vec<Output>,
//    theme: Option<String>
    layout: Option<String>,
}

impl View {
    fn process(&self, input: &dyn for<'a> MappedStructure<'a>) -> Result<Context> {
        let mut out_vars = Context::new();
        for output in &self.outputs {
            let mut buf = String::new();
            let sc = StatefulContext::root( input );
            exec( &sc, &output.code, &mut buf )?;
            out_vars.insert( output.name.clone(), Value::String(buf) );
        }
        Ok(out_vars)
    }
}

#[derive(Debug)]
struct Output {
    name: String,
    code: Vec<Symbol>,
}

type Properties = HashMap<String, String>;

#[derive(Debug)]
enum Symbol {
    Loop(Identifier, Vec<Symbol>),
    Show(Identifier,Properties),
    If(Identifier, Vec<Symbol>, Vec<Symbol>),
    Text(String),
}

#[derive(Debug,Clone,PartialEq)]
pub enum IdentifierValue {
    Root,
    Name(String),
    Index(usize),
}

pub type Identifier = Vec<IdentifierValue>;

impl DeepCrow {
    pub fn new() -> Self {
        Self {
            views: HashMap::new(),
            sources: vec![ViewSource::Static],
        }
    }

    fn id_source(&mut self, src: &ViewSource ) -> usize {
        for idx in 0..self.sources.len() {
            if self.sources[idx] == *src {
                return idx;
            }
        }

        // Nothing found, add a new one
        let idx = self.sources.len();
        self.sources.push( src.clone() );
        idx
    }

    pub fn load_file(&mut self, path: &Path) -> std::result::Result<(),Box::<dyn Error>> {
        let time = if let Ok(meta) = path.metadata() {
            if let Ok(t) = meta.modified() {
                t
            } else if let Ok(t) = meta.created() {
                t
            } else {
                SystemTime::now()
            }
        } else {
            SystemTime::now()
        };
        let source_id = self.id_source(
            &ViewSource::File {
                path: path.to_path_buf(),
                loaded: time,
                }
            );
        let p = parser::Parser::new();
        self.register_views(
            p.parse(
                &String::from_utf8( std::fs::read( path )? )?,
                source_id
                )?,
            )?;
        Ok(())
    }

    pub fn load_static(&mut self, data: &str) -> Result<()> {
        let source_id = self.id_source( &ViewSource::Static );
        let p = parser::Parser::new();
        self.register_views( p.parse( &data, source_id )? )
    }

    pub fn load_external(&mut self, key: &str, data: &str) -> Result<()> {
        let source_id = self.id_source(
            &ViewSource::External{ key: key.to_string()}
            );
        
        let p = parser::Parser::new();    
        self.register_views(
            p.parse( &data, source_id )?,
            )
    }

    fn register_views(&mut self, views: Vec<View>) -> Result<()> {
        for view in views {
            self.views.insert( view.name.clone(), view );
        }
        Ok(())
    }

    pub fn get_view_source(&self, view: &str) -> Option<ViewSource> {
        if let Some(view) = self.views.get(view) {
            if view.source < self.sources.len() {
                Some(self.sources[view.source].clone())
            } else {
                None
            }
        } else {
            None
        }
    }

    pub fn render_partial(&self, view: &str, input: &dyn for<'a> MappedStructure<'a> ) -> Result<Context> {
        if let Some(view) = self.views.get(view) {
            return view.process( input )
        } else {
            return Err(DeepCrowError::other("No such view found".into()));
        }
    }

    pub fn render(&self, view: &str, input: &dyn for<'a> MappedStructure<'a> ) -> Result<String> {
        if let Some(view) = self.views.get( view ) {
            //println!("::Symbol tree::\n{:?}", view );
            let mut output = view.process( input )?;
            if let Some(l) = &view.layout {
                self.render( l, &output )
            } else {
                if let Some(content) = output.remove("content") &&
                    let Value::String(s) = content {

                    Ok(s)
                } else {
                    Err(DeepCrowError::other("No content found in root layout.".into()))
                }
            }

        } else {
            Err(DeepCrowError::other("No such view found".into()))
        }
    }
}

fn exec<'a>(input: &StatefulContext<'a>, tokens: &Vec<Symbol>, buf: &mut String) -> Result<()> {
    for token in tokens {
        match token {
            Symbol::Loop(ident,code) => {
                //println!("!!! Loop over: {:?} {:?}", ident, input.get_value( &ident ));
                if let Some(value) = input.get_value( &ident ) &&
                    let MappedValue::List(list) = value {
                        let output = 
                        &list.for_each(&|rec: &MappedValue, buf: &mut String| {
                            if let MappedValue::Struct(d) = rec {
                                exec( &input.local(*d), code, buf )?;
                            }
                            Ok(())
                        })?;
                        //println!("!!! Output from loop: {}", output );
                    buf.push_str( &output );
                }
            }
            Symbol::If(ident,code,other) => {
                if let Some(value) = input.get_value( &ident ) &&
                    let MappedValue::Bool(b) = value && b {
                    exec(input, code, buf)?
                } else {
                    exec(input, other, buf)?
                }
            }
            Symbol::Show(ident,p) => {
                let format = if let Some(s) = p.get("format") {
                    s
                } else {
                    &"".to_string()
                };
                if let Some(value) = input.get_value( &ident ) {
                    match value {
                        MappedValue::Struct(_) => {
                            buf.push_str("Struct");
                        }
                        MappedValue::List(_) => {
                            buf.push_str("List");
                        }
                        MappedValue::Bool(b) => {
                            if b {
                                buf.push_str("true");
                            } else {
                                buf.push_str("false");
                            }
                        }
                        MappedValue::Str(s) => {
                            buf.push_str(s);
                        }
                        MappedValue::String(s) => {
                            buf.push_str(s.as_str());
                        }
                        MappedValue::Int8(i) => {
                            buf.push_str(&i.to_string());
                        }
                        MappedValue::Int16(i) => {
                            buf.push_str(&i.to_string());
                        }
                        MappedValue::Int32(i) => {
                            buf.push_str(&i.to_string());
                        }
                        MappedValue::Int64(i) => {
                            buf.push_str(&i.to_string());
                        }
                        MappedValue::UInt8(i) => {
                            buf.push_str(&i.to_string());
                        }
                        MappedValue::UInt16(i) => {
                            buf.push_str(&i.to_string());
                        }
                        MappedValue::UInt32(i) => {
                            buf.push_str(&i.to_string());
                        }
                        MappedValue::UInt64(i) => {
                            buf.push_str(&i.to_string());
                        }
                        MappedValue::Float32(f) => {
                            if format == "" {
                                buf.push_str(&f.to_string());
                            } else {
                                buf.push_str(&f.to_string());
                            }
                        }
                        MappedValue::Float64(f) => {
                            if format == "" {
                                buf.push_str(&f.to_string());
                            } else {
                                buf.push_str(&f.to_string());
                            }
                        }
                    }
                }
            }
            Symbol::Text(s) => {
                buf.push_str( s );
            }
            //_ => {}
        }
    }
    Ok(())
}