use std::collections::{HashMap, HashSet};

enum Phase {
    PrePrepare,
    Prepare,
    Commit,
}

struct Message {
    phase: Phase,
    view: u64,
    sequence: u64,
    block_hash: String,
    sender: String,
}

struct PBFTNode {
    id: String,
    view: u64,
    prepares: HashMap<u64, HashSet<String>>,
    commits: HashMap<u64, HashSet<String>>,
    total_nodes: usize,
}

impl PBFTNode {
    fn new(id: String, total_nodes: usize) -> Self {
        PBFTNode {
            id,
            view: 0,
            prepares: HashMap::new(),
            commits: HashMap::new(),
            total_nodes,
        }
    }
    
    fn receive_prepare(&mut self, msg: &Message) -> Option<Message> {
        let prepares = self.prepares.entry(msg.sequence).or_insert_with(HashSet::new);
        prepares.insert(msg.sender.clone());
        
        // Need 2f prepares (where f = (total_nodes - 1) / 3)
        let f = (self.total_nodes - 1) / 3;
        let required = 2 * f;
        
        if prepares.len() >= required && !self.commits.contains_key(&msg.sequence) {
            // Send commit
            Some(Message {
                phase: Phase::Commit,
                view: self.view,
                sequence: msg.sequence,
                block_hash: msg.block_hash.clone(),
                sender: self.id.clone(),
            })
        } else {
            None
        }
    }
    
    fn receive_commit(&mut self, msg: &Message) -> bool {
        let commits = self.commits.entry(msg.sequence).or_insert_with(HashSet::new);
        commits.insert(msg.sender.clone());
        
        // Need 2f+1 commits to finalize
        let f = (self.total_nodes - 1) / 3;
        let required = 2 * f + 1;
        
        commits.len() >= required
    }
}

fn main() {
    // 4 nodes: can tolerate 1 Byzantine fault (f=1)
    let mut node1 = PBFTNode::new(String::from("node1"), 4);
    
    // Simulate receiving prepares
    let prepare_msg = Message {
        phase: Phase::Prepare,
        view: 0,
        sequence: 1,
        block_hash: String::from("block_hash_123"),
        sender: String::from("node2"),
    };
    
    // Receive 2 prepares (need 2f = 2 for f=1)
    node1.receive_prepare(&prepare_msg);
    let mut prepare2 = prepare_msg;
    prepare2.sender = String::from("node3");
    
    if let Some(commit_msg) = node1.receive_prepare(&prepare2) {
        println!("Node1 sending commit for sequence {}", commit_msg.sequence);
        
        // Receive commits
        let mut commit1 = commit_msg.clone();
        commit1.sender = String::from("node2");
        let mut commit2 = commit_msg.clone();
        commit2.sender = String::from("node3");
        
        if node1.receive_commit(&commit_msg) {
            println!("Block finalized!");
        }
        if node1.receive_commit(&commit1) {
            println!("Block finalized!");
        }
        if node1.receive_commit(&commit2) {
            println!("Block finalized!");
        }
    }
}

enum VoteType {
    Prevote,
    Precommit,
}

struct Vote {
    vote_type: VoteType,
    height: u64,
    round: u64,
    block_hash: Option<String>,
    validator: String,
}

struct TendermintValidator {
    id: String,
    height: u64,
    round: u64,
    prevotes: Vec<Vote>,
    precommits: Vec<Vote>,
    locked_block: Option<String>,
}

impl TendermintValidator {
    fn new(id: String) -> Self {
        TendermintValidator {
            id,
            height: 1,
            round: 0,
            prevotes: Vec::new(),
            precommits: Vec::new(),
            locked_block: None,
        }
    }
    
    fn receive_prevote(&mut self, vote: Vote) -> bool {
        if vote.height == self.height && vote.round == self.round {
            self.prevotes.push(vote);
            
            // Check if we have 2/3+ prevotes for a block
            let block_votes: usize = self.prevotes
                .iter()
                .filter(|v| v.block_hash == vote.block_hash)
                .count();
            
            let total_validators = 4; // Simplified
            let required = (2 * total_validators) / 3 + 1;
            
            if block_votes >= required && vote.block_hash.is_some() {
                // Lock on this block
                self.locked_block = vote.block_hash.clone();
                return true;
            }
        }
        false
    }
    
    fn can_precommit(&self) -> bool {
        self.locked_block.is_some()
    }
    
    fn create_precommit(&self) -> Option<Vote> {
        if self.can_precommit() {
            Some(Vote {
                vote_type: VoteType::Precommit,
                height: self.height,
                round: self.round,
                block_hash: self.locked_block.clone(),
                validator: self.id.clone(),
            })
        } else {
            None
        }
    }
}

fn main() {
    let mut validator = TendermintValidator::new(String::from("validator1"));
    
    // Receive prevotes
    for i in 0..3 {
        let vote = Vote {
            vote_type: VoteType::Prevote,
            height: 1,
            round: 0,
            block_hash: Some(String::from("block123")),
            validator: format!("validator{}", i + 1),
        };
        validator.receive_prevote(vote);
    }
    
    if let Some(precommit) = validator.create_precommit() {
        println!("Validator can precommit for block: {:?}", precommit.block_hash);
        println!("Block is locked and ready to commit");
    }
}