//! This is documentation for the tree_magic crate.
//!
//! See the README in the repository for more information.

#[macro_use] extern crate nom;
#[macro_use] extern crate lazy_static;
extern crate petgraph;

use std::collections::HashMap;
use std::collections::HashSet;
use petgraph::prelude::*;
//use petgraph::dot::{Dot, Config};

mod fdo_magic;
mod basetype;

/// Information about currently loaded MIME types
///
/// The `graph` contains subclass relations between all given mimes.
/// (EX: `application/json` -> `text/plain` -> `application/octet-stream`)
/// This is a `petgraph` DiGraph, so you can walk the tree if needed.
/// 
/// The `hash` is a mapping between mime types and nodes on the graph.
/// The root of the graph is "all/all", so start traversing there unless
/// you need to jump to a particular node.
pub struct TypeStruct {
    pub graph: DiGraph<String, u32>,
    pub hash: HashMap<String, NodeIndex>
}


lazy_static! {
    /// The TypeStruct autogenerated at library init, and used by the library.
    pub static ref TYPE: TypeStruct = {
        graph_init().unwrap_or( TypeStruct{graph: DiGraph::new(), hash: HashMap::new()} )
    };
}

// Initialize filetype graph
fn graph_init() -> Result<TypeStruct, std::io::Error> {
    
    let mut graph = DiGraph::<String, u32>::new();
    let mut added_mimes = HashMap::<String, NodeIndex>::new();
    
    // Get list of MIME types
    let mut mimelist = fdo_magic::init::get_supported();
    mimelist.extend(basetype::init::get_supported());
    
    mimelist.sort();
    mimelist.dedup();
    let mimelist = mimelist;
    
    // Create all nodes
    for mimetype in mimelist.iter() {
        let node = graph.add_node(mimetype.clone());
        added_mimes.insert(mimetype.clone(), node);
    }
    
    // Get list of edges from each mod's init submod
    // TODO: Can we iterate over a vector of function/module pointers?
    let mut edge_list_raw = basetype::init::get_subclasses();
    edge_list_raw.extend(fdo_magic::init::get_subclasses());
        
    let mut edge_list = HashSet::<(NodeIndex, NodeIndex)>::with_capacity(edge_list_raw.len());
    for x in edge_list_raw {
        let child_raw = x.0;
        let parent_raw = x.1;
        
        let parent = match added_mimes.get(&parent_raw) {
            Some(node) => *node,
            None => {continue;}
        };
        
        let child = match added_mimes.get(&child_raw) {
            Some(node) => *node,
            None => {continue;}
        };
        
        edge_list.insert( (child, parent) );
    }
    
    graph.extend_with_edges(&edge_list);
    
    //Add to applicaton/octet-stream, all/all, or text/plain, depending on top-level
    //(We'll just do it here because having the graph makes it really nice)
    
    let added_mimes_tmp = added_mimes.clone();
    let node_text = match added_mimes_tmp.get("text/plain"){
        Some(x) => *x,
        None => {
            let node = graph.add_node("text/plain".to_string());
            added_mimes.insert("text/plain".to_string(), node);
            node
        }
    };
    let node_octet = match added_mimes_tmp.get("application/octet-stream"){
        Some(x) => *x,
        None => {
            let node = graph.add_node("application/octet-stream".to_string());
            added_mimes.insert("application/octet-stream".to_string(), node);
            node
        }
    };
    let node_allall = match added_mimes_tmp.get("all/all"){
        Some(x) => *x,
        None => {
            let node = graph.add_node("all/all".to_string());
            added_mimes.insert("all/all".to_string(), node);
            node
        }
    };
    let node_allfiles = match added_mimes_tmp.get("all/allfiles"){
        Some(x) => *x,
        None => {
            let node = graph.add_node("all/allfiles".to_string());
            added_mimes.insert("all/allfiles".to_string(), node);
            node
        }
    };
    
    let mut edge_list_2 = HashSet::<(NodeIndex, NodeIndex)>::new();
    for mimenode in graph.externals(Incoming) {
        
        let ref mimetype = graph[mimenode];
        let toplevel = mimetype.split("/").nth(0).unwrap_or("");
        
        if mimenode == node_text || mimenode == node_octet || 
           mimenode == node_allfiles || mimenode == node_allall 
        {
            continue;
        }
        
        if toplevel == "text" {
            edge_list_2.insert( (node_text, mimenode) );
        } else if toplevel == "inode" {
            edge_list_2.insert( (node_allall, mimenode) );
        } else {
            edge_list_2.insert( (node_octet, mimenode) );
        }
    }
    // Don't add duplicate entries
    graph.extend_with_edges(edge_list_2.difference(&edge_list));
    
    let graph = graph;
    let added_mimes = added_mimes;
    //println!("{:?}", Dot::with_config(&graph, &[Config::EdgeNoLabel]));

    Ok( TypeStruct{graph: graph, hash: added_mimes} )
}

/// Checks if the given bytestream matches the given MIME type.
///
/// Returns true or false if it matches or not. If the given mime type is not known,
/// the function will always return false.
pub fn match_u8(mimetype: &str, bytes: &[u8], len: usize) -> bool
{
    let result: bool;
    
    // Handle base types
    if basetype::test::can_check(&mimetype){
        result = basetype::test::from_u8(bytes, len, &mimetype);
    // Handle via magic
    } else if fdo_magic::test::can_check(&mimetype) {
        result = fdo_magic::test::from_u8(bytes, len, &mimetype);
    // Nothing can handle this. Somehow.
    } else {
        result = false;
    }
    
    result
}


