use squad_quest::{SquadObject, account::Account, config::Config, map::{Map, Room}, quest::Quest};

static CONFIG_PATH: &str = "./tests/main/config.toml";

#[test]
fn load_quests() {
    let config = Config::load(CONFIG_PATH.into());
    let quests = config.load_quests();

    assert_eq!(quests.len(), 2);
}

#[test]
fn empty_quest_is_default() {
    // First loaded quest should be 0.toml, which is empty
    let config = Config::load(CONFIG_PATH.into());
    let mut quests = config.load_quests();
    quests.sort_by(|a,b| a.id.cmp(&b.id));
    let quest = quests.first().unwrap();
    
    let default = Quest::default();

    assert_eq!(*quest, default);
}

#[test]
fn quest_one() {
    let config = Config::load(CONFIG_PATH.into());
    let quests = config.load_quests();
    let quest = quests.iter().find(|q| q.id == 1).unwrap();
    
    let expected = Quest {
        id: 1,
        difficulty: squad_quest::quest::QuestDifficulty::Easy,
        reward: 100,
        name: "Example easy quest".to_owned(),
        description: "Answer this quest without any attachments or comments".to_owned(),
        answer: "Accept the answer if it has no attachments and an empty comment".to_owned(),
        public: false,
        available_on: None,
        deadline: None
    };

    assert_eq!(*quest, expected);
}

#[test]
fn load_accounts() {
    let config = Config::load(CONFIG_PATH.into());
    let accounts = config.load_accounts();

    assert_eq!(accounts.len(), 2);
}

#[test]
fn empty_account_is_default() {
    let config = Config::load(CONFIG_PATH.into());
    let accounts = config.load_accounts();

    let default = Account::default();

    let account = accounts.iter().find(|a| a.id == default.id).unwrap();

    assert_eq!(*account, default);
}

#[test]
fn account_test() {
    let config = Config::load(CONFIG_PATH.into());

    let expected = Account {
        id: "test".to_string(),
        balance: 150,
        location: 0,
        quests_completed: vec![0],
        rooms_unlocked: Vec::new()
    };

    let accounts = config.load_accounts();
    let account = accounts.iter().find(|a| a.id == expected.id).unwrap();

    assert_eq!(*account, expected);
}

#[test]
fn load_map() {
    let config = Config::load(CONFIG_PATH.into());

    let room0 = Room {
        id: 0,
        children: vec![1, 2],
        value: 0,
        name: "Entrance".to_string(),
        description: Some("Enter the dungeon".to_string()),
    };

    let room1 = Room {
        id: 1,
        children: vec![0, 3],
        value: 100,
        name: "Kitchen hall".to_string(),
        description: None,
    };

    let room2 = Room {
        id: 2,
        children: vec![0],
        value: 250,
        name: "Room".to_string(),
        description: Some("Simple room with no furniture".to_string()),
    };

    let room3 = Room {
        id: 3,
        children: vec![1],
        value: 175,
        name: "Kitchen".to_string(),
        description: Some("Knives are stored here".to_string()),
    };

    let expected = Map {
        room: vec![room0, room1, room2, room3],
    };
    
    let map_path = config.full_map_path();

    let map = Map::load(map_path).unwrap();

    assert_eq!(map.room, expected.room);
}