mongosh 0.9.0

//! Admin executor for administrative commands
//!
//! This module provides the AdminExecutor which handles MongoDB administrative operations:
//! - Database management: show databases, use database
//! - Collection management: show collections
//! - Server commands and diagnostics

use futures::stream::TryStreamExt;
use mongodb::bson::{self, Document};
use tracing::info;

use crate::error::{ExecutionError, MongoshError, Result};
use crate::parser::AdminCommand;

use super::confirmation::confirm_admin_operation;
use super::context::ExecutionContext;
use super::result::{ExecutionResult, ExecutionStats, ResultData};

/// Executor for administrative commands
pub struct AdminExecutor {
    /// Execution context
    context: ExecutionContext,
}

impl AdminExecutor {
    /// Create a new admin executor
    ///
    /// # Arguments
    /// * `context` - Execution context
    ///
    /// # Returns
    /// * `Result<Self>` - New executor or error
    pub async fn new(context: ExecutionContext) -> Result<Self> {
        Ok(Self { context })
    }

    /// Execute an administrative command
    ///
    /// # Arguments
    /// * `cmd` - Admin command to execute
    ///
    /// # Returns
    /// * `Result<ExecutionResult>` - Execution result or error
    pub async fn execute(&self, cmd: AdminCommand) -> Result<ExecutionResult> {
        // Check if operation requires confirmation
        if !confirm_admin_operation(&cmd)? {
            return Ok(ExecutionResult {
                success: true,
                data: ResultData::Message("Operation cancelled by user".to_string()),
                stats: ExecutionStats::default(),
                error: None,
            });
        }

        match cmd {
            AdminCommand::ShowDatabases => self.show_databases().await,
            AdminCommand::ShowCollections => self.show_collections().await,
            AdminCommand::UseDatabase(name) => self.use_database(name).await,
            AdminCommand::ListIndexes(collection) => self.list_indexes(collection).await,
            AdminCommand::CreateIndex {
                collection,
                keys,
                options,
            } => self.create_index(collection, keys, options).await,
            AdminCommand::CreateIndexes {
                collection,
                indexes,
            } => self.create_indexes(collection, indexes).await,
            AdminCommand::DropIndex { collection, index } => {
                self.drop_index(collection, index).await
            }
            AdminCommand::DropIndexes {
                collection,
                indexes,
            } => self.drop_indexes(collection, indexes).await,
            AdminCommand::DropCollection(collection) => self.drop_collection(collection).await,
            AdminCommand::RenameCollection {
                collection,
                target,
                drop_target,
            } => self.rename_collection(collection, target, drop_target).await,
            AdminCommand::CollectionStats { collection, scale } => {
                self.collection_stats(collection, scale).await
            }
            _ => Err(MongoshError::NotImplemented(
                "Admin command not yet implemented".to_string(),
            )),
        }
    }

    /// Show all databases
    ///
    /// # Returns
    /// * `Result<ExecutionResult>` - List of database names
    async fn show_databases(&self) -> Result<ExecutionResult> {
        info!("Listing databases");

        let client = self.context.get_client().await?;

        let db_names = client
            .list_database_names()
            .await
            .map_err(|e| ExecutionError::QueryFailed(e.to_string()))?;

        info!("Found {} databases", db_names.len());

        Ok(ExecutionResult {
            success: true,
            data: ResultData::List(db_names),
            stats: ExecutionStats {
                execution_time_ms: 0,
                documents_returned: 0,
                documents_affected: None,
            },
            error: None,
        })
    }

    /// Show collections in current database
    ///
    /// # Returns
    /// * `Result<ExecutionResult>` - List of collection names
    async fn show_collections(&self) -> Result<ExecutionResult> {
        let db_name = self.context.get_current_database().await;
        info!("Listing collections in database '{}'", db_name);

        let db = self.context.get_database().await?;

        let collection_names = db
            .list_collection_names()
            .await
            .map_err(|e| ExecutionError::QueryFailed(e.to_string()))?;

        info!("Found {} collections", collection_names.len());

        Ok(ExecutionResult {
            success: true,
            data: ResultData::List(collection_names),
            stats: ExecutionStats {
                execution_time_ms: 0,
                documents_returned: 0,
                documents_affected: None,
            },
            error: None,
        })
    }

