use anyhow::Result;
use include_dir::{include_dir, Dir};
use lazy_static::lazy_static;
use rusqlite::Connection;
use rusqlite_migration::{Migrations, M};

static MIGRATIONS_DIR: Dir = include_dir!("$CARGO_MANIFEST_DIR/migrations");

const DATABASE_FILE: &str = "lifeline.db";

// Define migrations. These are applied atomically.
lazy_static! {
    static ref MIGRATIONS: Migrations<'static> = Migrations::new(
        MIGRATIONS_DIR
            .dirs()
            .map(|dir| {
                dir.files()
                    .find(|f| f.path().ends_with("up.sql"))
                    .map(|up_file| M::up(up_file.contents_utf8().unwrap()))
                    .unwrap()
            })
            .collect()
    );
}

pub fn init_db() -> Result<Connection> {
    let mut conn = Connection::open(DATABASE_FILE)?;

    // Update the database schema, atomically
    MIGRATIONS.to_latest(&mut conn)?;

    // Apply some PRAGMA. These are often better applied outside of migrations, as some needs to be
    // executed for each connection (like `foreign_keys`) or to be executed outside transactions
    // (`journal_mode` is a noop in a transaction).
    conn.pragma_update(None, "journal_mode", "WAL").unwrap();
    conn.pragma_update(None, "foreign_keys", "ON").unwrap();

    Ok(conn)
}

// Test that migrations are working
#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn migrations_test() {
        assert!(MIGRATIONS.validate().is_ok());
    }
}

#[derive(Debug)]
pub struct Person {
    pub id: i32,
    pub name: String,
    pub age: u8,
    pub data: Option<Vec<u8>>,
}

use crate::entity::person::Person;
use anyhow::Result;
use rusqlite::{params, Connection};

pub fn add_person(conn: &Connection, person: &Person) -> Result<()> {
    conn.execute(
        "INSERT INTO person (name, age, data) VALUES (?1, ?2, ?3)",
        params![person.name, person.age, person.data],
    )
    .unwrap();

    Ok(())
}

pub fn get_persons(conn: &Connection) -> Result<Vec<Person>> {
    let mut stmt = conn.prepare("SELECT * FROM person")?;
    let persons = stmt.query_map([], |row| {
        Ok(Person {
            id: row.get(0)?,
            name: row.get(1)?,
            age: row.get(2)?,
            data: row.get(3)?,
        })
    })?;

    let mut ret_persons = Vec::new();
    for p in persons {
        ret_persons.push(p?);
    }
    Ok(ret_persons)
}

mod entity;
mod storage;

use crate::entity::person::Person;
use crate::storage::migration::init_db;
use crate::storage::person::{add_person, get_persons};
use boost_rs::logger;
use boost_rs::logger::log::info;

fn main() {
    // Step 1: Init logger
    logger::init(Some(logger::LogLevel::Trace));

    // Step 2: Init database
    let conn = init_db().unwrap();

    // Use the db
    add_person(
        &conn,
        &Person {
            id: 0,
            name: "John".to_string(),
            age: 18,
            data: Some(Vec::from("test")),
        },
    )
    .unwrap();

    let persons = get_persons(&conn);
    info!("{:?}", persons);
}