Session 4.2 - DAO Concepts

pragma solidity ^0.8.0;

contract SimpleDAO {
    struct Proposal {
        uint256 id;
        string description;
        uint256 amount;
        address payable recipient;
        uint256 votes;
        uint256 deadline;
        bool executed;
        mapping(address => bool) voted;
    }
    
    mapping(uint256 => Proposal) public proposals;
    mapping(address => uint256) public shares;
    uint256 public totalShares;
    uint256 public proposalCount;
    uint256 public constant VOTING_PERIOD = 7 days;
    
    event ProposalCreated(uint256 proposalId, string description);
    event Voted(uint256 proposalId, address voter, uint256 shares);
    event ProposalExecuted(uint256 proposalId);
    
    modifier onlyMember() {
        require(shares[msg.sender] > 0, "Not a DAO member");
        _;
    }
    
    function joinDAO() external payable {
        require(msg.value > 0, "Must contribute ETH");
        shares[msg.sender] += msg.value;
        totalShares += msg.value;
    }
    
    function createProposal(
        string memory _description,
        uint256 _amount,
        address payable _recipient
    ) external onlyMember returns (uint256) {
        proposalCount++;
        Proposal storage newProposal = proposals[proposalCount];
        newProposal.id = proposalCount;
        newProposal.description = _description;
        newProposal.amount = _amount;
        newProposal.recipient = _recipient;
        newProposal.deadline = block.timestamp + VOTING_PERIOD;
        
        emit ProposalCreated(proposalCount, _description);
        return proposalCount;
    }
    
    function vote(uint256 _proposalId) external onlyMember {
        Proposal storage proposal = proposals[_proposalId];
        require(block.timestamp < proposal.deadline, "Voting period ended");
        require(!proposal.voted[msg.sender], "Already voted");
        require(!proposal.executed, "Proposal already executed");
        
        proposal.voted[msg.sender] = true;
        proposal.votes += shares[msg.sender];
        
        emit Voted(_proposalId, msg.sender, shares[msg.sender]);
    }
    
    function executeProposal(uint256 _proposalId) external {
        Proposal storage proposal = proposals[_proposalId];
        require(block.timestamp >= proposal.deadline, "Voting still active");
        require(!proposal.executed, "Already executed");
        require(proposal.votes > totalShares / 2, "Insufficient votes");
        require(address(this).balance >= proposal.amount, "Insufficient funds");
        
        proposal.executed = true;
        proposal.recipient.transfer(proposal.amount);
        
        emit ProposalExecuted(_proposalId);
    }
    
    function getProposal(uint256 _proposalId) external view returns (
        string memory description,
        uint256 amount,
        address recipient,
        uint256 votes,
        uint256 deadline,
        bool executed
    ) {
        Proposal storage proposal = proposals[_proposalId];
        return (
            proposal.description,
            proposal.amount,
            proposal.recipient,
            proposal.votes,
            proposal.deadline,
            proposal.executed
        );
    }
}