    /// Switch to a different database
    ///
    /// # Arguments
    /// * `name` - Database name
    ///
    /// # Returns
    /// * `Result<ExecutionResult>` - Success message
    async fn use_database(&self, name: String) -> Result<ExecutionResult> {
        info!("Switching to database '{}'", name);

        self.context.set_current_database(name.clone()).await;

        Ok(ExecutionResult {
            success: true,
            data: ResultData::Message(format!("switched to db {}", name)),
            stats: ExecutionStats::default(),
            error: None,
        })
    }

    /// List indexes on a collection
    ///
    /// # Arguments
    /// * `collection` - Collection name
    ///
    /// # Returns
    /// * `Result<ExecutionResult>` - List of indexes
    async fn list_indexes(&self, collection: String) -> Result<ExecutionResult> {
        let db_name = self.context.get_current_database().await;
        info!(
            "Listing indexes for collection '{}' in database '{}'",
            collection, db_name
        );

        let db = self.context.get_database().await?;
        let coll: mongodb::Collection<Document> = db.collection(&collection);

        // Get cursor for indexes
        let mut cursor = coll
            .list_indexes()
            .await
            .map_err(|e| ExecutionError::QueryFailed(e.to_string()))?;

        // Collect all indexes into a vector
        let mut indexes = Vec::new();
        while let Some(index) = cursor
            .try_next()
            .await
            .map_err(|e| ExecutionError::QueryFailed(e.to_string()))?
        {
            // Convert IndexModel to Document
            let index_doc = bson::to_document(&index).map_err(|e| {
                ExecutionError::QueryFailed(format!("Failed to convert index to document: {}", e))
            })?;
            indexes.push(index_doc);
        }

        let count = indexes.len();
        info!("Found {} indexes", count);

        Ok(ExecutionResult {
            success: true,
            data: ResultData::Documents(indexes),
            stats: ExecutionStats {
                execution_time_ms: 0,
                documents_returned: count,
                documents_affected: None,
            },
            error: None,
        })
    }

    /// Parse index options from a document
    ///
    /// # Arguments
    /// * `options_doc` - Options document to parse
    ///
    /// # Returns
    /// * `Result<Option<mongodb::options::IndexOptions>>` - Parsed options or error
    fn parse_index_options(
        options_doc: Option<Document>,
    ) -> Result<Option<mongodb::options::IndexOptions>> {
        match options_doc {
            Some(opts) => {
                let index_opts = bson::from_document(opts).map_err(|e| {
                    ExecutionError::InvalidParameters(format!("Invalid index options: {}", e))
                })?;
                Ok(Some(index_opts))
            }
            None => Ok(None),
        }
    }

    /// Create an index on a collection
    ///
    /// # Arguments
    /// * `collection` - Collection name
    /// * `keys` - Index keys document
    /// * `options` - Optional index options
    ///
    /// # Returns
    /// * `Result<ExecutionResult>` - Index creation result
    async fn create_index(
        &self,
        collection: String,
        keys: Document,
        options: Option<Document>,
    ) -> Result<ExecutionResult> {
        use tracing::debug;

        debug!(
            "Creating index on collection '{}' with keys: {:?}",
            collection, keys
        );

        let db = self.context.get_database().await?;
        let coll: mongodb::Collection<Document> = db.collection(&collection);

        // Parse and validate index options
        let index_options = Self::parse_index_options(options)?;

        // Create index model
        let index_model = mongodb::IndexModel::builder()
            .keys(keys)
            .options(index_options)
            .build();

        // Create the index
        let result = coll
            .create_index(index_model)
            .await
            .map_err(|e| ExecutionError::QueryFailed(e.to_string()))?;

        debug!("Created index with name: {}", result.index_name);

        Ok(ExecutionResult {
            success: true,
            data: ResultData::Message(format!("Created index: {}", result.index_name)),
            stats: ExecutionStats::default(),
            error: None,
        })
    }

