use chrs_mail::{Mailbox, Message};
use chrono::Utc;
use std::process::Command;
use uuid::Uuid;
use std::path::PathBuf;

pub struct SyncManager {
    mailbox: Mailbox,
    repo_path: PathBuf,
}

impl SyncManager {
    pub fn new(mailbox: Mailbox, repo_path: PathBuf) -> Self {
        Self { mailbox, repo_path }
    }

    pub fn broadcast_state(&self, from_peer: &str, to_peer: &str) -> Result<(), Box<dyn std::error::Error>> {
        // Get current dolt hash
        let output = Command::new("dolt")
            .args(&["log", "-n", "1", "--format", "%H"])
            .current_dir(&self.repo_path)
            .output()?;
        
        let current_hash = String::from_utf8_lossy(&output.stdout).trim().to_string();
        
        let msg = Message {
            id: Uuid::new_v4(),
            from_peer: from_peer.into(),
            to_peer: to_peer.into(),
            topic: "sync_signal".into(),
            payload: serde_json::json!({ "commit_hash": current_hash }),
            sent_at: Utc::now(),
            read_at: None,
        };

        self.mailbox.send(&msg)?;
        println!("Broadcasted sync signal: {} from {}", current_hash, from_peer);
        Ok(())
    }

    pub fn handle_sync_signal(&self, msg: &Message) -> Result<(), Box<dyn std::error::Error>> {
        if msg.topic != "sync_signal" {
            return Ok(());
        }

        let remote_hash = msg.payload["commit_hash"].as_str().unwrap_or_default();
        println!("Received sync signal for hash: {}", remote_hash);

        // In a real P2P scenario, we would pull from the remote peer's URL.
        // For now, we simulate by attempting a 'dolt pull' if a remote is configured.
        let status = Command::new("dolt")
            .args(&["pull", "origin"])
            .current_dir(&self.repo_path)
            .status()?;

        if status.success() {
            println!("Successfully pulled updates for hash: {}", remote_hash);
        }

        Ok(())
    }
}