use serde::{Deserialize, Serialize};
use std::path::PathBuf;
use storaget::*;

#[derive(Serialize, Deserialize, Debug, Default, Clone)]
struct Car {
    pub id: String,
    pub name: String,
    pub hp: u32,
}

impl Car {
    pub fn new(id: String, name: String, hp: u32) -> Self {
        Car { id, name, hp }
    }
}

impl VecPackMember for Car {
    fn get_id(&self) -> &str {
        &self.id
    }
}

#[derive(Serialize, Deserialize, Debug, Default, Clone)]
struct Robot {
    pub id: String,
    pub name: String,
    pub can_speak: bool,
}

impl Robot {
    pub fn new(id: String, name: String, can_speak: bool) -> Self {
        Robot {
            id,
            name,
            can_speak,
        }
    }
}

impl VecPackMember for Robot {
    fn get_id(&self) -> &str {
        &self.id
    }
}

#[test]
fn test_vecpack_load_or_init() {
    let meaning_of_life: PackResult<VecPack<Car>> =
        VecPack::load_or_init(PathBuf::from("data/vecpack_test_load_or_init"));
    assert_eq!(meaning_of_life.is_ok(), true);
    assert_eq!((*meaning_of_life.unwrap()).len(), 0);
}

fn create_dummy_vecpack(path: PathBuf) -> VecPack<Car> {
    let mut meaning_of_life: VecPack<Car> =
        VecPack::load_or_init(path).unwrap();
    meaning_of_life
        .insert(Car::new("1".to_string(), "CarSmall".to_string(), 150))
        .unwrap();
    meaning_of_life
        .insert(Car::new("2".to_string(), "CarBig".to_string(), 650))
        .unwrap();
    meaning_of_life
        .insert(Car::new("3".to_string(), "CarMedium".to_string(), 250))
        .unwrap();
    meaning_of_life
}

#[test]
fn test_vecpack_insert() {
    let mut meaning_of_life: VecPack<Car> =
        VecPack::load_or_init(PathBuf::from("data/vecpack_test_insert"))
            .unwrap();
    meaning_of_life
        .insert(Car::new("1".to_string(), "CarSmall".to_string(), 150))
        .unwrap();
    meaning_of_life
        .insert(Car::new("2".to_string(), "CarBig".to_string(), 650))
        .unwrap();
    meaning_of_life
        .insert(Car::new("3".to_string(), "CarMedium".to_string(), 250))
        .unwrap();

    assert_eq!((*meaning_of_life).len(), 3);
}

#[test]
fn test_vecpack_as_mut() {
    let mut cars =
        create_dummy_vecpack(PathBuf::from("data/vecpack_test_as_mut"));
    cars.into_iter().for_each(|i| i.as_mut().hp = 1);
    assert_eq!(cars.get(0).unwrap().hp, 1);
}

#[test]
fn test_vecpack_find_id() {
    let cars = create_dummy_vecpack(PathBuf::from("data/vecpack_test_find_id"));
    assert_eq!(cars.find_id("3").is_ok(), true);
    assert_eq!(cars.find_id("1").unwrap().unpack().hp, 150);
    assert_eq!(cars.find_id("2").unwrap().unpack().hp, 650);
    assert_eq!(cars.find_id("3").unwrap().unpack().hp, 250);
}

#[test]
fn test_vecpack_find_id_mut_update() {
    let mut cars = create_dummy_vecpack(PathBuf::from(
        "data/vecpack_test_find_id_mut_update",
    ));
    cars.find_id_mut("1").unwrap().update(|i| i.hp = 1).unwrap();
    cars.find_id_mut("2")
        .unwrap()
        .update(|i| i.hp = 11)
        .unwrap();
    cars.find_id_mut("3")
        .unwrap()
        .update(|i| i.hp = 111)
        .unwrap();

    assert_eq!(cars.find_id("1").unwrap().hp, 1);
    assert_eq!(cars.find_id("2").unwrap().hp, 11);
    assert_eq!(cars.find_id("3").unwrap().hp, 111);
}

#[test]
fn test_vecpack_find_id_mut_as_mut() {
    let mut cars = create_dummy_vecpack(PathBuf::from(
        "data/vecpack_test_find_id_mut_as_mut",
    ));
    cars.find_id_mut("1").unwrap().as_mut().hp = 1;
    cars.find_id_mut("2").unwrap().as_mut().hp = 11;
    cars.find_id_mut("3").unwrap().as_mut().hp = 111;
    assert_eq!(cars.find_id_mut("4").is_ok(), false);
    assert_eq!(cars.find_id_mut("100").is_ok(), false);

    assert_eq!(cars.find_id("1").unwrap().hp, 1);
    assert_eq!(cars.find_id("2").unwrap().hp, 11);
    assert_eq!(cars.find_id("3").unwrap().hp, 111);
}

#[test]
fn test_id_str() {
    let mut robots: VecPack<Robot> =
        VecPack::load_or_init(PathBuf::from("data/vecpack_test_id_str"))
            .unwrap();

    robots
        .insert(Robot::new("a".to_string(), "robot_a".to_string(), true))
        .unwrap();
    robots
        .insert(Robot::new("b".to_string(), "robot_b".to_string(), false))
        .unwrap();
    robots
        .insert(Robot::new("c".to_string(), "robot_c".to_string(), false))
        .unwrap();

    assert_eq!(robots.find_id("a").is_ok(), true);
}

#[test]
fn test_mut_ref() {
    let mut robots: VecPack<Robot> =
        VecPack::load_or_init(PathBuf::from("data/vecpack_test_mut_red"))
            .unwrap();
    robots
        .insert(Robot::new(
            "firstone".to_string(),
            "Mini Robot".to_string(),
            true,
        ))
        .unwrap();

    let robots = robots.as_vec_mut();
    robots.get_mut(0).unwrap().as_mut().name = "Mini Roboto".to_string();
    assert_eq!(robots.get(0).unwrap().name, "Mini Roboto");
}