use crate::*;

use vagabond::*;


type ParseFn = fn(&str, Option<&Path>) -> Vec<Symbol>;


/// Gather all source units from a PATH-style environment variable.
pub fn gather_from_path_variable(variable: &str, extension: &str, parse: ParseFn) -> Vec<SourceUnit> {
    let mut source_units = Vec::new();
    if let Ok(string) = std::env::var(variable) {
        for path in string.split(":").map(PathBuf::from) {
            source_units.extend(gather_from_path(&path, extension, parse));
        }
    };
    return source_units;
}

/// Gather source units at or descending from a path.
pub fn gather_from_path(path: &Path, extension: &str, parse: ParseFn) -> Vec<SourceUnit> {
    let mut source_units = Vec::new();
    if let Ok(entry) = Entry::from_path(path) {
        if EntryType::File == entry.entry_type {
            if let Ok(unit) = SourceUnit::from_path(&entry.path, extension, parse) {
                source_units.push(unit);
            }
        } else if EntryType::Directory == entry.entry_type {
            if let Ok(entries) = traverse_directory(entry.path) {
                for entry in entries {
                    if let Ok(unit) = SourceUnit::from_path(&entry.path, extension, parse) {
                        source_units.push(unit);
                    }
                }
            }
        }
    };
    return source_units;
}


pub struct SourceUnit {
    pub main: SourceFile,
    pub head: Option<SourceFile>,
    pub tail: Option<SourceFile>,
}

impl SourceUnit {
    /// Load source from a main file and an associated head and tail file.
    pub fn from_path<P: AsRef<Path>>(path: P, extension: &str, parse: ParseFn) -> Result<Self, FileError> {
        let main_path = { path.as_ref().canonicalize().unwrap_or_else(|_| path.as_ref().to_path_buf()) };
        let main_path_str = main_path.as_os_str().to_string_lossy().to_string();
        let head_extension = format!("head.{extension}");
        let tail_extension = format!("tail.{extension}");
        let is_head = main_path_str.ends_with(&head_extension);
        let is_tail = main_path_str.ends_with(&tail_extension);
        let is_not_main = !main_path_str.ends_with(extension);
        // Head and tail files will be picked up later along with the main file.
        if is_not_main || is_head || is_tail { return Err(FileError::InvalidExtension); }

        let source_code = read_file(path.as_ref())?;
        let symbols = parse(&source_code, Some(path.as_ref()));
        let head_path = main_path.with_extension(head_extension);
        let tail_path = main_path.with_extension(tail_extension);

        macro_rules! parse_file {
            ($path:expr) => {
                read_file(&$path).ok().map(|source_code| {
                    let symbols = parse(&source_code, Some(&$path));
                    let path = $path;
                    SourceFile { symbols, source_code, path }
                })
            };
        }
        let main = SourceFile { path: main_path, source_code, symbols };
        let head = parse_file!(head_path);
        let tail = parse_file!(tail_path);
        Ok( SourceUnit { main, head, tail } )
    }

    /// Load from a string of source code.
    pub fn from_string<P: AsRef<Path>>(source_code: String, path: P, parse: ParseFn) -> Self {
        let path = { path.as_ref().canonicalize().unwrap_or_else(|_| path.as_ref().to_path_buf()) };
        let symbols = parse(&source_code, Some(&path));
        Self { main: SourceFile { path, source_code, symbols }, head: None, tail: None }
    }

    pub fn name(&self) -> Option<String> {
        self.main.path.file_name().map(|s| s.to_string_lossy().to_string())
    }

    pub fn path(&self) -> String {
        self.main.path.as_os_str().to_string_lossy().to_string()

    }
}


pub struct SourceFile {
    pub path: PathBuf,
    pub source_code: String,
    pub symbols: Vec<Symbol>,
}

pub struct Symbol {
    pub name: String,
    pub source: SourceSpan,
    pub role: SymbolRole,
}

#[derive(PartialEq)]
pub enum SymbolRole {
    Definition(DefinitionType),
    Reference,
}

#[derive(PartialEq)]
pub enum DefinitionType {
    MustPrecedeReference,
    CanFollowReference,
}