use std::rc::Rc;
//use std::fs::File;
use std::collections::HashMap;

pub trait ProtoMsg {
    fn deserialize(&self,
                   obj: &serde_json::Map<String, serde_json::Value>,
                   id_key: &mut i64,
                   name_key: &mut String) {}
    fn init1(&self) {}
    fn init2(&self) {}
    fn init3(&self) {}
}

struct MetaClass<T> {
    file_name: String,
    idx: i32,
    prim_key: String,
    sec_key: String,
    dummy: T,
    wrap_list: Vec<Rc<T>>,
    wrap_id_hash: HashMap<i64, Rc<T>>,
    wrap_name_hash: HashMap<String, Rc<T>>
}

impl<T: Clone + ProtoMsg> MetaClass<T> {

    fn deserialize_json(&mut self, idx: i64, obj: &serde_json::Map<String, serde_json::Value>) {
        let msg = Rc::new(self.dummy.clone());
        let id_key = &mut 0;
        let name_key = &mut String::new();
        msg.deserialize(&obj, id_key, name_key);
        self.wrap_list.push(msg.clone());
        if self.prim_key.is_empty() {
            self.wrap_id_hash.insert(idx, msg.clone());
        } else {
            if *id_key != 0 {
                self.wrap_id_hash.insert(*id_key, msg.clone());
            }
        }
        if !name_key.is_empty() {
            self.wrap_name_hash.insert(name_key.to_string(), msg.clone());
        }
    }

}

fn  test1<T>(mgr: &MetaMgr<T>, meta: &MetaClass<T>) {

}

fn  test2<T>(mgr: &MetaMgr<T>) {

}

pub struct MetaMgr<T> {
    meta_classes: Vec<MetaClass::<T>>,
}

impl<T: Clone + ProtoMsg> MetaMgr<T> {

    pub fn new() -> Self {
        return MetaMgr::<T>{
            meta_classes: Vec::new()
        };
    }

    pub fn init(&mut self) {

    }

    pub fn un_init(&mut self) {

    }

    pub fn register_meta(&mut self, file_name: String, idx: i32, prim_key: String, sec_key: String, dummy: T) {
        let meta = MetaClass::<T> {
            file_name: file_name,
            idx: 100,
            prim_key: prim_key,
            sec_key: sec_key,
            dummy: dummy,
            wrap_list: Vec::new(),
            wrap_id_hash: HashMap::new(),
            wrap_name_hash: HashMap::new()
        };
        self.meta_classes.push(meta);
    }

    fn test(&self, meta: &mut MetaClass::<T>) {
    }

    pub fn load(&mut self) {
        /*
        for i in 0..self.meta_classes.len() {
            let meta = &self.meta_classes[i];
            match File::open(&meta.file_name) {
                Ok(f) => {
                    match serde_json::from_reader(f) {
                        Ok(data) => {
                            match (data) {
                                serde_json::Value::Array(arr) =>{
                                    let mut idx = 0;
                                    for item in arr {
                                        if let serde_json::Value::Object(obj) = item {
                                            //meta.deserialize_json(idx, &obj);
                                            idx = idx + 1;
                                        }
                                    }
                                },
                                serde_json::Value::Object(obj) =>{
                                    //meta.deserialize_json(0, &obj);
                                },
                                _ => {

                                }
                            }
                        }
                        Err(e) => {

                        }
                    }
                }
                Err(e) => {

                }
            }
        }*/
    }

    pub fn get_metalist(&mut self, idx: i32) -> Option<&Vec::<Rc::<T>>> {
        if idx >= 0 && idx as usize <= self.meta_classes.len() {
            return Some(&self.meta_classes[idx as usize].wrap_list);
        }
        return None;
    }

    pub fn get_byid(&mut self, idx: i32, id: i64) -> Option<&Rc<T>> {
        return self.internal_get_byid(idx as usize, id);
    }

    pub fn get_byname(&mut self, idx: i32, name: String) -> Option<&Rc<T>> {
        return self.internal_get_byname(idx as usize, name);
    }

    pub fn internal_get_byid(&mut self, idx: usize, id: i64) -> Option<&Rc<T>> {
        if idx < self.meta_classes.len() {
            match self.meta_classes[idx].wrap_id_hash.get(&id) {
                Some(v) => {
                    return Some(v);
                }
                None => {

                }
            }
        }
        return None;
    }

    pub fn internal_get_byname(&mut self, idx: usize, name: String) -> Option<&Rc<T>> {
        if idx < self.meta_classes.len() {
            match self.meta_classes[idx].wrap_name_hash.get(&name) {
                Some(v) => {
                    return Some(v);
                }
                None => {

                }
            }
        }
        return None;
    }

}