//! Support package for phreak_engine.
//!
//! The phreak_facts module is used to separate the fact generation logic from the phreak_engine.
//!
#[macro_use]
extern crate serde;

use std::borrow::Borrow;
use std::cmp::Ordering;
use std::collections::BTreeMap;
use std::collections::hash_map::DefaultHasher;
use std::fmt::Debug;
use std::hash::{Hash, Hasher};
use std::rc::Rc;

use generational_arena::{Arena, Index as Handle};
use serde::export::fmt::Error;
use serde::export::Formatter;

pub use data::Value;

mod data;

/// A FactAttribute consists of three values
///
/// The normal usage would be:
///  attribute.0 identifies the object
///  attribute.1 identifies the type of the attribute
///  attribute.2 identifies the value
#[derive(Serialize, Deserialize, PartialEq, Eq)]
pub struct FactAttribute(pub Value, pub Value, pub Value);

// impl PartialEq for FactAttribute {
//     fn eq(&self, other: &Self) -> bool {
//         self.0 == other.0 && self.1 == other.1 && self.2 == other.2
//     }
// }

//impl Eq for FactAttribute {}

impl Hash for FactAttribute {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.0.hash(state);
        self.1.hash(state);
        self.2.hash(state);
    }
}

impl PartialOrd for FactAttribute {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        let mut r = self.0.partial_cmp(&other.0);
        if r == Some(Ordering::Equal) {
            r = self.1.partial_cmp(&other.1);
        }
        if r == Some(Ordering::Equal) {
            r = self.2.partial_cmp(&other.2);
        }
        r
    }
}

impl Ord for FactAttribute {
    fn cmp(&self, other: &Self) -> Ordering {
        let mut r = self.0.cmp(&other.0);
        if Ordering::Equal == r {
            r = self.1.cmp(&other.1);
        }
        if Ordering::Equal == r {
            r = self.2.cmp(&other.2);
        }
        r
    }
}

impl Debug for FactAttribute {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
        write!(f, "<{}, {}, {}>", &self.0, &self.1, &self.2)
    }
}

/// FactObject contains grouped information around a single object.
///
/// Example: A Car can have multiple pieces of information associated:
///  The color is red.
///  It has 4 wheels, and 3 doors.
///  The brand is Ferrari
///
/// This information is stored in a standardized way for the phreak algorithm, in order to
/// efficiently match conditions against the known facts.
#[derive(Serialize, Deserialize)]
pub struct FactObject {
    // note: for now we store this using multiple allocations, but ideally this would be
    // a single allocation of continues memory
    class: String,
    attrs: Vec<Rc<FactAttribute>>,
}

impl FactObject {
    pub fn get_name(&self) -> &String {
        &self.class
    }

    pub fn iter_attrs(&self) -> std::slice::Iter<'_, Rc<FactAttribute>> {
        self.attrs.iter()
    }
}

impl Debug for FactObject {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
        let v: Vec<(&Value, &Value, &Value)> = self.attrs.iter().map(|rc| {
            let b: &FactAttribute = rc.borrow();
            (&b.0, &b.1, &b.2)
        }).collect();
        write!(f, "Facts{{ class='{}', attrs={:?} }}", self.class, v)
    }
}

impl Clone for FactObject {
    fn clone(&self) -> Self {
        FactObject { class: self.class.to_owned(), attrs: self.attrs.clone() }
    }
}

impl Hash for FactObject {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.class.hash(state);
        for attr in self.attrs.iter() {
            let b: &FactAttribute = attr.borrow();
            b.0.hash(state);
            b.1.hash(state);
            b.2.hash(state);
        }
    }
}

impl PartialEq for FactObject {
    fn eq(&self, other: &Self) -> bool {
        let mut b = self.class == other.class && self.attrs.len() == other.attrs.len();
        let mut i = 0;
        while b && i < self.attrs.len() {
            let left: &FactAttribute = self.attrs[i].borrow();
            let right: &FactAttribute = other.attrs[i].borrow();
            b = left.0 == right.0 && left.1 == right.1 && left.2 == right.2;
            i = i + 1;
        }
        b
    }
}

/// To facilitate the creation of facts, we offer a builder pattern.
///
/// To simplify the conversion from an object into a facts structure, we offer this
/// builder pattern.
///
/// ```
/// # use phreak_facts::FactsBuilder;
/// let facts = FactsBuilder::new("Car".to_owned())
///     .add_attributes("123".to_string(), "color".to_string(), "red".to_string())
///     .add_attributes("123".to_string(), "type".to_string(), "hatchback".to_string())
///     .add_attributes("123".to_string(), "brand".to_string(), "Toyota".to_string())
///     .build()
/// ;
///
/// ```
pub struct FactsBuilder {
    f: Option<FactObject>,
}

