《十二怒汉》与DAO投票机制：陪审团共识作为治理模型

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";

contract TwelveAngryMenDAO is AccessControl, ReentrancyGuard {
    bytes32 public constant JURY_ADMIN_ROLE = keccak256("JURY_ADMIN_ROLE");
    bytes32 public constant JURY_MEMBER_ROLE = keccak256("JURY_MEMBER_ROLE");

    enum VoteChoice {
        NOT_VOTED,
        GUILTY,
        NOT_GUILTY,
        ABSTAIN
    }

    enum DeliberationPhase {
        INITIAL_VOTE,
        DEBATE,
        RE_VOTE,
        FINAL_VOTE,
        CONSENSUS_REACHED,
        HUNG_JURY
    }

    enum ProposalType {
        SIMPLE_MAJORITY,
        SUPER_MAJORITY,
        UNANIMOUS,
        PLURALITY
    }

    struct Juror {
        address jurorAddress;
        string name;
        uint256 deliberationTime;
        uint256 votesCast;
        uint256 timesPersuaded;
        uint256 timesPersuadedOthers;
        uint256 reputation;
        bool isActive;
        bool isForeman;
    }

    struct DeliberationRound {
        uint256 roundId;
        uint256 guiltyVotes;
        uint256 notGuiltyVotes;
        uint256 abstainVotes;
        uint256 totalVotes;
        uint256 timestamp;
        bool isFinal;
        bytes32 deliberationHash;
    }

    struct Proposal {
        uint256 proposalId;
        address proposer;
        string title;
        string description;
        string evidenceURI;
        ProposalType proposalType;
        uint256 createdAt;
        uint256 votingDeadline;
        uint256 minVotesRequired;
        uint256 approvalThreshold;
        bool isExecuted;
        bool isPassed;
        DeliberationPhase phase;
    }

    struct Argument {
        uint256 argumentId;
        uint256 proposalId;
        address juror;
        string argumentHash;
        bool isForProposal;
        uint256 timestamp;
        uint256 persuasionScore;
    }

    mapping(address => Juror) public jurors;
    mapping(uint256 => DeliberationRound) public deliberationRounds;
    mapping(uint256 => Proposal) public proposals;
    mapping(uint256 => Argument) public arguments;
    mapping(uint256 => mapping(address => VoteChoice)) public proposalVotes;
    mapping(uint256 => address[]) public proposalVoters;

    uint256 private _roundCounter;
    uint256 private _proposalCounter;
    uint256 private _argumentCounter;
    uint256 public constant JURY_SIZE = 12;
    uint256 public constant MAX_DEBATE_TIME = 30 days;
    uint256 public constant MIN_DELIBERATION_ROUNDS = 3;
    uint256 public constant UNANIMOUS_THRESHOLD = 1200; // 12/12 = 100%

    event JurorSelected(address indexed juror, string name, uint256 timestamp);
    event VoteCast(uint256 indexed proposalId, address indexed juror, VoteChoice choice);
    event RoundCompleted(uint256 indexed roundId, uint256 guilty, uint256 notGuilty, uint256 abstain);
    event ArgumentSubmitted(uint256 indexed argumentId, uint256 indexed proposalId, address indexed juror);
    event ConsensusReached(uint256 indexed proposalId, bool passed);
    event HungJury(uint256 indexed proposalId);

    modifier onlyJuror() {
        require(jurors[msg.sender].isActive, "Not an active juror");
        _;
    }

    constructor() {
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _grantRole(JURY_ADMIN_ROLE, msg.sender);
    }

    function selectJuror(address _juror, string memory _name) external onlyRole(JURY_ADMIN_ROLE) {
        require(!jurors[_juror].isActive, "Already a juror");
        require(_getActiveJurorCount() < JURY_SIZE, "Jury is full");

        jurors[_juror] = Juror({
            jurorAddress: _juror,
            name: _name,
            deliberationTime: 0,
            votesCast: 0,
            timesPersuaded: 0,
            timesPersuadedOthers: 0,
            reputation: 100,
            isActive: true,
            isForeman: _getActiveJurorCount() == 0
        });

        _grantRole(JURY_MEMBER_ROLE, _juror);

        emit JurorSelected(_juror, _name, block.timestamp);
    }

    function createProposal(
        string memory _title,
        string memory _description,
        string memory _evidenceURI,
        ProposalType _proposalType,
        uint256 _votingDuration
    ) external returns (uint256) {
        _proposalCounter++;
        uint256 proposalId = _proposalCounter;

        uint256 approvalThreshold;
        if (_proposalType == ProposalType.UNANIMOUS) {
            approvalThreshold = UNANIMOUS_THRESHOLD;
        } else if (_proposalType == ProposalType.SUPER_MAJORITY) {
            approvalThreshold = 667; // 2/3
        } else {
            approvalThreshold = 501; // 简单多数
        }

        proposals[proposalId] = Proposal({
            proposalId: proposalId,
            proposer: msg.sender,
            title: _title,
            description: _description,
            evidenceURI: _evidenceURI,
            proposalType: _proposalType,
            createdAt: block.timestamp,
            votingDeadline: block.timestamp + _votingDuration,
            minVotesRequired: JURY_SIZE,
            approvalThreshold: approvalThreshold,
            isExecuted: false,
            isPassed: false,
            phase: DeliberationPhase.INITIAL_VOTE
        });

        // 开始第一轮投票
        _startDeliberationRound(proposalId);

        return proposalId;
    }

    function castVote(
        uint256 _proposalId,
        VoteChoice _choice
    ) external onlyJuror {
        Proposal storage proposal = proposals[_proposalId];
        require(block.timestamp < proposal.votingDeadline, "Voting ended");
        require(proposalVotes[_proposalId][msg.sender] == VoteChoice.NOT_VOTED, "Already voted");
        require(_choice != VoteChoice.NOT_VOTED, "Invalid choice");
        require(proposal.phase != DeliberationPhase.CONSENSUS_REACHED, "Consensus reached");

        proposalVotes[_proposalId][msg.sender] = _choice;
        proposalVoters[_proposalId].push(msg.sender);

        emit VoteCast(_proposalId, msg.sender, _choice);
    }

    function submitArgument(
        uint256 _proposalId,
        string memory _argumentHash,
        bool _isForProposal
    ) external onlyJuror returns (uint256) {
        _argumentCounter++;
        uint256 argumentId = _argumentCounter;

        arguments[argumentId] = Argument({
            argumentId: argumentId,
            proposalId: _proposalId,
            juror: msg.sender,
            argumentHash: _argumentHash,
            isForProposal: _isForProposal,
            timestamp: block.timestamp,
            persuasionScore: 0
        });

        emit ArgumentSubmitted(argumentId, _proposalId, msg.sender);
        return argumentId;
    }

    function completeRound(uint256 _proposalId) external onlyJuror {
        Proposal storage proposal = proposals[_proposalId];
        require(proposal.phase != DeliberationPhase.CONSENSUS_REACHED, "Consensus reached");

        _roundCounter++;
        uint256 roundId = _roundCounter;

        uint256 guilty = 0;
        uint256 notGuilty = 0;
        uint256 abstain = 0;

        address[] memory voters = proposalVoters[_proposalId];
        for (uint256 i = 0; i < voters.length; i++) {
            VoteChoice choice = proposalVotes[_proposalId][voters[i]];
            if (choice == VoteChoice.GUILTY) guilty++;
            else if (choice == VoteChoice.NOT_GUILTY) notGuilty++;
            else if (choice == VoteChoice.ABSTAIN) abstain++;
        }

        deliberationRounds[roundId] = DeliberationRound({
            roundId: roundId,
            guiltyVotes: guilty,
            notGuiltyVotes: notGuilty,
            abstainVotes: abstain,
            totalVotes: guilty + notGuilty + abstain,
            timestamp: block.timestamp,
            isFinal: false,
            deliberationHash: keccak256(abi.encodePacked(roundId, guilty, notGuilty, abstain))
        });

        emit RoundCompleted(roundId, guilty, notGuilty, abstain);

        // 检查是否达成共识
        _checkConsensus(_proposalId, roundId);
    }

    function _checkConsensus(uint256 _proposalId, uint256 _roundId) internal {
        Proposal storage proposal = proposals[_proposalId];
        DeliberationRound storage round = deliberationRounds[_roundId];

        uint256 totalVotes = round.guiltyVotes + round.notGuiltyVotes;
        uint256 notGuiltyPercent = totalVotes > 0 ? (round.notGuiltyVotes * 10000) / totalVotes : 0;

        // 全票一致
        if (notGuiltyPercent == 0 || notGuiltyPercent == 10000) {
            proposal.phase = DeliberationPhase.CONSENSUS_REACHED;
            proposal.isPassed = (notGuiltyPercent == 10000);
            round.isFinal = true;

            // 更新陪审员声誉
            _updateReputations(_proposalId);

            emit ConsensusReached(_proposalId, proposal.isPassed);
        }
        // 僵局（超过3轮投票）
        else if (_roundCounter >= _getActiveJurorCount()) {
            proposal.phase = DeliberationPhase.HUNG_JURY;
            emit HungJury(_proposalId);
        }
        else {
            proposal.phase = DeliberationPhase.DE_BATE;
        }
    }

    function _updateReputations(uint256 _proposalId) internal {
        address[] memory voters = proposalVoters[_proposalId];
        uint256 guilty = 0;
        uint256 notGuilty = 0;

        for (uint256 i = 0; i < voters.length; i++) {
            VoteChoice choice = proposalVotes[_proposalId][voters[i]];
            if (choice == VoteChoice.GUILTY) guilty++;
            else if (choice == VoteChoice.NOT_GUILTY) notGuilty++;
        }

        // 如果最终共识是"无罪"，投票"无罪"的陪审员获得声誉加分
        bool consensusNotGuilty = notGuilty > guilty;
        for (uint256 i = 0; i < voters.length; i++) {
            VoteChoice choice = proposalVotes[_proposalId][voters[i]];
            Juror storage juror = jurors[voters[i]];

            if (consensusNotGuilty && choice == VoteChoice.NOT_GUILTY) {
                juror.reputation += 10;
            } else if (!consensusNotGuilty && choice == VoteChoice.GUILTY) {
                juror.reputation += 10;
            } else {
                juror.reputation = juror.reputation > 5 ? juror.reputation - 5 : 0;
            }
        }
    }

    function _getActiveJurorCount() internal view returns (uint256) {
        uint256 count = 0;
        // In a real implementation, we would iterate through a mapping
        // For simplicity, we assume the count is tracked
        return count;
    }

    function _startDeliberationRound(uint256 _proposalId) internal {
        Proposal storage proposal = proposals[_proposalId];
        proposal.phase = DeliberationPhase.INITIAL_VOTE;
    }

    function getJurorInfo(address _juror) external view returns (Juror memory) {
        return jurors[_juror];
    }

    function getProposalStatus(uint256 _proposalId) external view returns (Proposal memory) {
        return proposals[_proposalId];
    }

    function getRoundResults(uint256 _roundId) external view returns (DeliberationRound memory) {
        return deliberationRounds[_roundId];
    }

    function getVoteDistribution(uint256 _proposalId) external view returns (uint256 guilty, uint256 notGuilty, uint256 abstain) {
        address[] memory voters = proposalVoters[_proposalId];
        for (uint256 i = 0; i < voters.length; i++) {
            VoteChoice choice = proposalVotes[_proposalId][voters[i]];
            if (choice == VoteChoice.GUILTY) guilty++;
            else if (choice == VoteChoice.NOT_GUILTY) notGuilty++;
            else if (choice == VoteChoice.ABSTAIN) abstain++;
        }
        return (guilty, notGuilty, abstain);
    }
}

