use std::collections::HashMap;
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct Player {
    pub username: String,
}

#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct Team {
    pub name: String,
    pub color: String,
    pub players: Vec<Player>,
    pub scores: HashMap<String, i32>,
}

impl Team {
    pub fn add_scores(&mut self, scores: &HashMap<String, i32>) {
        for (territory, score) in scores {
            self.scores
                .entry(territory.to_string())
                .and_modify(|s| *s += score)
                .or_insert(*score);
        }
    }
}

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

    #[test]
    fn test_player_score_new() {
        let player = Player {
            username: "testuser".to_string(),
            team: "TestTeam".to_string(),
        };

        let player_score = PlayerScore::new(player.clone());

        assert_eq!(player_score.player.username, "testuser");
        assert_eq!(player_score.player.team, "TestTeam");
        assert_eq!(player_score.total_score, 0);
        assert!(player_score.territory_scores.is_empty());
    }

    #[test]
    fn test_player_score_add_territory_score() {
        let player = Player {
            username: "testuser".to_string(),
            team: "TestTeam".to_string(),
        };

        let mut player_score = PlayerScore::new(player);

        player_score.add_territory_score("Capitol Hill".to_string(), 10);
        assert_eq!(player_score.total_score, 10);
        assert_eq!(player_score.territory_scores.get("Capitol Hill"), Some(&10));

        player_score.add_territory_score("Downtown".to_string(), 5);
        assert_eq!(player_score.total_score, 15);
        assert_eq!(player_score.territory_scores.get("Downtown"), Some(&5));

        // Add more points to existing territory
        player_score.add_territory_score("Capitol Hill".to_string(), 3);
        assert_eq!(player_score.total_score, 18);
        assert_eq!(player_score.territory_scores.get("Capitol Hill"), Some(&13));
    }

    #[test]
    fn test_team_score_new() {
        let team_score = TeamScore::new("Red Team".to_string());

        assert_eq!(team_score.team, "Red Team");
        assert_eq!(team_score.total_score, 0);
        assert!(team_score.territory_scores.is_empty());
    }

    #[test]
    fn test_team_score_add_territory_score() {
        let mut team_score = TeamScore::new("Blue Team".to_string());

        team_score.add_territory_score("Capitol Hill".to_string(), 20);
        assert_eq!(team_score.total_score, 20);
        assert_eq!(team_score.territory_scores.get("Capitol Hill"), Some(&20));

        team_score.add_territory_score("Downtown".to_string(), 15);
        assert_eq!(team_score.total_score, 35);
        assert_eq!(team_score.territory_scores.get("Downtown"), Some(&15));

        // Add more points to existing territory
        team_score.add_territory_score("Capitol Hill".to_string(), 10);
        assert_eq!(team_score.total_score, 45);
        assert_eq!(team_score.territory_scores.get("Capitol Hill"), Some(&30));
    }

    #[test]
    fn test_multiple_territories() {
        let player = Player {
            username: "mapper".to_string(),
            team: "Green Team".to_string(),
        };

        let mut player_score = PlayerScore::new(player);

        let territories = vec![
            ("Capitol Hill", 5),
            ("Downtown", 10),
            ("Fremont", 3),
            ("Ballard", 7),
        ];

        for (territory, score) in territories {
            player_score.add_territory_score(territory.to_string(), score);
        }

        assert_eq!(player_score.total_score, 25);
        assert_eq!(player_score.territory_scores.len(), 4);
    }
}