    /// Create multiple indexes on a collection
    ///
    /// # Arguments
    /// * `collection` - Collection name
    /// * `indexes` - Vector of index specifications
    ///
    /// # Returns
    /// * `Result<ExecutionResult>` - Index creation result
    async fn create_indexes(
        &self,
        collection: String,
        indexes: Vec<Document>,
    ) -> Result<ExecutionResult> {
        use tracing::debug;

        debug!(
            "Creating {} indexes on collection '{}'",
            indexes.len(),
            collection
        );

        let db = self.context.get_database().await?;
        let coll: mongodb::Collection<Document> = db.collection(&collection);

        // Create index models from documents
        let mut index_models = Vec::new();
        for (idx, index_doc) in indexes.into_iter().enumerate() {
            // Extract keys - MongoDB requires "key" field (not "keys")
            // Spec format: { key: { name: 1 }, name: "idx_name", unique: true, ... }
            let keys = index_doc
                .get_document("key")
                .or_else(|_| index_doc.get_document("keys"))
                .map_err(|_| {
                    ExecutionError::InvalidParameters(format!(
                        "Index specification at position {} must contain 'key' or 'keys' field",
                        idx
                    ))
                })?
                .clone();

            // Extract options - separate from keys
            let options_doc = if let Ok(opts_doc) = index_doc.get_document("options") {
                // Explicit options field
                Some(opts_doc.clone())
            } else {
                // Extract root-level option fields
                let mut opts = Document::new();
                let option_fields = [
                    "name",
                    "unique",
                    "background",
                    "sparse",
                    "expireAfterSeconds",
                    "partialFilterExpression",
                    "collation",
                    "weights",
                    "default_language",
                    "language_override",
                    "textIndexVersion",
                    "2dsphereIndexVersion",
                    "bits",
                    "min",
                    "max",
                    "bucketSize",
                    "storageEngine",
                    "wildcardProjection",
                    "hidden",
                ];

                for field in &option_fields {
                    if let Some(value) = index_doc.get(*field) {
                        opts.insert(*field, value.clone());
                    }
                }

                if !opts.is_empty() { Some(opts) } else { None }
            };

            // Parse options with proper error handling
            let index_options = Self::parse_index_options(options_doc).map_err(|e| {
                ExecutionError::InvalidParameters(format!(
                    "Invalid options for index at position {}: {}",
                    idx, e
                ))
            })?;

            let index_model = mongodb::IndexModel::builder()
                .keys(keys)
                .options(index_options)
                .build();

            index_models.push(index_model);
        }

        // Create the indexes
        let result = coll
            .create_indexes(index_models)
            .await
            .map_err(|e| ExecutionError::QueryFailed(e.to_string()))?;

        let index_names = result.index_names.join(", ");
        debug!(
            "Created {} indexes: {}",
            result.index_names.len(),
            index_names
        );

        Ok(ExecutionResult {
            success: true,
            data: ResultData::Message(format!("Created indexes: {}", index_names)),
            stats: ExecutionStats::default(),
            error: None,
        })
    }

    /// Drop a single index from a collection
    ///
    /// # Arguments
    /// * `collection` - Collection name
    /// * `index` - Index name to drop
    ///
    /// # Returns
    /// * `Result<ExecutionResult>` - Index drop result
    async fn drop_index(&self, collection: String, index: String) -> Result<ExecutionResult> {
        use tracing::debug;

        debug!(
            "Dropping index '{}' from collection '{}'",
            index, collection
        );

        let db = self.context.get_database().await?;
        let coll: mongodb::Collection<Document> = db.collection(&collection);

        // Drop the index
        coll.drop_index(index.clone())
            .await
            .map_err(|e| ExecutionError::QueryFailed(e.to_string()))?;

        debug!("Dropped index '{}'", index);

        Ok(ExecutionResult {
            success: true,
            data: ResultData::Message(format!("Dropped index: {}", index)),
            stats: ExecutionStats::default(),
            error: None,
        })
    }

    /// Drop multiple indexes from a collection
    ///
    /// # Arguments
    /// * `collection` - Collection name
    /// * `indexes` - Optional list of index names to drop (None = drop all)
    ///
    /// # Returns
    /// * `Result<ExecutionResult>` - Index drop result
    async fn drop_indexes(
        &self,
        collection: String,
        indexes: Option<Vec<String>>,
    ) -> Result<ExecutionResult> {
        use tracing::debug;

        let db = self.context.get_database().await?;
        let coll: mongodb::Collection<Document> = db.collection(&collection);

        match indexes {
            None => {
                // Drop all indexes except _id_
                debug!("Dropping all indexes from collection '{}'", collection);

                coll.drop_indexes()
                    .await
                    .map_err(|e| ExecutionError::QueryFailed(e.to_string()))?;

                debug!("Dropped all indexes from collection '{}'", collection);

                Ok(ExecutionResult {
                    success: true,
                    data: ResultData::Message(format!(
                        "Dropped all indexes from collection '{}'",
                        collection
                    )),
                    stats: ExecutionStats::default(),
                    error: None,
                })
            }
            Some(index_names) => {
                // Drop specific indexes
                debug!(
                    "Dropping {} indexes from collection '{}'",
                    index_names.len(),
                    collection
                );

                for index_name in &index_names {
                    coll.drop_index(index_name.clone())
                        .await
                        .map_err(|e| ExecutionError::QueryFailed(e.to_string()))?;
                }

                let names = index_names.join(", ");
                debug!("Dropped indexes: {}", names);

                Ok(ExecutionResult {
                    success: true,
                    data: ResultData::Message(format!("Dropped indexes: {}", names)),
                    stats: ExecutionStats::default(),
                    error: None,
                })
            }
        }
    }

