use crate::items::{Game, Person};
use serde::{Deserialize, Serialize};
use std::fs::File;
use std::io::BufReader;

#[derive(Clone, Serialize, Deserialize)]
pub struct User {
    pub person: Person,
    pub password_hash: String,
}

impl std::ops::Deref for User {
    type Target = Person;

    fn deref(&self) -> &Self::Target {
        &self.person
    }
}

impl std::ops::DerefMut for User {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.person
    }
}

#[derive(Serialize, Deserialize)]
pub struct PersistentState {
    pub games: Vec<Game>,
    pub users: Vec<User>,
}

pub const STATE_FILE: &str = "state.json";

pub fn save_state(games: &[Game], users: &[User]) {
    let mut games = games.to_vec();
    games.sort_unstable_by(|g1, g2| g1.title.cmp(&g2.title));

    let mut users = users.to_vec();
    users.sort_unstable_by(|u1, u2| u1.name.cmp(&u2.name));

    users.iter_mut().for_each(|u| {
        u.opinion.sort_unstable_by(|o1, o2| o1.title.cmp(&o2.title));
    });

    let state = PersistentState { games, users };
    if let Ok(file) = File::create(STATE_FILE) {
        let _ = serde_json::to_writer_pretty(file, &state);
    }
}

pub fn load_state() -> Option<(Vec<Game>, Vec<User>)> {
    if let Ok(file) = File::open(STATE_FILE) {
        let reader = BufReader::new(file);
        if let Ok(state) = serde_json::from_reader::<_, PersistentState>(reader) {
            return Some((state.games, state.users));
        }
    }
    None
}