import json
import time
import hashlib
import random
from dataclasses import dataclass
from typing import Dict, List, Optional, Tuple
from enum import Enum

class VoteChoice(Enum):
    GUILTY = "guilty"
    NOT_GUILTY = "not_guilty"
    ABSTAIN = "abstain"

class DeliberationPhase(Enum):
    INITIAL_VOTE = "initial_vote"
    DEBATE = "debate"
    RE_VOTE = "re_vote"
    CONSENSUS = "consensus_reached"
    HUNG_JURY = "hung_jury"

class ProposalType(Enum):
    SIMPLE = "simple_majority"
    SUPER = "super_majority"
    UNANIMOUS = "unanimous"
    PLURALITY = "plurality"

@dataclass
class Juror:
    address: str
    name: str
    vote: VoteChoice
    initial_vote: VoteChoice
    times_persuaded: int
    persuasion_power: float
    reputation: int
    is_foreman: bool

@dataclass
class Round:
    round_id: int
    guilty: int
    not_guilty: int
    abstain: int
    timestamp: int

@dataclass
class DAOProposal:
    proposal_id: int
    title: str
    description: str
    proposer: str
    proposal_type: ProposalType
    phase: DeliberationPhase
    created_at: int
    deadline: int
    passed: bool


class TwelveAngryMenDAO:
    """
    《十二怒汉》DAO投票模拟器
    """

    def __init__(self):
        self.jurors: Dict[str, Juror] = {}
        self.proposals: Dict[int, DAOProposal] = {}
        self.rounds: Dict[int, List[Round]] = {}
        self.proposal_counter = 0
        self.round_counter = 0
        self.jury_size = 12

    def _hash(self, *args) -> str:
        return hashlib.sha256(":".join(str(a) for a in args).encode()).hexdigest()

    def select_jury(self, names: List[str]) -> None:
        if len(names) != self.jury_size:
            raise ValueError(f"需要 {self.jury_size} 名陪审员")

        for i, name in enumerate(names):
            addr = self._hash(name, "juror")
            self.jurors[addr] = Juror(
                address=addr,
                name=name,
                vote=VoteChoice.NOT_VOTED,
                initial_vote=VoteChoice.NOT_VOTED,
                times_persuaded=0,
                persuasion_power=random.uniform(0.5, 1.0),
                reputation=100,
                is_foreman=(i == 0)
            )

        print(f"[陪审团] 已选择 {self.jury_size} 名陪审员")
        for j in self.jurors.values():
            print(f"  {j.name}: {'主审官' if j.is_foreman else '陪审员'}")

    def create_proposal(
        self,
        title: str,
        description: str,
        proposer: str,
        proposal_type: ProposalType = ProposalType.UNANIMOUS,
        duration: int = 86400
    ) -> int:
        self.proposal_counter += 1
        proposal_id = self.proposal_counter

        proposal = DAOProposal(
            proposal_id=proposal_id,
            title=title,
            description=description,
            proposer=proposer,
            proposal_type=proposal_type,
            phase=DeliberationPhase.INITIAL_VOTE,
            created_at=int(time.time()),
            deadline=int(time.time()) + duration,
            passed=False
        )

        self.proposals[proposal_id] = proposal
        self.rounds[proposal_id] = []

        print(f"[提案] #{proposal_id}: {title}")
        print(f"  描述: {description[:50]}...")
        print(f"  类型: {proposal_type.value}")

        return proposal_id

    def initial_vote(self, proposal_id: int) -> Dict:
        """第一轮投票"""
        if proposal_id not in self.proposals:
            raise ValueError(f"提案 #{proposal_id} 不存在")

        proposal = self.proposals[proposal_id]
        proposal.phase = DeliberationPhase.INITIAL_VOTE

        # 模拟12陪審员的初始投票
        for juror in self.jurors.values():
            # 基于陪审员的"偏见"和"理性"生成初始投票
            bias = random.random()
            if bias < 0.8:  # 80%的人初始投票"有罪"
                juror.vote = VoteChoice.GUILTY
            else:
                juror.vote = VoteChoice.NOT_GUILTY
            juror.initial_vote = juror.vote

        results = self._record_round(proposal_id)
        print(f"[第一轮投票] 结果: 有罪={results['guilty']}, 无罪={results['not_guilty']}, 弃权={results['abstain']}")

        return results

    def debate(self, proposal_id: int, persuader: str, target: str, argument: str) -> Dict:
        """辩论环节：一位陪审员说服另一位"""
        if persuader not in self.jurors or target not in self.jurors:
            raise ValueError("陪审员不存在")

        persuader_j = self.jurors[persuader]
        target_j = self.jurors[target]

        # 计算说服概率
        base_persuasion = persuader_j.persuasion_power
        target_resistance = 1.0 - (target_j.reputation / 100.0)
        persuasion_chance = base_persuasion * (1 - target_resistance)

        # 如果说服者持有"无罪"立场，说服力增加
        if persuader_j.vote == VoteChoice.NOT_GUILTY:
            persuasion_chance *= 1.2

        success = random.random() < persuasion_chance

        if success:
            old_vote = target_j.vote
            target_j.vote = persuader_j.vote
            target_j.times_persuaded += 1
            print(f"[辩论] {persuader_j.name} 说服了 {target_j.name}: {old_vote.value} → {target_j.vote.value}")
        else:
            print(f"[辩论] {persuader_j.name} 未能说服 {target_j.name}")

        return {
            "persuader": persuader_j.name,
            "target": target_j.name,
            "argument": argument,
            "success": success,
            "current_votes": self._get_vote_distribution(proposal_id)
        }

    def re_vote(self, proposal_id: int) -> Dict:
        """重新投票"""
        if proposal_id not in self.proposals:
            raise ValueError(f"提案 #{proposal_id} 不存在")

        proposal = self.proposals[proposal_id]
        proposal.phase = DeliberationPhase.RE_VOTE

        results = self._record_round(proposal_id)
        print(f"[重新投票] 结果: 有罪={results['guilty']}, 无罪={results['not_guilty']}, 弃权={results['abstain']}")

        # 检查共识
        if results['guilty'] == 0 or results['not_guilty'] == 0:
            proposal.phase = DeliberationPhase.CONSENSUS
            proposal.passed = (results['not_guilty'] == self.jury_size)
            print(f"[共识达成] {'无罪' if proposal.passed else '有罪'}")
        elif self.round_counter >= 6:
            proposal.phase = DeliberationPhase.HUNG_JURY
            print(f"[僵局] 无法达成共识")

        return results

    def _record_round(self, proposal_id: int) -> Dict:
        """记录一轮投票结果"""
        self.round_counter += 1
        round_id = self.round_counter

        guilty = sum(1 for j in self.jurors.values() if j.vote == VoteChoice.GUILTY)
        not_guilty = sum(1 for j in self.jurors.values() if j.vote == VoteChoice.NOT_GUILTY)
        abstain = sum(1 for j in self.jurors.values() if j.vote == VoteChoice.ABSTAIN)

        round_data = Round(
            round_id=round_id,
            guilty=guilty,
            not_guilty=not_guilty,
            abstain=abstain,
            timestamp=int(time.time())
        )

        if proposal_id not in self.rounds:
            self.rounds[proposal_id] = []
        self.rounds[proposal_id].append(round_data)

        return {
            "round_id": round_id,
            "guilty": guilty,
            "not_guilty": not_guilty,
            "abstain": abstain,
            "total": guilty + not_guilty + abstain
        }

    def _get_vote_distribution(self, proposal_id: int) -> Dict:
        guilty = sum(1 for j in self.jurors.values() if j.vote == VoteChoice.GUILTY)
        not_guilty = sum(1 for j in self.jurors.values() if j.vote == VoteChoice.NOT_GUILTY)
        abstain = sum(1 for j in self.jurors.values() if j.vote == VoteChoice.ABSTAIN)

        return {
            "guilty": guilty,
            "not_guilty": not_guilty,
            "abstain": abstain,
            "total": guilty + not_guilty + abstain
        }

    def get_deliberation_timeline(self, proposal_id: int) -> List[Dict]:
        if proposal_id not in self.rounds:
            return []

        timeline = []
        for i, round_data in enumerate(self.rounds[proposal_id]):
            timeline.append({
                "round": i + 1,
                "guilty": round_data.guilty,
                "not_guilty": round_data.not_guilty,
                "abstain": round_data.abstain,
                "trend": "→ 无罪" if round_data.not_guilty > round_data.guilty else "→ 有罪",
                "time": time.strftime("%H:%M:%S", time.gmtime(round_data.timestamp))
            })

        return timeline

    def simulate_12_angry_men(self) -> Dict:
        """
        模拟《十二怒汉》的完整陪审团过程
        """
        print(f"\n{'='*60}")
        print(f"  《十二怒汉》DAO投票模拟")
        print(f"  陪审团共识作为治理模型")
        print(f"{'='*60}\n")

        # 1. 选择陪审团
        print(">>> 1. 选择陪审团\n")
        juror_names = [
            "主审官（法官）", "8号陪审员", "3号陪审员",
            "4号陪审员", "5号陪审员", "6号陪审员",
            "7号陪审员", "9号陪审员", "10号陪审员",
            "11号陪审员", "2号陪审员", "12号陪审员"
        ]
        self.select_jury(juror_names)

        # 2. 创建提案
        print("\n>>> 2. 创建提案\n")
        proposal_id = self.create_proposal(
            title="被告人是否有罪？",
            description="18岁男孩被指控谋杀父亲，需要12名陪审员一致决定是否有罪",
            proposer="法官",
            proposal_type=ProposalType.UNANIMOUS
        )

        # 3. 第一轮投票（11:1有罪）
        print("\n>>> 3. 第一轮投票\n")
        vote1 = self.initial_vote(proposal_id)

        # 强制设定为11:1（模拟电影）
        for j in self.jurors.values():
            if j.name == "8号陪审员":
                j.vote = VoteChoice.NOT_GUILTY
            else:
                j.vote = VoteChoice.GUILTY
        vote1 = self._record_round(proposal_id)
        print(f"  [模拟电影] 强制设定: 有罪=11, 无罪=1（8号陪审员）")

        # 4. 辩论环节
        print("\n>>> 4. 辩论环节\n")

        # 8号陪审员逐一说服其他陪审员
        persuader = [j for j in self.jurors.values() if j.name == "8号陪审员"][0]

        # 说服9号
        target9 = [j for j in self.jurors.values() if j.name == "9号陪审员"][0]
        self.debate(proposal_id, persuader.address, target9.address, "存在合理怀疑")

        # 重新投票
        vote2 = self.re_vote(proposal_id)
        # 强制10:2
        for j in self.jurors.values():
            if j.name in ["8号陪审员", "9号陪审员"]:
                j.vote = VoteChoice.NOT_GUILTY
            else:
                j.vote = VoteChoice.GUILTY
        vote2 = self._record_round(proposal_id)
        print(f"  [模拟] 10:2（8号和9号投无罪）")

        # 继续说服
        target5 = [j for j in self.jurors.values() if j.name == "5号陪审员"][0]
        self.debate(proposal_id, persuader.address, target5.address, "证人的证词不可靠")

        target11 = [j for j in self.jurors.values() if j.name == "11号陪审员"][0]
        self.debate(proposal_id, persuader.address, target11.address, "刀子的证据有问题")

        vote3 = self.re_vote(proposal_id)
        for j in self.jurors.values():
            if j.name in ["8号陪审员", "9号陪审员", "5号陪审员", "11号陪审员"]:
                j.vote = VoteChoice.NOT_GUILTY
            else:
                j.vote = VoteChoice.GUILTY
        vote3 = self._record_round(proposal_id)
        print(f"  [模拟] 8:4")

        # 继续...
        for target_name in ["2号陪审员", "6号陪审员", "12号陪审员", "4号陪审员", "7号陪审员", "10号陪审员"]:
            t = [j for j in self.jurors.values() if j.name == target_name]
            if t:
                self.debate(proposal_id, persuader.address, t[0].address, "逻辑推理")

        vote4 = self.re_vote(proposal_id)
        for j in self.jurors.values():
            if j.name not in ["3号陪审员"]:
                j.vote = VoteChoice.NOT_GUILTY
            else:
                j.vote = VoteChoice.GUILTY
        vote4 = self._record_round(proposal_id)
        print(f"  [模拟] 1:11（只有3号坚持有罪）")

        # 最终说服3号
        target3 = [j for j in self.jurors.values() if j.name == "3号陪审员"][0]
        self.debate(proposal_id, persuader.address, target3.address, "撕碎儿子的照片不代表有罪")

        vote5 = self.re_vote(proposal_id)
        for j in self.jurors.values():
            j.vote = VoteChoice.NOT_GUILTY
        vote5 = self._record_round(proposal_id)
        print(f"  [模拟] 0:12 全票无罪！共识达成")

        # 5. 投票时间线
        print("\n>>> 5. 投票时间线\n")
        timeline = self.get_deliberation_timeline(proposal_id)
        for t in timeline:
            print(f"  第{t['round']}轮: 有罪={t['guilty']}, 无罪={t['not_guilty']} {t['trend']}")

        # 6. DAO治理模型分析
        print("\n>>> 6. DAO治理模型分析\n")
        print(f"  《十二怒汉》→ DAO投票机制映射")
        print(f"  {'陪审团要素':<20} {'DAO投票机制':<20}")
        print(f"  {'-'*20} {'-'*20}")
        print(f"  {'12名陪审员':<20} {'12个投票地址':<20}")
        print(f"  {'主审官':<20} {'DAO管理员':<20}")
        print(f"  {'8号陪审员':<20} {'提案人':<20}")
        print(f"  {'举证':<20} {'提案论证':<20}")
        print(f"  {'辩论':<20} {'社区讨论':<20}")
        print(f"  {'重新投票':<20} {'快照投票':<20}")
        print(f"  {'全票一致':<20} {'超级多数':<20}")
        print(f"  {'合理怀疑':<20} {'反对票理由':<20}")

        print(f"\n{'='*60}")
        print(f"  模拟完成：从11:1到0:12")
        print(f"{'='*60}")

        return {
            "proposal_id": proposal_id,
            "total_rounds": len(self.rounds.get(proposal_id, [])),
            "final_vote": "0:12 全票无罪",
            "consensus_reached": True,
            "jurors_count": len(self.jurors)
        }


def main():
    dao = TwelveAngryMenDAO()
    result = dao.simulate_12_angry_men()

    print(f"\n=== 模拟结果 ===")
    print(f"提案: #{result['proposal_id']}")
    print(f"投票轮数: {result['total_rounds']}")
    print(f"最终结果: {result['final_vote']}")
    print(f"共识达成: {result['consensus_reached']}")


if __name__ == "__main__":
    main()