    /// Drop a collection
    ///
    /// # Arguments
    /// * `collection` - Collection name to drop
    ///
    /// # Returns
    /// * `Result<ExecutionResult>` - Collection drop result
    async fn drop_collection(&self, collection: String) -> Result<ExecutionResult> {
        use tracing::debug;

        debug!("Dropping collection '{}'", collection);

        let db = self.context.get_database().await?;
        let coll: mongodb::Collection<Document> = db.collection(&collection);

        // Drop the collection
        coll.drop()
            .await
            .map_err(|e| ExecutionError::QueryFailed(e.to_string()))?;

        debug!("Dropped collection '{}'", collection);

        Ok(ExecutionResult {
            success: true,
            data: ResultData::Message(format!("Dropped collection: {}", collection)),
            stats: ExecutionStats::default(),
            error: None,
        })
    }

    /// Rename a collection
    ///
    /// # Arguments
    /// * `collection` - Name of the collection to rename
    /// * `target` - New name for the collection
    /// * `drop_target` - Whether to drop the target collection if it exists
    ///
    /// # Returns
    /// * `Result<ExecutionResult>` - Collection rename result
    async fn rename_collection(
        &self,
        collection: String,
        target: String,
        drop_target: bool,
    ) -> Result<ExecutionResult> {
        use mongodb::bson::doc;
        use tracing::debug;

        debug!(
            "Renaming collection '{}' to '{}' (dropTarget: {})",
            collection, target, drop_target
        );

        let db = self.context.get_database().await?;
        let db_name = db.name();

        // Build the renameCollection command
        // The command must be run on the admin database
        let command = doc! {
            "renameCollection": format!("{}.{}", db_name, collection),
            "to": format!("{}.{}", db_name, target),
            "dropTarget": drop_target,
        };

        // Execute the command on the admin database
        let client = self.context.get_client().await?;
        let admin_db = client.database("admin");

        admin_db
            .run_command(command)
            .await
            .map_err(|e| ExecutionError::QueryFailed(e.to_string()))?;

        debug!("Renamed collection '{}' to '{}'", collection, target);

        Ok(ExecutionResult {
            success: true,
            data: ResultData::Message(format!(
                "Renamed collection '{}' to '{}'",
                collection, target
            )),
            stats: ExecutionStats::default(),
            error: None,
        })
    }

    /// Get collection statistics
    ///
    /// # Arguments
    /// * `collection` - Name of the collection
    /// * `scale` - Optional scale factor for size values
    ///
    /// # Returns
    /// * `Result<ExecutionResult>` - Collection statistics
    async fn collection_stats(
        &self,
        collection: String,
        scale: Option<i32>,
    ) -> Result<ExecutionResult> {
        use mongodb::bson::doc;
        use tracing::debug;

        debug!(
            "Getting stats for collection '{}' with scale: {:?}",
            collection, scale
        );

        let db = self.context.get_database().await?;

        // Build the collStats command
        let mut command = doc! {
            "collStats": &collection,
        };

        if let Some(scale_value) = scale {
            command.insert("scale", scale_value);
        }

        // Execute the command
        let result = db
            .run_command(command)
            .await
            .map_err(|e| ExecutionError::QueryFailed(e.to_string()))?;

        debug!("Retrieved stats for collection '{}'", collection);

        Ok(ExecutionResult {
            success: true,
            data: ResultData::Document(result),
            stats: ExecutionStats::default(),
            error: None,
        })
    }
}

#[cfg(test)]
mod tests {
    #[tokio::test]
    async fn test_admin_executor_creation() {
        // This is a placeholder test - would need proper setup with ConnectionManager
        // and SharedState to fully test
    }
}