things3-cli 1.0.0

//! Test binary for Things3 MCP with real user data
//!
//! This binary provides a safe way to test the MCP implementation using
//! your actual Things 3 database in read-only mode.

use anyhow::Result;
use clap::{Parser, ValueEnum};
use serde_json::Value;
use std::path::PathBuf;
use std::sync::Arc;
use std::time::Instant;
use things3_core::{ThingsConfig, ThingsDatabase};
use tracing::{error, info, warn};

/// Test mode selection
#[derive(Debug, Clone, ValueEnum)]
enum TestMode {
    /// Run normal tests
    Normal,
    /// Run performance benchmarks
    Performance,
    /// Dry run - check setup without running tests
    DryRun,
}

/// Test runner for Things3 MCP with real data
#[derive(Parser)]
#[command(author, version, about, long_about = None)]
struct Args {
    /// Path to Things3 database (defaults to standard macOS location)
    #[arg(long)]
    database_path: Option<PathBuf>,

    /// Use a backup database instead of live data
    #[arg(long)]
    use_backup: bool,

    /// Enable verbose logging
    #[arg(short, long)]
    verbose: bool,

    /// Test mode to run
    #[arg(long, value_enum, default_value = "normal")]
    mode: TestMode,

    /// Output results in JSON format
    #[arg(long)]
    json_output: bool,
}

const DEFAULT_THINGS_DB_PATH: &str = "/Users/garthdb/Library/Group Containers/JLMPQHK86H.com.culturedcode.ThingsMac/ThingsData-0Z0Z2/Things Database.thingsdatabase/main.sqlite";

#[tokio::main]
async fn main() -> Result<()> {
    let args = Args::parse();

    // Initialize logging
    let log_level = if args.verbose { "debug" } else { "info" };
    tracing_subscriber::fmt()
        .with_env_filter(log_level)
        .with_target(false)
        .init();

    info!("Starting Things3 MCP test with real data");

    // Determine database path
    let db_path = args
        .database_path
        .unwrap_or_else(|| PathBuf::from(DEFAULT_THINGS_DB_PATH));

    if !db_path.exists() {
        error!("Database not found at: {}", db_path.display());
        return Err(anyhow::anyhow!("Database file not found"));
    }

    info!("Using database: {}", db_path.display());

    if matches!(args.mode, TestMode::DryRun) {
        info!("Dry run - setup looks good!");
        return Ok(());
    }

    // Create a safe test environment
    let test_runner = TestRunner::new(db_path, args.verbose, args.json_output).await?;

    // Run tests
    let run_performance = matches!(args.mode, TestMode::Performance);
    test_runner.run_all_tests(run_performance).await?;

    info!("All tests completed successfully");
    Ok(())
}

struct TestRunner {
    db: Arc<ThingsDatabase>,
    verbose: bool,
    #[allow(dead_code)]
    json_output: bool,
}

impl TestRunner {
    async fn new(db_path: PathBuf, verbose: bool, json_output: bool) -> Result<Self> {
        info!("Setting up test environment...");

        // Create database connection in read-only mode
        let config = ThingsConfig::new(db_path, false);
        let db = ThingsDatabase::new(&config.database_path).await?;

        Ok(Self {
            db: Arc::new(db),
            verbose,
            json_output,
        })
    }

    async fn run_all_tests(&self, run_performance: bool) -> Result<()> {
        info!("Running comprehensive MCP tests...");

        // Test 1: Database connectivity and basic queries
        self.test_database_connectivity().await?;

        // Test 2: Basic data retrieval
        self.test_basic_data_retrieval().await?;

        // Test 3: Test schema validation
        self.test_schema_validation().await?;

        // Test 4: Performance tests (if requested)
        if run_performance {
            self.run_performance_tests().await?;
        }

        // Test 5: MCP protocol simulation
        self.test_mcp_protocol_simulation().await?;

        Ok(())
    }

    async fn test_database_connectivity(&self) -> Result<()> {
        info!("Testing database connectivity...");

        let start = Instant::now();

        // Test basic connection
        let _inbox_tasks = self.db.get_inbox(Some(1)).await?;
        let tables = ["TMTask", "TMProject", "TMArea"]; // Simulated table list
        let duration = start.elapsed();

        info!(
            "✓ Database connected successfully ({} tables found in {:?})",
            tables.len(),
            duration
        );

        // Test that we can read from main tables
        let expected_tables = vec!["TMTask", "TMProject", "TMArea"];
        for table in expected_tables {
            if tables.iter().any(|t| t.contains(table)) {
                info!("✓ Found expected table: {}", table);
            } else {
                warn!("Expected table {} not found in schema", table);
            }
        }

        Ok(())
    }