/// Gets the type of a file from a raw bytestream, starting at a certain node
/// in the type graph.
///
/// Returns mime as string wrapped in Some if a type matches, or
/// None if no match is found.
/// Retreive the node from the `TYPE.hash` HashMap, using the MIME as the key.
///
/// ## Panics
/// Will panic if the given node is not found in the graph.
/// As the graph is immutable, this should not happen if the node index comes from
/// TYPE.hash.
pub fn from_u8_node(parentnode: NodeIndex, bytes: &[u8], len: usize) -> Option<String>
{
    
    // Walk the children
    let children = TYPE.graph.neighbors_directed(parentnode, Outgoing);
    for childnode in children {
        let ref mimetype = TYPE.graph[childnode];

        match match_u8(mimetype, bytes, len) {
            true => {
                match from_u8_node(
                    childnode, bytes, len
                ) {
                    Some(foundtype) => return Some(foundtype),
                    None => return Some(mimetype.clone()),
                }
            }
            false => continue,
        }
    }
    
    None
}

/// Gets the type of a file from a byte stream.
///
/// Returns mime as string wrapped in Some if a type matches, or
/// None if no match is found. Because this starts from the type graph root,
/// it is a bug if this returns None.
pub fn from_u8(bytes: &[u8], len: usize) -> Option<String>
{
    let node = match TYPE.graph.externals(Incoming).next() {
        Some(foundnode) => foundnode,
        None => return None
    };
    from_u8_node(node, bytes, len)
}

/// Checks if the given vector of bytes matches the given MIME type.
///
/// Returns true or false if it matches or not. If the given mime type is not known,
/// the function will always return false.
pub fn match_vec_u8(bytes: Vec<u8>, mimetype: &str) -> bool
{
    let len = bytes.len();
    match_u8(mimetype, bytes.as_slice(), len)
}


/// Gets the type of a file from a vector of bytes, starting at a certain node
/// in the type graph.
///
/// Returns mime as string wrapped in Some if a type matches, or
/// None if no match is found.
/// Retreive the node from the `TYPE.hash` HashMap, using the MIME as the key.
///
/// ## Panics
/// Will panic if the given node is not found in the graph.
/// As the graph is immutable, this should not happen if the node index comes from
/// TYPE.hash.
pub fn from_vec_u8_node(parentnode: NodeIndex, bytes: Vec<u8>) -> Option<String>
{
    let len = bytes.len();
    from_u8_node(parentnode, bytes.as_slice(), len)
}

/// Gets the type of a file from a vector of bytes.
///
/// Returns mime as string wrapped in Some if a type matches, or
/// None if no match is found. Because this starts from the type graph root,
/// it is a bug if this returns None.
pub fn from_vec_u8(bytes: Vec<u8>) -> Option<String> {

    let node = match TYPE.graph.externals(Incoming).next() {
        Some(foundnode) => foundnode,
        None => return None
    };
    from_vec_u8_node(node, bytes)
}

/// Check if the given filepath matches the given MIME type.
///
/// Returns true or false if it matches or not, or an Error if the file could
/// not be read. If the given mime type is not known, it will always return false.
pub fn match_filepath(mimetype: &str, filepath: &str) -> Result<bool, std::io::Error> {

    let result: Result<bool, std::io::Error>;
    
    // Handle base types
    if basetype::test::can_check(&mimetype){
        result = basetype::test::from_filepath(filepath, &mimetype);
    // Handle via magic
    } else if fdo_magic::test::can_check(&mimetype) {
        result = fdo_magic::test::from_filepath(filepath, &mimetype);
    // Nothing can handle this. Somehow.
    } else {
        result = Ok(false);
    }
    
    result
}


/// Gets the type of a file from a filepath, starting at a certain node
/// in the type graph.
///
/// Returns mime as string wrapped in Some if a type matches, or
/// None if the file is not found or cannot be opened.
/// Retreive the node from the `TYPE.hash` HashMap, using the MIME as the key.
///
/// ## Panics
/// Will panic if the given node is not found in the graph.
/// As the graph is immutable, this should not happen if the node index comes from
/// TYPE.hash.
pub fn from_filepath_node(parentnode: NodeIndex, filepath: &str) -> Option<String> 
{
    
    // Walk the children
    let children = TYPE.graph.neighbors_directed(parentnode, Outgoing);
    for childnode in children {
    
        let ref mimetype = TYPE.graph[childnode];
        
        match match_filepath(mimetype, filepath) {
            Ok(res) => match res {
                true => {
                    match from_filepath_node(
                        childnode, filepath
                    ) {
                        Some(foundtype) => return Some(foundtype),
                        None => return Some(mimetype.clone()),
                    }
                }
                false => continue,
            },
            //Err(why) => panic!("{:?}", why),
            Err(_) => return None
        }
    }
    
    None
}

/// Gets the type of a file from a filepath.
///
/// Does not look at file name or extension, just the contents.
/// Returns mime as string wrapped in Some if a type matches, or
/// None if the file is not found or cannot be opened.
pub fn from_filepath(filepath: &str) -> Option<String> {

    let node = match TYPE.graph.externals(Incoming).next() {
        Some(foundnode) => foundnode,
        None => return None
    };
    
    from_filepath_node(node, filepath)
}