//! Keyring migration support for legacy formats

use std::path::PathBuf;

use oo7::{Secret, file::UnlockedKeyring};

use crate::error::Error;

/// Pending keyring migration

#[derive(Clone)]

pub enum PendingMigration {

    /// Legacy v0 keyring format

    V0 {

        name: String,

        path: PathBuf,

        label: String,

        alias: String,

    },

    /// KWallet keyring format

    #[cfg(feature = "kwallet_migration")]

    KWallet {

        name: String,

        path: PathBuf,

        label: String,

        alias: String,

    },

}

impl PendingMigration {

    /// Attempt to migrate this keyring with the provided secret

        &self,

        data_dir: &PathBuf,

        secret: &Secret,

    ) -> Result<UnlockedKeyring, Error> {

        match self {

                // Write migrated keyring

                // Cleanup old file

                } else {

                }

            }

            #[cfg(feature = "kwallet_migration")]

            Self::KWallet { path, name, .. } => {

                tracing::debug!("Migrating KWallet keyring: {}", name);

                // Parse KWallet file in blocking task

                let path_clone = path.clone();

                let password = secret.to_vec();

                let wallet = tokio::task::spawn_blocking(move || {

                    kwallet_parser::KWalletFile::open(&path_clone, &password)

                })

                .await

                .map_err(|e| {

                    Error::IO(std::io::Error::other(format!("Task join error: {}", e)))

                })??;

                tracing::info!("Parsed KWallet file '{}'", name);

                // Create new oo7 keyring

                let unlocked = UnlockedKeyring::open_at(data_dir, name, secret.clone()).await?;

                // Convert KWallet entries to oo7 items

                let mut items = Vec::new();

                for (folder_name, folder) in wallet.wallet() {

                    for (entry_key, entry) in folder {

                        match kwallet_parser::convert_entry(folder_name, entry_key, entry) {

                            Ok(ss_entry) => {

                                items.push((

                                    ss_entry.label().to_owned(),

                                    ss_entry.attributes().to_owned(),

                                    Secret::blob(ss_entry.secret()),

                                    true,

                                ));

                            }

                            Err(e) => {

                                tracing::warn!(

                                    "Skipping entry {}/{}: {}",

                                    folder_name,

                                    entry_key,

                                    e

                                );

                            }

                        }

                    }

                }

                unlocked.create_items(items).await?;

                tracing::info!("Migrated KWallet entries to oo7 format for '{}'", name);

                // Cleanup old files

                if let Err(e) = tokio::fs::remove_file(path).await {

                    tracing::warn!("Failed to remove KWallet file at {:?}: {}", path, e);

                } else {

                    tracing::info!("Removed KWallet file at {:?}", path);

                }

                // Try to remove salt file if it exists

                let salt_path = path.with_extension("salt");

                if salt_path.exists() {

                    if let Err(e) = tokio::fs::remove_file(&salt_path).await {

                        tracing::warn!(

                            "Failed to remove KWallet salt file at {:?}: {}",

                            salt_path,

                            e

                        );

                    } else {

                        tracing::info!("Removed KWallet salt file at {:?}", salt_path);

                    }

                }

                tracing::info!("Successfully migrated KWallet keyring '{}'", name);

                Ok(unlocked)

            }

        }

    }

        match self {

            #[cfg(feature = "kwallet_migration")]

            Self::KWallet { name, .. } => name,

        }

    }

        match self {

            #[cfg(feature = "kwallet_migration")]

            Self::KWallet { label, .. } => label,

        }

    }

        match self {

            #[cfg(feature = "kwallet_migration")]

            Self::KWallet { alias, .. } => alias,

        }

    }

        match self {

            #[cfg(feature = "kwallet_migration")]

            Self::KWallet { path, .. } => path,

        }

    }

}