use super::types::*;
use std::io::Read;
use rin_util::{AutoLoader, Result, Error};
use std::fs;
use std::path::{Path, PathBuf};
use glin::{self, CreationContext, program::ShaderPrecision};
use super::CreationProxy;
use regex::Regex;

/// Program settings to be used by a glsl program autoloader
#[derive(Clone, Debug)]
pub struct ProgramSettings<P: AsRef<Path> + Clone>{
    /// glsl version, in desktop 330, 400, 420...
    /// in gles 2 or 3
    pub version: usize,
    /// precision of the shaders, by now applied
    /// to vertex and fragment
    pub precision: ShaderPrecision,
    /// enabled extensions by name
    pub extensions: Vec<String>,
    /// add or change defines in the shaders
    pub defines: Vec<(String, String)>,
    /// shader type / path pairs
    pub shaders: Vec<(GLenum, P)>,
    /// shader type / replacement pairs
    /// where replacement is two strings one for search and the second for replace by
    /// every time the shader is realoaded any replacements will be applied
    pub shader_replace: Vec<(GLenum, (String, String))>,
    /// search paths for includes.
    /// includes will be looked for in the same folder as the shader and if not found
    /// there in each of the paths in this vector until found
    pub includes_search_paths: Vec<P>,
    /// includes substitutions that don't come from files in the file system
    /// the key of this hashmap is the name of the include as found in the shaders
    /// the value is the source for the include
    pub includes_dictionary: glin::HashMap<String,String>,
}

impl<P: AsRef<Path> + Clone> ProgramSettings<P>{
    /// Converts this settings into glin::program::Settings by loading
    /// the shaders from the specified paths and turning them into
    /// a source `String`
    pub fn to_glin(&self) -> Result<glin::program::Settings<String>>{
        let mut errors = vec![];
        let mut includes = self.includes_dictionary.clone();
        let shaders = self.shaders.iter().filter_map(|&(ty, ref path)| {
            let shader_file = fs::File::open(path)
                .map_err(|err| format!("{}", err));
            if let Ok(mut shader_file) = shader_file{
                let mut shader_src = String::new();
                let read = shader_file.read_to_string(&mut shader_src)
                    .map_err(|err| format!("{}", err));
                if let Ok(_) = read{
                    shader_src = self.shader_replace.iter()
                        .filter(|(shader_ty, _)| *shader_ty == ty)
                        .fold(shader_src, |src, (_, (from, to))| src.replace(from, to));

                    for (include, path) in includes_paths(
                        path.as_ref().parent().unwrap(),
                        &self.includes_search_paths,
                        &self.includes_dictionary,
                        &shader_src)
                    {
                        let mut include_src = String::new();
                        if let Err(err) = fs::File::open(path)
                            .and_then( |mut file| file.read_to_string(&mut include_src))
                        {
                            errors.push(format!("{}", err))
                        }else{
                            include_src = self.shader_replace.iter()
                                .filter(|(shader_ty, _)| *shader_ty == ty)
                                .fold(include_src, |src, (_, (from, to))| src.replace(from, to));
                            includes.insert(include.to_str().unwrap().to_owned(), include_src);
                        }
                    }

                    Some((ty, shader_src))
                }else{
                    errors.push(read.unwrap_err());
                    None
                }
            }else{
                errors.push(shader_file.unwrap_err());
                None
            }
        }).collect::<Vec<_>>();

        if errors.is_empty(){
            Ok(glin::program::Settings{
                version: self.version,
                precision: self.precision,
                extensions: self.extensions.clone(),
                defines: self.defines.clone(),
                bindings: crate::default_attribute_bindings().clone(),
                shaders,
                includes,
                .. Default::default()
            })
        }else{
            Err(Error::new(&errors.join("\n\n")))
        }
    }
}

fn load_program<P: AsRef<Path> + Clone>(gl: &CreationProxy, settings: ProgramSettings<P>) -> Result<glin::Program>{
    let settings = settings.to_glin()?;
    gl.new_program().from_settings(settings)
        .map_err(|e| Error::with_cause("Program load error",e))
}

// Returns a vector of include paths as they are included and their corresponding absolute paths
fn includes_paths<P1,P2>(
    shader_path: P1,
    search_paths: &[P2],
    includes_dictionary: &glin::HashMap<String,String>,
    shader_src: &str) -> Vec<(PathBuf, PathBuf)>
where P1: AsRef<Path>,
      P2: AsRef<Path>
{
    let search = r"#include\s*".to_string() + "\"(.*)\"";
    let re = Regex::new(&search).unwrap();
    let shader_path = shader_path.as_ref().to_owned();
    re.captures_iter(shader_src).flat_map(move |captures|{
        if includes_dictionary.contains_key(&captures[1]) {
            vec![]
        }else{
            let include_path = Path::new(&captures[1]);
            let absolute_path = if include_path.is_absolute(){
                include_path.to_owned()
            }else{
                let mut path = shader_path.join(include_path);
                let mut search_paths = search_paths.iter();
                while !path.exists(){
                    if let Some(search_path) = search_paths.next(){
                        path = search_path.as_ref().join(include_path);
                    }else{
                        break;
                    }
                }

                path
            };

            if let Ok(mut include) = fs::File::open(&absolute_path){
                let mut include_src = String::new();
                include.read_to_string(&mut include_src).unwrap();
                let mut includes = includes_paths(
                    shader_path.clone(),
                    search_paths,
                    includes_dictionary,
                    &include_src);
                includes.push((include_path.to_owned(), absolute_path));
                includes
            }else{
                vec![(include_path.to_owned(), absolute_path)]
            }
        }
    }).collect()
}

pub(crate) fn new_program<P: AsRef<Path> + Clone + 'static>(gl: CreationProxy, settings: ProgramSettings<P>) -> AutoLoader<glin::Program>{
    let paths = {
        let includes = settings.shaders.iter()
            .filter_map(|(ty, path)|{
                if let Ok(mut shader) = fs::File::open(path.as_ref()){
                    let mut shader_src = String::new();
                    shader.read_to_string(&mut shader_src).unwrap();
                    shader_src = settings.shader_replace.iter()
                        .filter(|(shader_ty, _)| shader_ty == ty)
                        .fold(shader_src, |src, (_, (from, to))| src.replace(from, to));
                    Some(includes_paths(
                        path.as_ref().parent().unwrap(),
                        &settings.includes_search_paths,
                        &settings.includes_dictionary,
                        &shader_src))
                }else{
                    None
                }
            })
            .flat_map(|it| it);

        settings.shaders
            .iter()
            .map(|(_ty, path)| path.as_ref().to_owned())
            .chain(includes.map(|(_include, absolute)| absolute))
            .map(|path| path.to_str().unwrap().to_string())
            .collect::<Vec<_>>()
    };

    AutoLoader::new(
        paths,
        move || load_program(&gl, settings.clone())
    )
}