//! Node-to-node messaging over Tor.
//! Sends messages to peer .onion addresses via SOCKS5 proxy.
//! Messages are persisted to disk and survive restarts.

use anyhow::{Context, Result};
use serde::{Deserialize, Serialize};
use std::path::{Path, PathBuf};
use std::sync::{Mutex, OnceLock};

const TOR_SOCKS: &str = "socks5h://127.0.0.1:9050";
const MAX_STORED: usize = 200;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct IncomingMessage {
    pub from_pubkey: String,
    #[serde(default)]
    pub from_onion: Option<String>,
    pub message: String,
    pub timestamp: String,
    /// "sent" or "received"
    #[serde(default = "default_received")]
    pub direction: String,
}

fn default_received() -> String {
    "received".to_string()
}

#[derive(Debug, Default, Serialize, Deserialize)]
struct MessageStore {
    messages: Vec<IncomingMessage>,
}

fn store() -> &'static Mutex<MessageStore> {
    static STORE: OnceLock<Mutex<MessageStore>> = OnceLock::new();
    STORE.get_or_init(|| Mutex::new(MessageStore::default()))
}

fn data_path() -> &'static Mutex<Option<PathBuf>> {
    static PATH: OnceLock<Mutex<Option<PathBuf>>> = OnceLock::new();
    PATH.get_or_init(|| Mutex::new(None))
}

/// Initialize message store — load from disk. Call once at startup.
pub async fn init(data_dir: &Path) {
    let path = data_dir.join("messages.json");
    *data_path().lock().unwrap_or_else(|e| e.into_inner()) = Some(path.clone());

    if let Ok(content) = tokio::fs::read_to_string(&path).await {
        if let Ok(loaded) = serde_json::from_str::<MessageStore>(&content) {
            let mut guard = store().lock().unwrap_or_else(|e| e.into_inner());
            *guard = loaded;
            tracing::info!("Loaded {} messages from disk", guard.messages.len());
        }
    }
}

/// Persist current messages to disk.
fn persist() {
    let guard = store().lock().unwrap_or_else(|e| e.into_inner());
    let path_guard = data_path().lock().unwrap_or_else(|e| e.into_inner());
    if let Some(ref path) = *path_guard {
        if let Ok(content) = serde_json::to_string(&*guard) {
            // Use sync write — called from store functions already holding the lock
            let _ = std::fs::write(path, content);
        }
    }
}

/// Store a received message (called from HTTP handler).
pub fn store_received_sync(from_pubkey: &str, message: &str) {
    let ts = chrono::Utc::now().to_rfc3339();
    let mut guard = store().lock().unwrap_or_else(|e| e.into_inner());

    // Deduplication: skip if same pubkey + message within last 30 seconds
    let dominated = guard.messages.iter().rev().take(20).any(|m| {
        m.from_pubkey == from_pubkey && m.message == message && m.direction == "received"
            && within_seconds(&m.timestamp, &ts, 30)
    });
    if dominated {
        return;
    }

    guard.messages.push(IncomingMessage {
        from_pubkey: from_pubkey.to_string(),
        from_onion: None,
        message: message.to_string(),
        timestamp: ts,
        direction: "received".to_string(),
    });
    trim_messages(&mut guard);
    drop(guard);
    persist();
}

pub async fn store_received(from_pubkey: &str, message: &str) {
    store_received_sync(from_pubkey, message);
}

/// Store a sent message (for display in Archipelago channel).
pub fn store_sent(message: &str) {
    let mut guard = store().lock().unwrap_or_else(|e| e.into_inner());
    guard.messages.push(IncomingMessage {
        from_pubkey: "me".to_string(),
        from_onion: None,
        message: message.to_string(),
        timestamp: chrono::Utc::now().to_rfc3339(),
        direction: "sent".to_string(),
    });
    trim_messages(&mut guard);
    drop(guard);
    persist();
}

