pub trait Command: Serialize + Clone {
    fn execute(&self, graph: &mut Graph) -> Result<()>;
    fn inverse(&self) -> Box<dyn Command>;
    fn timestamp(&self) -> Timestamp;
    fn peer_id(&self) -> PeerId;
}

pub enum GraphCommand {
    CreateNode(CreateNodeCommand),
    DeleteNode(DeleteNodeCommand),
    UpdateNodeMetadata(UpdateNodeMetadataCommand),
    CreateEdge(CreateEdgeCommand),
    DeleteEdge(DeleteEdgeCommand),
    MoveNode(MoveNodeCommand),
}

// Example command
pub struct CreateNodeCommand {
    node_id: NodeKey,
    url: Url,
    title: String,
    position: Point2D<f32>,
    timestamp: Timestamp,
    peer_id: PeerId,
}

pub struct OperationLog {
    operations: Vec<LogEntry>,
    file_path: PathBuf,
}

pub struct LogEntry {
    command: Box<dyn Command>,
    sequence_number: u64,
    synced_to_peers: Vec<PeerId>,    // Which peers have this op
}

impl OperationLog {
    pub fn append(&mut self, cmd: Box<dyn Command>) -> Result<()> {
        let entry = LogEntry {
            command: cmd.clone(),
            sequence_number: self.operations.len() as u64,
            synced_to_peers: vec![],
        };
        
        // 1. Persist to disk first (durability)
        self.save_entry_to_file(&entry)?;
        
        // 2. Then add to memory
        self.operations.push(entry);
        
        Ok(())
    }
    
    pub fn unsynced_ops(&self) -> Vec<(u64, &Box<dyn Command>)> {
        self.operations.iter()
            .enumerate()
            .map(|(i, entry)| (i as u64, &entry.command))
            .collect()
    }
    
    pub fn mark_synced(&mut self, peer_id: PeerId, up_to_seq: u64) {
        for i in 0..=up_to_seq as usize {
            self.operations[i].synced_to_peers.push(peer_id);
        }
    }
}

pub struct VersionVector {
    clocks: HashMap<PeerId, u64>,
}

impl VersionVector {
    pub fn increment(&mut self, peer_id: PeerId) {
        *self.clocks.entry(peer_id).or_insert(0) += 1;
    }
    
    pub fn happened_before(&self, other: &VersionVector) -> bool {
        // self < other: All clocks ≤, at least one <
        self.clocks.iter().all(|(peer, clock)| {
            clock <= other.clocks.get(peer).copied().unwrap_or(0)
        }) && self.clocks != &other.clocks
    }
    
    pub fn concurrent(&self, other: &VersionVector) -> bool {
        !self.happened_before(other) && !other.happened_before(self)
    }
}

// Apply version vector to each node
pub struct Node {
    id: NodeKey,
    url: Url,
    version_vector: VersionVector,  // Track when this was last modified
    created_by: PeerId,
    last_modified_by: PeerId,
    last_modified_timestamp: Timestamp,
}

pub fn merge_node_metadata(local: &mut Node, remote: &Node) {
    if remote.last_modified_timestamp > local.last_modified_timestamp {
        local.title = remote.title.clone();
        local.notes = remote.notes.clone();
        local.last_modified_by = remote.last_modified_by;
        local.version_vector = remote.version_vector.clone();
    }
}

pub fn merge_node_metadata(local: &mut Node, remote: &Node) {
    if remote.version_vector.happened_before(&local.version_vector) {
        return;  // Local is newer, keep it
    } else if local.version_vector.happened_before(&remote.version_vector) {
        *local = remote.clone();  // Remote is newer, take it
    } else {
        // Concurrent: conflict!
        return Err(Conflict {
            local_version: local.version_vector.clone(),
            remote_version: remote.version_vector.clone(),
        });
    }
}

pub struct CRDTPosition {
    last_update_by: PeerId,
    last_update_at: Timestamp,
    position: Point2D<f32>,
    version_vector: VersionVector,
}

pub fn merge_positions(local: &mut CRDTPosition, remote: &CRDTPosition) {
    if remote.version_vector.happened_before(&local.version_vector) {
        return;  // Local is newer
    } else if local.version_vector.happened_before(&remote.version_vector) {
        *local = remote.clone();  // Remote is newer
    } else {
        // Concurrent: average the positions (physics will converge anyway)
        local.position = Point2D {
            x: (local.position.x + remote.position.x) / 2.0,
            y: (local.position.y + remote.position.y) / 2.0,
        };
        local.version_vector.merge_with(&remote.version_vector);
    }
}

