tfmcp 0.2.2

//! Terraform provider information retrieval.

use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::fs;
use std::path::Path;
use std::process::Command;

/// Provider information from terraform providers command
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ProviderInfo {
    pub name: String,
    pub namespace: String,
    pub version: Option<String>,
    pub version_constraints: Option<String>,
    pub source: String,
}

/// Lock file entry
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ProviderLock {
    pub name: String,
    pub version: String,
    pub constraints: Option<String>,
    pub hashes: Vec<String>,
}

/// Complete provider information result
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ProvidersResult {
    pub success: bool,
    pub providers: Vec<ProviderInfo>,
    pub locks: Option<Vec<ProviderLock>>,
    pub message: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ProviderLockfileCheck {
    pub lockfile_exists: bool,
    pub provider_count: usize,
    pub locked_providers: Vec<ProviderLock>,
    pub warnings: Vec<String>,
    pub recommendations: Vec<String>,
}

/// Get provider information
pub fn get_providers(
    terraform_path: &Path,
    project_dir: &Path,
    include_lock: bool,
) -> anyhow::Result<ProvidersResult> {
    // Run terraform providers command
    let output = Command::new(terraform_path)
        .arg("providers")
        .current_dir(project_dir)
        .output()?;

    let stdout = String::from_utf8_lossy(&output.stdout);
    let stderr = String::from_utf8_lossy(&output.stderr);

    if !output.status.success() {
        return Err(anyhow::anyhow!("Failed to get providers: {stderr}"));
    }

    // Parse provider output
    let providers = parse_providers_output(&stdout);

    // Parse lock file if requested
    let locks = if include_lock {
        parse_lock_file(project_dir).ok()
    } else {
        None
    };

    let message = format!("Found {} providers", providers.len());

    Ok(ProvidersResult {
        success: true,
        providers,
        locks,
        message,
    })
}

pub fn check_provider_lockfile(project_dir: &Path) -> anyhow::Result<ProviderLockfileCheck> {
    let lock_path = project_dir.join(".terraform.lock.hcl");
    if !lock_path.exists() {
        return Ok(ProviderLockfileCheck {
            lockfile_exists: false,
            provider_count: 0,
            locked_providers: Vec::new(),
            warnings: vec!["Provider lockfile .terraform.lock.hcl is missing".to_string()],
            recommendations: vec![
                "Run terraform init and commit .terraform.lock.hcl for reproducible provider selection"
                    .to_string(),
            ],
        });
    }

    let locks = parse_lock_file(project_dir)?;
    let mut warnings = Vec::new();
    let mut recommendations = Vec::new();

    if locks.is_empty() {
        warnings.push("Provider lockfile exists but no provider entries were parsed".to_string());
    }

    for lock in &locks {
        if lock.hashes.is_empty() {
            warnings.push(format!("Provider {} has no hashes recorded", lock.name));
        }
        if lock.constraints.is_none() {
            recommendations.push(format!(
                "Add an explicit version constraint for provider {} in required_providers",
                lock.name
            ));
        }
    }

    Ok(ProviderLockfileCheck {
        lockfile_exists: true,
        provider_count: locks.len(),
        locked_providers: locks,
        warnings,
        recommendations,
    })
}

/// Parse terraform providers output
fn parse_providers_output(output: &str) -> Vec<ProviderInfo> {
    let mut providers = Vec::new();
    let mut seen: HashMap<String, bool> = HashMap::new();

    for line in output.lines() {
        let line = line.trim();

        // Skip empty lines and headers
        if line.is_empty()
            || line.starts_with("Providers required")
            || line.starts_with(".")
            || line.starts_with("├")
            || line.starts_with("└")
        {
            // Check if this is a provider line in tree format
            if line.contains("provider[") || line.contains("registry.terraform.io") {
                if let Some(provider) = parse_provider_line(line) {
                    let key = format!("{}/{}", provider.namespace, provider.name);
                    if let std::collections::hash_map::Entry::Vacant(e) = seen.entry(key) {
                        e.insert(true);
                        providers.push(provider);
                    }
                }
            }
            continue;
        }

        // Parse provider lines
        if line.contains("provider[") || line.contains("registry.terraform.io") {
            if let Some(provider) = parse_provider_line(line) {
                let key = format!("{}/{}", provider.namespace, provider.name);
                if let std::collections::hash_map::Entry::Vacant(e) = seen.entry(key) {
                    e.insert(true);
                    providers.push(provider);
                }
            }
        }
    }

    providers
}

/// Parse a single provider line
fn parse_provider_line(line: &str) -> Option<ProviderInfo> {
    // Format: provider[registry.terraform.io/hashicorp/aws] 5.0.0
    // or: └── provider[registry.terraform.io/hashicorp/aws] 5.0.0

    let line = line
        .trim_start_matches('├')
        .trim_start_matches('└')
        .trim_start_matches('─')
        .trim_start_matches(' ')
        .trim();

    // Extract the provider part
    if let Some(start) = line.find("provider[") {
        let rest = &line[start + 9..];
        if let Some(end) = rest.find(']') {
            let provider_path = &rest[..end];

            // Parse provider path: registry.terraform.io/namespace/name
            let parts: Vec<&str> = provider_path.split('/').collect();
            if parts.len() >= 3 {
                let namespace = parts[parts.len() - 2].to_string();
                let name = parts[parts.len() - 1].to_string();

                // Extract version if present
                let version = rest[end + 1..]
                    .split_whitespace()
                    .next()
                    .filter(|v| !v.is_empty())
                    .map(|v| v.to_string());

                return Some(ProviderInfo {
                    name,
                    namespace: namespace.clone(),
                    version: version.clone(),
                    version_constraints: version,
                    source: provider_path.to_string(),
                });
            }
        }
    }

    None
}

/// Parse .terraform.lock.hcl file
fn parse_lock_file(project_dir: &Path) -> anyhow::Result<Vec<ProviderLock>> {
    let lock_path = project_dir.join(".terraform.lock.hcl");

    if !lock_path.exists() {
        return Ok(vec![]);
    }

    let content = fs::read_to_string(&lock_path)?;
    parse_lock_hcl(&content)
}

/// Parse the lock file HCL content
fn parse_lock_hcl(content: &str) -> anyhow::Result<Vec<ProviderLock>> {
    let mut locks = Vec::new();
    let mut current_provider: Option<String> = None;
    let mut current_version: Option<String> = None;
    let mut current_constraints: Option<String> = None;
    let mut current_hashes: Vec<String> = Vec::new();

    for line in content.lines() {
        let line = line.trim();

        // Provider block start
        if line.starts_with("provider \"") {
            // Save previous provider if exists
            if let (Some(name), Some(version)) = (&current_provider, &current_version) {
                locks.push(ProviderLock {
                    name: name.clone(),
                    version: version.clone(),
                    constraints: current_constraints.take(),
                    hashes: std::mem::take(&mut current_hashes),
                });
            }

            // Extract new provider name
            if let Some(start) = line.find('"') {
                if let Some(end) = line[start + 1..].find('"') {
                    current_provider = Some(line[start + 1..start + 1 + end].to_string());
                }
            }
            current_version = None;
            current_constraints = None;
            current_hashes.clear();
        }
        // Version
        else if line.starts_with("version") {
            if let Some(start) = line.find('"') {
                if let Some(end) = line[start + 1..].find('"') {
                    current_version = Some(line[start + 1..start + 1 + end].to_string());
                }
            }
        }
        // Constraints
        else if line.starts_with("constraints") {
            if let Some(start) = line.find('"') {
                if let Some(end) = line[start + 1..].find('"') {
                    current_constraints = Some(line[start + 1..start + 1 + end].to_string());
                }
            }
        }
        // Hashes
        else if line.starts_with("\"h1:") || line.starts_with("\"zh:") {
            if let Some(end) = line[1..].find('"') {
                current_hashes.push(line[1..end + 1].to_string());
            }
        }
    }

    // Save last provider
    if let (Some(name), Some(version)) = (current_provider, current_version) {
        locks.push(ProviderLock {
            name,
            version,
            constraints: current_constraints,
            hashes: current_hashes,
        });
    }

    Ok(locks)
}

/// Get provider version constraints from configuration
#[allow(dead_code)]
pub fn get_provider_requirements(project_dir: &Path) -> anyhow::Result<HashMap<String, String>> {
    let mut requirements = HashMap::new();

    // Read all .tf files looking for required_providers blocks
    if let Ok(entries) = fs::read_dir(project_dir) {
        for entry in entries.flatten() {
            let path = entry.path();
            if path.is_file() && path.extension().is_some_and(|e| e == "tf") {
                if let Ok(content) = fs::read_to_string(&path) {
                    extract_provider_requirements(&content, &mut requirements);
                }
            }
        }
    }

    Ok(requirements)
}

/// Extract provider requirements from HCL content
#[allow(dead_code)]
fn extract_provider_requirements(content: &str, requirements: &mut HashMap<String, String>) {
    let mut in_required_providers = false;
    let mut brace_depth = 0;

    for line in content.lines() {
        let line = line.trim();

        if line.contains("required_providers") {
            in_required_providers = true;
            brace_depth = 0;
        }

        if in_required_providers {
            brace_depth += line.matches('{').count() as i32;
            brace_depth -= line.matches('}').count() as i32;

            if brace_depth <= 0 && line.contains('}') {
                in_required_providers = false;
                continue;
            }

            // Look for version constraints
            if line.contains("version") {
                if let Some(start) = line.find('"') {
                    if let Some(end) = line[start + 1..].find('"') {
                        let version = line[start + 1..start + 1 + end].to_string();

                        // Try to find the provider name from previous lines or same line
                        if let Some(eq_pos) = line.find('=') {
                            let name = line[..eq_pos].trim().to_string();
                            if !name.is_empty() && name != "version" {
                                requirements.insert(name, version.clone());
                            }
                        }
                    }
                }
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_parse_provider_line() {
        let line = "provider[registry.terraform.io/hashicorp/aws] 5.31.0";
        let provider = parse_provider_line(line).unwrap();
        assert_eq!(provider.name, "aws");
        assert_eq!(provider.namespace, "hashicorp");
        assert_eq!(provider.version, Some("5.31.0".to_string()));
    }

    #[test]
    fn test_parse_provider_line_tree_format() {
        let line = "└── provider[registry.terraform.io/hashicorp/random] 3.5.0";
        let provider = parse_provider_line(line).unwrap();
        assert_eq!(provider.name, "random");
        assert_eq!(provider.namespace, "hashicorp");
    }

    #[test]
    fn test_parse_lock_hcl() {
        let content = r#"
provider "registry.terraform.io/hashicorp/aws" {
  version     = "5.31.0"
  constraints = "~> 5.0"
  hashes = [
    "h1:abc123",
    "zh:def456",
  ]
}
"#;
        let locks = parse_lock_hcl(content).unwrap();
        assert_eq!(locks.len(), 1);
        assert_eq!(locks[0].version, "5.31.0");
        assert_eq!(locks[0].constraints, Some("~> 5.0".to_string()));
    }

    #[test]
    fn test_extract_provider_requirements() {
        let content = r#"
terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }
}
"#;
        let mut reqs = HashMap::new();
        extract_provider_requirements(content, &mut reqs);
        // Note: This simple parser may not catch all cases
        // The terraform providers command is more reliable
    }

    #[test]
    fn test_check_provider_lockfile_missing() {
        let dir = tempfile::tempdir().unwrap();
        let check = check_provider_lockfile(dir.path()).unwrap();

        assert!(!check.lockfile_exists);
        assert_eq!(check.provider_count, 0);
        assert!(!check.warnings.is_empty());
    }

    #[test]
    fn test_check_provider_lockfile_detects_entries() {
        let dir = tempfile::tempdir().unwrap();
        fs::write(
            dir.path().join(".terraform.lock.hcl"),
            r#"
provider "registry.terraform.io/hashicorp/aws" {
  version     = "5.31.0"
  constraints = "~> 5.0"
  hashes = [
    "h1:abc123",
  ]
}
"#,
        )
        .unwrap();

        let check = check_provider_lockfile(dir.path()).unwrap();

        assert!(check.lockfile_exists);
        assert_eq!(check.provider_count, 1);
        assert!(check.warnings.is_empty());
    }
}