use super::MigrationError;
use crate::database::v1;
use crate::database::v2;
use bincode::{deserialize, serialize};
use chrono::{DateTime, Utc};
use sled::Db;

/// Migrate from database version 1 to version 2
pub fn migrate(db: &mut Db) -> Result<(), MigrationError> {
    {
        // Migrate sessions

        // Open old & new trees
        let v1_past_sessions = db.open_tree(v1::trees::past_sessions::NAME)?;
        let v2_sessions = db.open_tree(v2::trees::session::NAME)?;

        // Iterate over old tree
        for r in v1_past_sessions.iter() {
            let (k, v) = r?;

            // Deserialize old value
            let v1::trees::past_sessions::V {
                category,
                started,
                ended,
            } = deserialize(&v)?;

            // Convert to new value
            let v2_value = v2::trees::session::V {
                category,
                started: DateTime::<Utc>::from_naive_utc_and_offset(started, Utc).into(),
                ended: DateTime::<Utc>::from_naive_utc_and_offset(ended, Utc).into(),
                deleted: false,
            };

            // Insert into new tree
            v2_sessions.insert(k, serialize(&v2_value)?)?;
        }

        // Remove old tree
        v1_past_sessions.clear()?;
    }

    {
        // Migrate categories
        // Open the old tree, and a TMP tree since the old tree name hasn't changed
        let categories = db.open_tree(v1::trees::categories::NAME)?;
        let v2_categories_tmp = db.open_tree("TEMP")?;

        // Iterate over old tree
        for r in categories.iter() {
            let (k, v) = r?;

            // Deserialize old value
            let v1::trees::categories::V {
                name,
                color,
                started,
            } = deserialize(&v)?;

            // Convert to new value
            let v2_value = v2::trees::category::V {
                name,
                description: None,
                color,
                started: started
                    .map(|ndt| DateTime::<Utc>::from_naive_utc_and_offset(ndt, Utc).into()),
                parent: None,
                deleted: false,
            };

            // Insert into temporary tree
            v2_categories_tmp.insert(k, serialize(&v2_value)?)?;
        }

        // Copy data from temp-tree back into old tree
        categories.clear()?;
        for r in v2_categories_tmp.iter() {
            let (k, v) = r?;
            categories.insert(k, v)?;
        }
        v2_categories_tmp.clear()?;
    }

    Ok(())
}