jap_learn/src/data_provider/card_stats.rs

use crate::lang::{CardStatistics, DeckSettings, INVALID_ID};
use rusqlite::Connection;
use std::time::Instant;

pub fn load_stats_of_deck(set: &DeckSettings, connection: &Connection) -> Vec<CardStatistics> {
    let mut stmt = connection
        .prepare("SELECT id, word_id, score, last_opened FROM card_stats WHERE set_id = ?1")
        .unwrap();
    let iter = stmt
        .query_map((set.id,), |row| {
            Ok(CardStatistics {
                id: row.get(0)?,
                word_id: row.get(1)?,
                set_id: set.id,
                score: row.get(2)?,
                last_open: row.get(3)?,
            })
        })
        .unwrap();

    let mut buffer = vec![];
    for word in iter {
        buffer.push(word.unwrap());
    }

    buffer
}

pub fn add_stat_list(stat: &mut [CardStatistics], connection: &Connection) {
    let time = Instant::now();
    let inserting = stat
        .iter()
        .map(|stat| {
            format!(
                "({}, {}, {}, {})",
                stat.word_id,
                stat.set_id,
                stat.score,
                stat.last_open.timestamp()
            )
        })
        .collect::<Vec<_>>()
        .join(", ");
    let query = format!(
        "INSERT INTO card_stats (word_id, set_id, score, last_opened) VALUES {}",
        inserting
    );
    let count = connection.execute(query.as_str(), ());

    if count.is_err() {
        return;
    }

    let last_index: u32 = connection
        .query_one(
            "SELECT seq from sqlite_sequence WHERE name == ?1",
            ("card_stats".to_string(),),
            |row| row.get(0),
        )
        .unwrap();

    let start_index = last_index - (stat.len() as u32) + 1;

    for (index, id) in (start_index..=last_index).enumerate() {
        stat[index].id = id.into();
    }

    println!("Added {} cards for {:?}", stat.len(), time.elapsed());
}

// pub fn add_stat(stat: &mut CardStatistics, connection: &Connection) {
//     let time = Instant::now();
//     let index = connection
//         .query_row(
//             "INSERT INTO card_stats (word_id, set_id, score, last_opened) VALUES (?1, ?2, ?3, ?4) RETURNING id",
//             (
//                 &stat.word_id,
//                 &stat.set_id,
//                 &stat.score,
//                 &stat.last_open.timestamp(),
//             ),
//             |row| row.get(0)
//         )
//         .unwrap_or_else(|e| {println!("{}", e); 0});
//
//     stat.id = index;
//     println!("Added stat: {}", time.elapsed().as_millis());
// }

pub fn update_stat_score(stat: &CardStatistics, connection: &Connection) {
    let time = Instant::now();

    connection
        .execute(
            "UPDATE card_stats SET score = ?1, last_opened = ?2 WHERE id = ?3",
            (&stat.score, &stat.last_open.timestamp(), &stat.id),
        )
        .unwrap_or_else(|e| {
            println!("{}", e);
            0
        });
    println!("Updated stat: {}", time.elapsed().as_millis());
}

pub fn delete_stat(stat: &CardStatistics, connection: &Connection) {
    if !stat.id.is_valid() {
        return;
    }
    connection
        .execute("DELETE FROM card_stats WHERE id = ?1", (&stat.id,))
        .unwrap_or_else(|e| {
            println!("{}", e);
            0
        });
}