    async fn test_basic_data_retrieval(&self) -> Result<()> {
        info!("Testing basic data retrieval...");

        // Test inbox tasks
        let start = Instant::now();
        let inbox_tasks = self.db.get_inbox(Some(10)).await?;
        let inbox_duration = start.elapsed();
        info!(
            "✓ Retrieved {} inbox tasks in {:?}",
            inbox_tasks.len(),
            inbox_duration
        );

        // Test projects
        let start = Instant::now();
        let projects = self.db.get_projects(Some(10)).await?;
        let projects_duration = start.elapsed();
        info!(
            "✓ Retrieved {} projects in {:?}",
            projects.len(),
            projects_duration
        );

        // Test areas
        let start = Instant::now();
        let areas = self.db.get_areas().await?;
        let areas_duration = start.elapsed();
        info!("✓ Retrieved {} areas in {:?}", areas.len(), areas_duration);

        // Test today's tasks
        let start = Instant::now();
        let today_tasks = self.db.get_today(Some(10)).await?;
        let today_duration = start.elapsed();
        info!(
            "✓ Retrieved {} today tasks in {:?}",
            today_tasks.len(),
            today_duration
        );

        Ok(())
    }

    async fn test_schema_validation(&self) -> Result<()> {
        info!("Testing schema validation...");

        // Validate that we can access expected columns
        let sample_task = self.db.get_inbox(Some(1)).await?;
        if let Some(task) = sample_task.first() {
            info!("✓ Sample task validation:");
            info!("  - UUID: {}", task.uuid);
            info!("  - Title: {}", task.title);
            info!("  - Status: {:?}", task.status);

            if !task.title.is_empty() {
                info!("✓ Task has valid title");
            }
        } else {
            warn!("No tasks found for schema validation");
        }

        Ok(())
    }

    async fn run_performance_tests(&self) -> Result<()> {
        info!("Running performance tests...");

        let test_cases = vec![
            ("inbox_query", 10),
            ("projects_query", 10),
            ("areas_query", 10),
            ("today_query", 10),
        ];

        for (test_name, iterations) in test_cases {
            info!("Running {} iterations of {}...", iterations, test_name);

            let mut durations = Vec::new();

            for i in 0..iterations {
                let start = Instant::now();

                match test_name {
                    "inbox_query" => {
                        self.db.get_inbox(Some(50)).await?;
                    }
                    "projects_query" => {
                        self.db.get_projects(Some(50)).await?;
                    }
                    "areas_query" => {
                        self.db.get_areas().await?;
                    }
                    "today_query" => {
                        self.db.get_today(Some(50)).await?;
                    }
                    _ => unreachable!(),
                }

                durations.push(start.elapsed());

                if self.verbose {
                    info!("  Iteration {}: {:?}", i + 1, durations.last().unwrap());
                }
            }

            let total_duration: std::time::Duration = durations.iter().sum();
            let avg_duration = if durations.is_empty() {
                std::time::Duration::ZERO
            } else {
                total_duration / u32::try_from(durations.len()).unwrap_or(1)
            };
            let min_duration = durations.iter().min().unwrap();
            let max_duration = durations.iter().max().unwrap();

            info!(
                "✓ {}: avg {:?}, min {:?}, max {:?}",
                test_name, avg_duration, min_duration, max_duration
            );
        }

        Ok(())
    }

    async fn test_mcp_protocol_simulation(&self) -> Result<()> {
        info!("Testing MCP protocol simulation...");

        // Simulate typical MCP tool calls
        let test_calls = vec![
            ("get_inbox", None::<String>),
            ("get_today", None::<String>),
            ("get_projects", None::<String>),
            ("get_areas", None::<String>),
        ];

        for (tool_name, _args) in test_calls {
            let start = Instant::now();

            match tool_name {
                "get_inbox" => {
                    let tasks = self.db.get_inbox(Some(20)).await?;
                    let json_result = serde_json::to_value(&tasks)?;
                    Self::validate_json_structure(&json_result, "inbox tasks");
                }
                "get_today" => {
                    let tasks = self.db.get_today(Some(20)).await?;
                    let json_result = serde_json::to_value(&tasks)?;
                    Self::validate_json_structure(&json_result, "today tasks");
                }
                "get_projects" => {
                    let projects = self.db.get_projects(Some(20)).await?;
                    let json_result = serde_json::to_value(&projects)?;
                    Self::validate_json_structure(&json_result, "projects");
                }
                "get_areas" => {
                    let areas = self.db.get_areas().await?;
                    let json_result = serde_json::to_value(&areas)?;
                    Self::validate_json_structure(&json_result, "areas");
                }
                _ => unreachable!(),
            }

            let duration = start.elapsed();
            info!("✓ MCP tool '{}' completed in {:?}", tool_name, duration);
        }

        Ok(())
    }

    fn validate_json_structure(json: &Value, data_type: &str) {
        if json.is_array() {
            let array = json.as_array().unwrap();
            info!(
                "✓ {} JSON structure valid (array with {} items)",
                data_type,
                array.len()
            );

            // Validate first item if it exists
            if let Some(first_item) = array.first() {
                if first_item.is_object() {
                    let obj = first_item.as_object().unwrap();
                    if obj.contains_key("uuid") && obj.contains_key("title") {
                        info!("✓ {} item structure valid (has uuid and title)", data_type);
                    } else {
                        warn!("{} item missing expected fields", data_type);
                    }
                }
            }
        } else {
            warn!("{} JSON is not an array as expected", data_type);
        }

        // Validation complete
    }
}