// Parmanode to App Manifest converter
// Converts Parmanode module structure to Archipelago app manifest format

use archipelago_container::AppManifest;
use anyhow::{Context, Result};
use std::path::PathBuf;
use tokio::fs;
use tracing::info;

pub struct ParmanodeConverter;

impl ParmanodeConverter {
    pub fn new() -> Self {
        Self
    }
    
    /// Convert a Parmanode module directory to an App Manifest
    pub async fn convert_to_manifest(&self, module_path: &PathBuf) -> Result<AppManifest> {
        info!("Converting Parmanode module to manifest: {:?}", module_path);
        
        // Read Parmanode module metadata if available
        let module_name = module_path
            .file_name()
            .and_then(|n| n.to_str())
            .unwrap_or("unknown")
            .to_string();
        
        // Try to detect what the module installs
        let install_script = module_path.join("install.sh");
        let script_content = if install_script.exists() {
            fs::read_to_string(&install_script).await.ok()
        } else {
            None
        };
        
        // Infer app details from script content
        let (app_id, image) = self.infer_from_script(&script_content)?;
        
        // Create a basic manifest
        let manifest_yaml = format!(
            r#"
app:
  id: {}
  name: {}
  version: 1.0.0
  description: Converted from Parmanode module
  
  container:
    image: {}
    pull_policy: if-not-present
    
  resources:
    cpu_limit: 1
    memory_limit: 512Mi
    disk_limit: 10Gi
    
  security:
    capabilities: []
    readonly_root: true
    network_policy: isolated
"#,
            app_id, module_name, image
        );
        
        AppManifest::from_str(&manifest_yaml)
            .context("Failed to create manifest from Parmanode module")
    }
    
    fn infer_from_script(&self, script_content: &Option<String>) -> Result<(String, String)> {
        let content = script_content.as_deref().unwrap_or("");

        // Try to detect Bitcoin Core
        if content.contains("bitcoind") || content.contains("bitcoin-core") {
            return Ok(("bitcoin-core".to_string(), "bitcoin/bitcoin:24.0".to_string()));
        }

        // Try to detect LND
        if content.contains("lnd") && !content.contains("lightning") {
            return Ok(("lnd".to_string(), "lightninglabs/lnd:v0.18.0".to_string()));
        }

        // Try to detect Core Lightning
        if content.contains("clightning") || content.contains("core-lightning") {
            return Ok(("core-lightning".to_string(), "elementsproject/lightningd:v23.08.2".to_string()));
        }

        // Try to detect Electrs
        if content.contains("electrs") {
            return Ok(("electrs".to_string(), "romanz/electrs:v0.10.0".to_string()));
        }

        // Default fallback — pin Alpine to a specific version
        Ok(("parmanode-module".to_string(), "alpine:3.19".to_string()))
    }
}

impl Default for ParmanodeConverter {
    fn default() -> Self {
        Self::new()
    }
}
