// src/logic.rs

use serde::{Deserialize, Serialize};
use std::fmt;

#[derive(Default, Serialize, Deserialize, PartialEq)]
enum Stav {
    #[default] Nova = 0,
    Pouzivana = 1,
    Poskodena = 2,
    Vyradena = 3,
}

impl fmt::Display for Stav {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Stav::Nova => write!(f, "Nova"),
            Stav::Pouzivana => write!(f, "Pouzivana"),
            Stav::Poskodena => write!(f, "Poskodena"),
            Stav::Vyradena => write!(f, "Vyradena")
        }
    }
}

#[derive(Default, Serialize, Deserialize)]
struct Kniha {
    autori: Vec<String>,
    nazov: String,
    vydavatelstvo: String,
    zaner: String,
    pocet_stran: usize,
    isbn: String,
    rok_vydania: usize,
    je_pozicana: bool,
    stav_knihy: Stav,
}

impl fmt::Display for Kniha {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "(Autori: {},
               Nazov: {},
               Vydavatelstvo: {},
               Zaner: {},
               Pocet stran: {},
               ISBN: {},
               Rok vydania: {},
               Je pozicana {},
               Stav knihy: {})",
               self.autori.join(", "),
               self.nazov,
               self.vydavatelstvo,
               self.zaner,
               self.pocet_stran,
               self.isbn,
               self.rok_vydania,
               self.je_pozicana,
               self.stav_knihy,
        )
    }
}


#[derive(Default, Serialize, Deserialize)]
struct Kniznica {
    knihy: Vec<Kniha>
}

impl Kniznica {
    // Asociovana funkcia
    fn nacitaj_zo_suboru(cesta: &std::path::PathBuf) -> Option<Self>{
        let obsah = match std::fs::read_to_string(cesta) {
            Ok(text) => text,
            Err(_) => return None,
        };
        let kniznica = match serde_json::from_str(obsah.as_str()) {
            Ok(k) => k,
            Err(_) => return None,
        };
        Some(kniznica)
    }
    // Metoda
    fn uloz_do_suboru(&self, cesta: &std::path::PathBuf) -> bool {
        let converted = match serde_json::to_string(&self) {
            Ok(k) => k,
            Err(_) => return false,
        };
        match std::fs::write(cesta, converted) {
            Ok(_) => return true,
            Err(_) => return false,
        };
    }

    fn pridaj_knihu(&mut self, nova_kniha: Kniha) -> Result<(), ()> {
        for x in &self.knihy {
            if x.isbn == nova_kniha.isbn {
                return Err(());
            }
        }
        self.knihy.push(nova_kniha);
        Ok(())
    }

    fn pridaj_knihu2(&mut self, nova_kniha: Kniha) -> Result<(), ()> {
        let moze = self.knihy.iter()
                             .all(|x| x.isbn != nova_kniha.isbn);
        if moze {
            self.knihy.push(nova_kniha);
        } else {
            return Err(());
        }
        Ok(())
    }

    fn odstran_knihu(&mut self, isbn: &str) -> Result<Kniha, ()> {
        if let Some(index) = self.knihy.iter()
            .position(|x| x.isbn == isbn) {
                let kniha = self.knihy.remove(index);
                Ok(kniha)
            } else {
                Err(())
            }

    }

    fn daj_knihu_podla_isbn(&self, isbn: &str) -> Option<&Kniha> {
        if let Some(vrat) = self.knihy.iter().find(|x| x.isbn == isbn) {
            return Some(vrat);
        }
        None
    }

    fn daj_knihy_podla_stavu(&self, stav_knihy: Stav) -> Vec<&Kniha> {
       self.knihy.iter().filter(|x| x.stav_knihy == stav_knihy).collect()
    }

    fn vypis_vydavatelstva_a_pocet_knih(&self) {
        // hashmap obsahuje <K, V> kde K moze byt string a V pocet
        let mut mapa = std::collections::HashMap::new();
        for k in &self.knihy {
            let meno = &k.vydavatelstvo;

            let novy_pocet = match mapa.get(meno) {
                Some(pocet) => pocet + 1,
                None => 1,
            };

            mapa.insert(meno, novy_pocet);

        }
        for (vyd, pocet) in mapa {
            println!("{}: {}", vyd, pocet);
        }
    }

    fn vypis_knihy_daneho_zanru(&self, zaner_st: &str) {
        let k = &self.knihy.iter().filter(|x| x.zaner == zaner_st).collect();
        for x in k {

        }
    }
}