impl FactsBuilder {
    /// Start building a new Facts object with the given class name
    pub fn new(name: String) -> Self {
        FactsBuilder { f: Some(FactObject { class: name, attrs: vec!() }) }
    }

    /// Add one triple of information
    ///
    /// Triples can be of the format ( instance-id, attribute, value )
    pub fn add_attributes(mut self, field1: String, field2: String, field3: String) -> Self {
        match &mut self.f {
            None => panic!("Set classname first"),
            Some(facts) => {
                facts.attrs.push(Rc::new(FactAttribute(
                    Value::from(field1),
                    Value::from(field2),
                    Value::from(field3))
                ));
            }
        }
        self
    }

    /// Add one triple of information
    ///
    /// Triples can be of the format ( instance-id, attribute, value )
    pub fn add_attributes_from_slice(mut self, field1: &str, field2: &str, field3: &str) -> Self {
        match &mut self.f {
            None => panic!("Set classname first"),
            Some(facts) => {
                let f = FactAttribute(
                    Value::from(field1),
                    Value::from(field2),
                    Value::from(field3),
                );
                facts.attrs.push(Rc::new(f));
            }
        }
        self
    }

    pub fn add_values(mut self, field1: Value, field2: Value, field3: Value) -> Self {
        match &mut self.f {
            None => panic!("Set classname first"),
            Some(facts) => {
                facts.attrs.push(Rc::new(FactAttribute(field1, field2, field3)));
            }
        }
        self
    }

    /// Finalize the facts object and return it
    pub fn build(self) -> FactObject {
        self.f.unwrap()
    }
}

/// Long-time storage of facts
pub struct Store {
    arena: Arena<FactObject>,
    handles: BTreeMap<u64, Vec<Handle>>,
}

impl Store {
    /// Create a new Store
    pub fn new() -> Self {
        Store { arena: Arena::new(), handles: BTreeMap::new() }
    }

    /// Add a single Facts object to the store, and return a Handle to it
    pub fn add_facts(&mut self, facts: FactObject) -> Handle {
        let mut s = DefaultHasher::new();
        facts.hash(&mut s);
        let hash = s.finish();

        let handle = self.arena.insert(facts);

        match &mut self.handles.get_mut(&hash) {
            None => {
                let mut v = Vec::with_capacity(1);
                v.push(handle);
                self.handles.insert(hash, v);
            }
            Some(v) => {
                v.push(handle);
            }
        }
        handle
    }

    /// Remove a Facts object by its handle
    pub fn remove_facts(&mut self, handle: Handle) -> Option<FactObject> {
        let facts = self.arena.remove(handle);
        match &facts {
            None => {}
            Some(f) => {
                let mut s = DefaultHasher::new();
                f.hash(&mut s);
                let hash = s.finish();
                match self.handles.get_mut(&hash) {
                    None => { panic!("Handle not found in Arena: {:?}", handle) }
                    Some(v) => {
                        let i = v.iter().enumerate().find(|h| h.1 == &handle).expect("Handle not found in bucket").0;
                        if v.len() == 1 {
                            v.pop();
                        } else {
                            if i == v.len() - 1 {
                                v.remove(i);
                            } else {
                                v.swap_remove(i);
                            }
                        }
                    }
                }
                self.handles.remove(&hash);
            }
        }
        facts
    }

    /// get the handle to a facts object
    pub fn find_facts(&self, facts: &FactObject) -> Option<Handle> {
        let mut s = DefaultHasher::new();
        facts.hash(&mut s);
        let hash = s.finish();

        // get the handle for the given facts object from the bucket
        self.handles.get(&hash).and_then(|bucket| { // get the bucket
            bucket.iter().find(|index| { // find the entry
                self.arena[**index] == *facts
            }).and_then(|handle| { // return the handle
                Some(handle.clone())
            })
        })
    }
}


#[cfg(test)]
mod tests {
    use test_case::test_case;

    use super::*;

    #[test_case("1", "2", "3")]
    fn test_facts_store(f1: &str, f2: &str, f3: &str) {
        let fact = FactsBuilder::new("class1".to_owned())
            .add_attributes_from_slice(f1, f2, f3)
            .build();

        let mut s = Store::new();
        let index = s.add_facts(fact);

        let fact = FactsBuilder::new("class1".to_owned())
            .add_attributes_from_slice(f1, f2, f3)
            .build();
        assert_eq!(s.find_facts(&fact), Some(index));

        s.remove_facts(index);
        assert_eq!(s.find_facts(&fact), None);
    }
}