pub enum MergeConflict {
    NodeDeleted {
        node_id: NodeKey,
        deleted_by: PeerId,
        deleted_at: Timestamp,
        edges_exist: bool,  // User added edges after deletion?
    },
    EdgeConflict {
        from: NodeKey,
        to: NodeKey,
        local_exists: bool,
        remote_exists: bool,
    },
}

pub fn show_conflict_ui(conflict: &MergeConflict) -> ConflictResolution {
    // Show UI to user: "Peer B deleted node X, but you have edges to it. Keep or delete?"
    // Returns: Keep / Delete / Merge
}

pub struct SyncRequest {
    peer_id: PeerId,
    our_seq: u64,           // "We have up to seq 4"
}

pub struct SyncResponse {
    peer_id: PeerId,
    their_seq: u64,         // "We have up to seq 2"
    ops: Vec<Box<dyn Command>>,  // "Here are ops 3-4"
}

impl P2PSync {
    pub fn pull(&self, peer: &PeerId) -> Result<SyncResponse> {
        let req = SyncRequest {
            peer_id: self.our_id,
            our_seq: self.local_log.len() as u64,
        };
        
        let resp = peer.send_sync_request(&req).await?;
        
        // Apply received ops
        for op in &resp.ops {
            self.graph.execute(op)?;
            self.local_log.mark_synced(*peer, op.timestamp());
        }
        
        Ok(resp)
    }
    
    pub fn push_to(&self, peer: &PeerId, up_to_seq: u64) -> Result<()> {
        let ops = self.local_log.ops_since(peer, up_to_seq);
        peer.send_ops(&ops).await?;
        Ok(())
    }
}

pub struct DirectP2P {
    local_addr: SocketAddr,
    peers: HashMap<PeerId, SocketAddr>,
}

impl DirectP2P {
    pub async fn broadcast_ops(&self, ops: &[Box<dyn Command>]) {
        for (peer_id, addr) in &self.peers {
            self.send_to(addr, ops).await;
        }
    }
}

pub struct RelayedP2P {
    relay_addr: String,  // e.g., "sync.graphshell-network.org:8080"
    group_id: String,    // "my-research-group"
}

impl RelayedP2P {
    pub async fn connect_to_relay(&self) {
        let ws = WebSocket::connect(&self.relay_addr).await?;
        ws.send(AuthMessage {
            group_id: self.group_id.clone(),
            peer_id: self.peer_id,
            signature: sign_with_group_key(),
        }).await?;
    }
    
    pub async fn broadcast_ops(&self, ops: &[Box<dyn Command>]) {
        let msg = SyncMessage {
            from: self.peer_id,
            to: None,  // Broadcast to group
            ops,
        };
        self.relay_connection.send(msg).await?;
    }
}

pub struct TrustedGroupSync {
    group_id: String,
    shared_key: Vec<u8>,  // 32 bytes, AES-256
    peers: Vec<PeerId>,
}

impl TrustedGroupSync {
    pub fn encrypt_message(&self, msg: &[u8]) -> Vec<u8> {
        encrypt_aes_gcm(msg, &self.shared_key)
    }
    
    pub fn decrypt_message(&self, encrypted: &[u8]) -> Result<Vec<u8>> {
        decrypt_aes_gcm(encrypted, &self.shared_key)
    }
}

pub struct SignedCommand {
    command: Box<dyn Command>,
    signature: Vec<u8>,        // Sign(peer_private_key, command)
    peer_public_key: Vec<u8>,  // For verification
}

impl SignedCommand {
    pub fn verify(&self, trusted_keys: &[Vec<u8>]) -> bool {
        let is_trusted = trusted_keys.contains(&self.peer_public_key);
        let is_valid = verify_signature(&self.signature, &self.command, &self.peer_public_key);
        is_trusted && is_valid
    }
}

pub struct PortableGraph {
    version: String,           // "1.0"
    created_at: Timestamp,
    app_version: String,       // "graphshell-0.2.0"
    
    nodes: Vec<PortableNode>,
    edges: Vec<PortableEdge>,
    
    operation_log: Vec<PortableCommand>,  // For rebuild
}

pub struct PortableNode {
    id: String,               // UUID, stable across exports
    url: String,
    title: String,
    notes: String,
    tags: Vec<String>,
    
    position: (f32, f32),     // Absolute position
    created_at: Timestamp,
    created_by: String,       // Peer name/id
    
    metadata: PortableMetadata,
}

pub struct PortableMetadata {
    favicon: Option<String>,  // Base64 PNG
    thumbnail: Option<String>, // Base64 JPEG
    description: String,
}