/// Get all messages (sent + received) for UI display.
pub fn get_received() -> Vec<IncomingMessage> {
    store().lock().unwrap_or_else(|e| e.into_inner()).messages.clone()
}

fn trim_messages(store: &mut MessageStore) {
    if store.messages.len() > MAX_STORED {
        let drain = store.messages.len() - MAX_STORED;
        store.messages.drain(0..drain);
    }
}

/// Check if two ISO8601 timestamps are within N seconds of each other.
fn within_seconds(ts1: &str, ts2: &str, secs: i64) -> bool {
    use chrono::DateTime;
    let a = DateTime::parse_from_rfc3339(ts1).ok();
    let b = DateTime::parse_from_rfc3339(ts2).ok();
    match (a, b) {
        (Some(a), Some(b)) => (a - b).num_seconds().unsigned_abs() < secs as u64,
        _ => false,
    }
}

// ─── Tor Messaging ──────────────────────────────────────────────

/// Tor v3 onion hostname is 56 base32 chars (a-z, 2-7). Reject invalid formats.
fn validate_onion(onion: &str) -> Result<()> {
    let host = onion.trim_end_matches(".onion");
    if host.len() != 56 {
        anyhow::bail!(
            "Invalid onion address (expected 56 chars, got {}). The peer may have wrong data - try removing and re-adding via Discover.",
            host.len()
        );
    }
    let valid = host.chars().all(|c| c.is_ascii_lowercase() || (c >= '2' && c <= '7'));
    if !valid {
        anyhow::bail!("Invalid onion address: must be 56 base32 chars (a-z, 2-7)");
    }
    Ok(())
}

/// Send a message to a peer over Tor.
pub async fn send_to_peer(onion: &str, from_pubkey: &str, message: &str) -> Result<()> {
    validate_onion(onion)?;

    let host = if onion.ends_with(".onion") {
        onion.to_string()
    } else {
        format!("{}.onion", onion)
    };
    let url = format!("http://{}/archipelago/node-message", host);
    let body = serde_json::json!({
        "from_pubkey": from_pubkey,
        "message": message,
        "timestamp": chrono::Utc::now().to_rfc3339(),
    });

    let proxy = reqwest::Proxy::all(TOR_SOCKS).context("Invalid Tor proxy")?;
    let client = reqwest::Client::builder()
        .proxy(proxy)
        .timeout(std::time::Duration::from_secs(60))
        .build()
        .context("Failed to build HTTP client")?;

    let resp = client
        .post(&url)
        .json(&body)
        .send()
        .await
        .map_err(|e| {
            let msg = e.to_string();
            if msg.contains("connection refused") || msg.contains("Connection refused") {
                anyhow::anyhow!("Tor not reachable at 127.0.0.1:9050. Is Tor running?")
            } else if msg.contains("timeout") || msg.contains("timed out") {
                anyhow::anyhow!("Connection timed out. The peer may be offline or unreachable over Tor.")
            } else {
                anyhow::anyhow!("Failed to send over Tor: {}", msg)
            }
        })?;

    if !resp.status().is_success() {
        anyhow::bail!(
            "Peer returned {} {}. The peer may need /archipelago/ in its nginx config.",
            resp.status().as_u16(),
            resp.status().canonical_reason().unwrap_or("")
        );
    }
    Ok(())
}

/// Check if a peer is reachable (ping over Tor).
pub async fn check_peer_reachable(onion: &str) -> Result<bool> {
    validate_onion(onion)?;

    let host = if onion.ends_with(".onion") {
        onion.to_string()
    } else {
        format!("{}.onion", onion)
    };
    let url = format!("http://{}/health", host);
    let proxy = reqwest::Proxy::all(TOR_SOCKS).context("Invalid Tor proxy")?;
    let client = reqwest::Client::builder()
        .proxy(proxy)
        .timeout(std::time::Duration::from_secs(30))
        .build()
        .context("Failed to build HTTP client")?;

    match client.get(&url).send().await {
        Ok(resp) => Ok(resp.status().is_success()),
        Err(_) => Ok(false),
    }
}