use rand::RngExt;
use rusqlite::{Connection, params};
use serde::{Deserialize, Serialize};
use std::sync::{Arc, Mutex};

pub type Db = Arc<Mutex<Connection>>;

#[derive(Serialize, Deserialize)]
pub struct Snippet {
    pub id: i64,
    pub short_id: String,
    pub content: String,
    pub name: String,
}

const ALPHABET: &[u8] = b"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";

fn generate_short_id() -> String {
    let mut rng = rand::rng();
    (0..10)
        .map(|_| ALPHABET[rng.random_range(0..ALPHABET.len())] as char)
        .collect()
}

pub fn init_db() -> Db {
    let conn = Connection::open("sipp.sqlite").expect("Failed to open database");
    conn.execute(
        "CREATE TABLE IF NOT EXISTS snippets (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            short_id TEXT NOT NULL UNIQUE,
            content TEXT NOT NULL,
            name TEXT NOT NULL
        )",
        [],
    )
    .expect("Failed to create table");
    Arc::new(Mutex::new(conn))
}

pub fn create_snippet(db: &Db, name: &str, content: &str) -> Snippet {
    let conn = db.lock().unwrap();
    let short_id = generate_short_id();
    conn.execute(
        "INSERT INTO snippets (short_id, content, name) VALUES (?1, ?2, ?3)",
        params![short_id, content, name],
    )
    .expect("Failed to insert snippet");
    let id = conn.last_insert_rowid();
    Snippet {
        id,
        short_id,
        content: content.to_string(),
        name: name.to_string(),
    }
}

pub fn get_snippet_by_short_id(db: &Db, short_id: &str) -> Option<Snippet> {
    let conn = db.lock().unwrap();
    conn.query_row(
        "SELECT id, short_id, content, name FROM snippets WHERE short_id = ?1",
        params![short_id],
        |row| {
            Ok(Snippet {
                id: row.get(0)?,
                short_id: row.get(1)?,
                content: row.get(2)?,
                name: row.get(3)?,
            })
        },
    )
    .ok()
}

pub fn get_all_snippets(db: &Db) -> Vec<Snippet> {
    let conn = db.lock().unwrap();
    let mut stmt = conn
        .prepare("SELECT id, short_id, content, name FROM snippets ORDER BY id DESC")
        .expect("Failed to prepare statement");
    stmt.query_map([], |row| {
        Ok(Snippet {
            id: row.get(0)?,
            short_id: row.get(1)?,
            content: row.get(2)?,
            name: row.get(3)?,
        })
    })
    .expect("Failed to query snippets")
    .filter_map(|r| r.ok())
    .collect()
}

pub fn delete_snippet_by_short_id(db: &Db, short_id: &str) -> bool {
    let conn = db.lock().unwrap();
    match conn.execute(
        "DELETE FROM snippets WHERE short_id = ?1",
        params![short_id],
    ) {
        Ok(rows_affected) => rows_affected > 0,
        Err(_) => false,
    }
}