┌─────────────────────────────────────────────────────────────────────────────┐
│                    GOVERNMENT CHALLENGES ADDRESSED BY BLOCKCHAIN            │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    BUREAUCRACY & INEFFICIENCY                       │   │
│  │  Slow, paper-heavy processes with multiple layers of approval.      │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    CORRUPTION & FRAUD                               │   │
│  │  Vulnerable to manipulation in procurement, voting, and records.    │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    DATA SILOS                                       │   │
│  │  Government departments operate in isolation with limited sharing.  │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    IDENTITY & AUTHENTICATION                        │   │
│  │  Fragmented identity systems, fraud, and identity theft.            │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    LACK OF TRANSPARENCY                             │   │
│  │  Citizens have limited visibility into government operations.       │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                    BLOCKCHAIN CITIZEN IDENTITY                              │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    CITIZEN                                           │   │
│  │  • Owns DID (Decentralised Identifier)                              │   │
│  │  • Controls personal data                                          │   │
│  │  • Grants consent for data sharing                                 │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    VERIFIABLE CREDENTIALS                            │   │
│  │  • Birth certificate                                                │   │
│  │  • National ID                                                       │   │
│  │  • Driver's license                                                 │   │
│  │  • Tax records                                                       │   │
│  │  • Education credentials                                            │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                    ┌───────────────┼───────────────┐                      │
│                    v               v               v                      │
│  ┌──────────────────┐  ┌──────────────────┐  ┌──────────────────┐        │
│  │  Government      │  │  Healthcare      │  │  Financial       │        │
│  │  • Verify ID     │  │  • Health records│  │  • KYC/AML      │        │
│  │  • Issue docs    │  │  • Insurance     │  │  • Banking      │        │
│  └──────────────────┘  └──────────────────┘  └──────────────────┘        │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

# ===================================================================
# MODULE 3, LESSON 7: GOVERNMENT AND PUBLIC SERVICES
# ===================================================================

import hashlib
import time
import random
from typing import Dict, List, Optional, Tuple
from datetime import datetime, timedelta
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
import seaborn as sns
import warnings
warnings.filterwarnings('ignore')

print("="*70)
print("GOVERNMENT AND PUBLIC SERVICES – BLOCKCHAIN APPLICATIONS")
print("="*70)

# ----------------------------------------------------------------
# PART A: CITIZEN IDENTITY SYSTEM
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART A: Blockchain Citizen Identity System")
print("-"*60)

class CitizenIdentity:
    """
    Simulated citizen identity on blockchain.
    """
    def __init__(self, citizen_id: str, name: str, date_of_birth: str):
        self.citizen_id = citizen_id
        self.name = name
        self.date_of_birth = date_of_birth
        self.credentials: List[Dict] = []
        self.verifications: List[Dict] = []
        self.created_at = datetime.now()
        self.did = f"did:gov:{citizen_id}"
    
    def issue_credential(self, credential_type: str, data: Dict, issuer: str) -> Dict:
        """Issue a verifiable credential to the citizen."""
        credential = {
            'id': f'CRED-{len(self.credentials)+1:06d}',
            'type': credential_type,
            'data': data,
            'issuer': issuer,
            'issued_at': datetime.now(),
            'valid_until': datetime.now() + timedelta(days=730),
            'hash': hashlib.sha256(f"{self.citizen_id}{credential_type}{json.dumps(data)}{time.time()}".encode()).hexdigest()[:16],
            'active': True
        }
        self.credentials.append(credential)
        print(f"Credential issued: {credential_type} for {self.name}")
        return credential
    
    def verify_credential(self, credential_id: str) -> bool:
        """Verify a credential."""
        credential = next((c for c in self.credentials if c['id'] == credential_id), None)
        if not credential:
            return False
        if not credential['active']:
            return False
        if credential['valid_until'] < datetime.now():
            return False
        return True
    
    def revoke_credential(self, credential_id: str) -> bool:
        """Revoke a credential."""
        credential = next((c for c in self.credentials if c['id'] == credential_id), None)
        if not credential:
            return False
        credential['active'] = False
        print(f"Credential {credential_id} revoked")
        return True
    
    def get_active_credentials(self) -> List[Dict]:
        """Get all active credentials."""
        return [c for c in self.credentials if c['active'] and c['valid_until'] > datetime.now()]
    
    def get_summary(self) -> Dict:
        return {
            'citizen_id': self.citizen_id,
            'name': self.name,
            'did': self.did,
            'total_credentials': len(self.credentials),
            'active_credentials': len(self.get_active_credentials()),
            'created_at': self.created_at
        }

# Create citizens
print("Creating citizen identities...")
citizen1 = CitizenIdentity('CIT-0001', 'John Smith', '1985-03-15')
citizen2 = CitizenIdentity('CIT-0002', 'Maria Garcia', '1990-07-22')
citizen3 = CitizenIdentity('CIT-0003', 'David Kim', '1978-11-03')

# Issue credentials
print("\nIssuing government credentials...")
citizen1.issue_credential('National ID', {'number': 'NID-123456', 'expiry': '2030-01-01'}, 'Gov_Agency')
citizen1.issue_credential('Passport', {'number': 'P-987654', 'country': 'USA', 'expiry': '2029-06-01'}, 'Gov_Agency')
citizen1.issue_credential('Drivers License', {'number': 'D-456789', 'class': 'C', 'expiry': '2027-08-15'}, 'DMV')

citizen2.issue_credential('National ID', {'number': 'NID-789012', 'expiry': '2030-05-01'}, 'Gov_Agency')
citizen2.issue_credential('Social Security', {'number': 'SSN-456789', 'status': 'Active'}, 'Gov_Agency')

citizen3.issue_credential('National ID', {'number': 'NID-345678', 'expiry': '2029-12-01'}, 'Gov_Agency')

print("\nCitizen Summaries:")
for citizen in [citizen1, citizen2, citizen3]:
    summary = citizen.get_summary()
    print(f"  {summary['name']}: {summary['active_credentials']} active credentials")

# ----------------------------------------------------------------
# PART B: BLOCKCHAIN VOTING SYSTEM
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART B: Blockchain Voting System Simulation")
print("-"*60)

class Voter:
    def __init__(self, voter_id: str, name: str, eligible: bool = True):
        self.voter_id = voter_id
        self.name = name
        self.eligible = eligible
        self.has_voted = False
        self.vote_hash = None
        self.voting_power = 1 if eligible else 0
    
    def cast_vote(self, candidate: str, election_id: str) -> Dict:
        if not self.eligible:
            return {'error': 'Not eligible to vote'}
        if self.has_voted:
            return {'error': 'Already voted'}
        
        self.has_voted = True
        self.vote_hash = hashlib.sha256(f"{self.voter_id}{candidate}{election_id}{time.time()}".encode()).hexdigest()[:16]
        
        return {
            'voter_id': self.voter_id,
            'candidate': candidate,
            'election_id': election_id,
            'vote_hash': self.vote_hash,
            'timestamp': datetime.now()
        }

class BlockchainVote:
    def __init__(self, election_id: str, election_name: str, candidates: List[str]):
        self.election_id = election_id
        self.election_name = election_name
        self.candidates = candidates
        self.votes: List[Dict] = []
        self.voter_hashes: List[str] = []
        self.start_time = datetime.now()
        self.end_time = datetime.now() + timedelta(days=1)
        self.total_eligible_voters = 0
        self.total_registered_voters = 0
    
    def register_voter(self, voter: Voter) -> bool:
        if not voter.eligible:
            return False
        self.total_eligible_voters += 1
        print(f"Voter {voter.name} registered for {self.election_name}")
        return True
    
    def cast_ballot(self, voter: Voter, candidate: str) -> Dict:
        if datetime.now() > self.end_time:
            return {'error': 'Voting period has ended'}
        if candidate not in self.candidates:
            return {'error': 'Invalid candidate'}
        
        result = voter.cast_vote(candidate, self.election_id)
        if 'error' in result:
            return result
        
        # Record vote on blockchain (immutable)
        vote_record = {
            'election_id': self.election_id,
            'candidate': candidate,
            'voter_hash': hashlib.sha256(voter.voter_id.encode()).hexdigest()[:16],  # Anonymised
            'vote_hash': voter.vote_hash,
            'timestamp': datetime.now()
        }
        self.votes.append(vote_record)
        self.voter_hashes.append(voter.vote_hash)
        self.total_registered_voters += 1
        
        print(f"Vote cast by {voter.name} for {candidate}")
        return result
    
    def tally_votes(self) -> Dict[str, int]:
        """Count votes for each candidate."""
        tally = {candidate: 0 for candidate in self.candidates}
        for vote in self.votes:
            tally[vote['candidate']] += 1
        return tally
    
    def get_voter_turnout(self) -> float:
        if self.total_eligible_voters == 0:
            return 0
        return self.total_registered_voters / self.total_eligible_voters
    
    def get_results(self) -> Dict:
        tally = self.tally_votes()
        total_votes = sum(tally.values())
        results = {
            'election_id': self.election_id,
            'election_name': self.election_name,
            'total_votes': total_votes,
            'voter_turnout': self.get_voter_turnout(),
            'candidates': {},
            'winner': None
        }
        
        for candidate, count in tally.items():
            pct = (count / total_votes) * 100 if total_votes > 0 else 0
            results['candidates'][candidate] = {
                'votes': count,
                'percentage': pct
            }
        
        if tally:
            winner = max(tally, key=tally.get)
            results['winner'] = winner
        
        return results

# Create election
print("Creating blockchain election...")
election = BlockchainVote(
    election_id='EL-2024-001',
    election_name='City Council Election 2024',
    candidates=['Candidate_A', 'Candidate_B', 'Candidate_C']
)

print(f"Election: {election.election_name}")
print(f"Candidates: {', '.join(election.candidates)}")

# Create voters
voters = [
    Voter('V001', 'Alice Johnson', True),
    Voter('V002', 'Bob Smith', True),
    Voter('V003', 'Charlie Brown', True),
    Voter('V004', 'Diana Ross', True),
    Voter('V005', 'Eve Wilson', False),  # Not eligible
    Voter('V006', 'Frank Davis', True),
    Voter('V007', 'Grace Lee', True)
]

# Register voters
print("\nRegistering voters...")
for voter in voters:
    election.register_voter(voter)

# Cast votes
print("\nCasting votes...")
# Simulate voting
vote_choices = [
    ('Candidate_A', ['V001', 'V003', 'V006']),
    ('Candidate_B', ['V002', 'V004']),
    ('Candidate_C', ['V007'])
]

for candidate, voter_ids in vote_choices:
    for voter_id in voter_ids:
        voter = next((v for v in voters if v.voter_id == voter_id), None)
        if voter:
            election.cast_ballot(voter, candidate)

# Get results
print("\nElection Results:")
results = election.get_results()
print(f"  Total Votes: {results['total_votes']}")
print(f"  Voter Turnout: {results['voter_turnout']:.1%}")
print("\n  Candidates:")
for candidate, data in results['candidates'].items():
    print(f"    {candidate}: {data['votes']} votes ({data['percentage']:.1f}%)")
print(f"\n  Winner: {results['winner']}")

# ----------------------------------------------------------------
# PART C: LAND REGISTRY SYSTEM
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART C: Blockchain Land Registry")
print("-"*60)

class LandRecord:
    def __init__(self, land_id: str, location: str, area: float, owner: str):
        self.land_id = land_id
        self.location = location
        self.area = area
        self.owner = owner
        self.created_at = datetime.now()
        self.transfer_history: List[Dict] = []
        self.hash = hashlib.sha256(f"{land_id}{location}{area}{owner}{time.time()}".encode()).hexdigest()[:16]
        self.status = 'Active'
        
        # Initial registration record
        self.add_transfer(owner, 'Registration')
    
    def add_transfer(self, new_owner: str, reason: str) -> Dict:
        transfer = {
            'from_owner': self.owner,
            'to_owner': new_owner,
            'reason': reason,
            'timestamp': datetime.now(),
            'transfer_hash': hashlib.sha256(f"{self.land_id}{self.owner}{new_owner}{time.time()}".encode()).hexdigest()[:16]
        }
        self.transfer_history.append(transfer)
        self.owner = new_owner
        self.hash = hashlib.sha256(f"{self.land_id}{self.location}{self.area}{self.owner}{time.time()}".encode()).hexdigest()[:16]
        print(f"Land {self.land_id} transferred to {new_owner} ({reason})")
        return transfer
    
    def get_provenance(self) -> List[Dict]:
        return self.transfer_history
    
    def get_summary(self) -> Dict:
        return {
            'land_id': self.land_id,
            'location': self.location,
            'area': self.area,
            'current_owner': self.owner,
            'status': self.status,
            'transfers': len(self.transfer_history),
            'hash': self.hash
        }

class LandRegistry:
    def __init__(self, jurisdiction: str):
        self.jurisdiction = jurisdiction
        self.records: List[LandRecord] = []
        self.disputes: List[Dict] = []
    
    def register_land(self, land_id: str, location: str, area: float, owner: str) -> LandRecord:
        record = LandRecord(land_id, location, area, owner)
        self.records.append(record)
        print(f"Land registered: {land_id} in {location}")
        return record
    
    def transfer_ownership(self, land_id: str, new_owner: str, reason: str) -> bool:
        record = next((r for r in self.records if r.land_id == land_id), None)
        if not record:
            print(f"Land {land_id} not found")
            return False
        record.add_transfer(new_owner, reason)
        return True
    
    def get_land_details(self, land_id: str) -> Optional[Dict]:
        record = next((r for r in self.records if r.land_id == land_id), None)
        if not record:
            return None
        return record.get_summary()
    
    def get_owner_properties(self, owner: str) -> List[str]:
        return [r.land_id for r in self.records if r.owner == owner]
    
    def report_dispute(self, land_id: str, claimant: str, reason: str) -> Dict:
        dispute = {
            'land_id': land_id,
            'claimant': claimant,
            'reason': reason,
            'status': 'Open',
            'reported_at': datetime.now(),
            'dispute_id': f'DISP-{len(self.disputes)+1:06d}'
        }
        self.disputes.append(dispute)
        print(f"Dispute reported for {land_id}: {reason}")
        return dispute
    
    def resolve_dispute(self, dispute_id: str, resolution: str) -> bool:
        dispute = next((d for d in self.disputes if d['dispute_id'] == dispute_id), None)
        if not dispute:
            return False
        dispute['status'] = 'Resolved'
        dispute['resolution'] = resolution
        dispute['resolved_at'] = datetime.now()
        print(f"Dispute {dispute_id} resolved: {resolution}")
        return True

# Create land registry
registry = LandRegistry('City of Metropolis')

print("\nLand Registry Operations:")

# Register lands
registry.register_land('LND-001', '123 Main St, Metropolis', 500.0, 'John Smith')
registry.register_land('LND-002', '456 Oak Ave, Metropolis', 750.0, 'Maria Garcia')
registry.register_land('LND-003', '789 Pine Rd, Metropolis', 1200.0, 'John Smith')

# Transfer ownership
print("\n--- Ownership Transfers ---")
registry.transfer_ownership('LND-001', 'Robert Chen', 'Sale')
registry.transfer_ownership('LND-002', 'Sarah Wilson', 'Inheritance')
registry.transfer_ownership('LND-003', 'Kevin Brown', 'Gift')

# Report and resolve dispute
registry.report_dispute('LND-001', 'Alice Johnson', 'Boundary dispute with adjacent property')
registry.resolve_dispute('DISP-000001', 'Boundary survey confirmed original boundaries')

# Land details
print("\n--- Land Registry Summary ---")
for land_id in ['LND-001', 'LND-002', 'LND-003']:
    details = registry.get_land_details(land_id)
    if details:
        print(f"\n{land_id}:")
        print(f"  Location: {details['location']}")
        print(f"  Current Owner: {details['current_owner']}")
        print(f"  Transfers: {details['transfers']}")

# ----------------------------------------------------------------
# PART D: GOVERNMENT SERVICES VISUALISATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART D: Government Services Visualisation")
print("-"*60)

# Simulate government service adoption metrics
adoption_data = {
    'Service': [
        'Digital Identity',
        'E-Voting',
        'Land Registry',
        'Social Welfare',
        'Tax Filing',
        'Business Registration'
    ],
    'Current Adoption Rate (%)': [35, 12, 25, 18, 42, 30],
    'Projected Adoption (2026)': [65, 40, 55, 45, 70, 60],
    'Efficiency Improvement (%)': [60, 80, 55, 70, 65, 50]
}

adoption_df = pd.DataFrame(adoption_data)

print("Government Service Adoption Data:")
print(adoption_df.to_string(index=False))

# Create visualisations
fig, axes = plt.subplots(1, 2, figsize=(14, 6))

# 1. Adoption rates
ax1 = axes[0]
x = np.arange(len(adoption_data['Service']))
width = 0.35

ax1.bar(x - width/2, adoption_data['Current Adoption Rate (%)'], width, label='Current', color='blue', alpha=0.7)
ax1.bar(x + width/2, adoption_data['Projected Adoption (2026)'], width, label='Projected 2026', color='green', alpha=0.7)
ax1.set_xlabel('Government Service')
ax1.set_ylabel('Adoption Rate (%)')
ax1.set_title('Blockchain Adoption in Government Services')
ax1.set_xticks(x)
ax1.set_xticklabels(adoption_data['Service'], rotation=45, ha='right')
ax1.legend()
ax1.grid(True, alpha=0.3)

# 2. Efficiency improvement
ax2 = axes[1]
ax2.barh(adoption_data['Service'], adoption_data['Efficiency Improvement (%)'], color='teal', alpha=0.7)
ax2.set_xlabel('Efficiency Improvement (%)')
ax2.set_title('Efficiency Improvement by Service')
ax2.grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig('government_services.png', dpi=300, bbox_inches='tight')
plt.show()
print("Government services chart saved as 'government_services.png'")

# ----------------------------------------------------------------
# PART E: USE CASES AND BENEFITS
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART E: Government Use Cases and Benefits")
print("-"*60)

use_cases = pd.DataFrame({
    'Use Case': [
        'Digital Identity',
        'E-Voting',
        'Land Registry',
        'Tax Collection',
        'Social Welfare',
        'Procurement',
        'Public Records'
    ],
    'Benefit': [
        'Citizen control, reduced fraud',
        'Transparency, accessibility',
        'Immutable records, reduced disputes',
        'Automated compliance, reduced evasion',
        'Reduced fraud, targeted distribution',
        'Transparency, reduced corruption',
        'Immutable, accessible records'
    ],
    'Status': [
        'Growing',
        'Emerging',
        'Mature (in some countries)',
        'Emerging',
        'Early',
        'Pilot',
        'Growing'
    ],
    'Example': [
        'Estonia e-Residency',
        'West Virginia (pilot)',
        'Georgia Lantmäteriet',
        'Dubai Blockchain',
        'UNDP pilots',
        'EU Tenders',
        'UK Land Registry'
    ]
})

print(use_cases.to_string(index=False))

# ----------------------------------------------------------------
# PART F: SUMMARY AND RECOMMENDATIONS
# ----------------------------------------------------------------

print("\n" + "="*70)
print("PART F: Summary and Recommendations")
print("="*70)

print("""
Government and Public Services with Blockchain – Key Takeaways:

1. Blockchain addresses bureaucracy, corruption, data silos, and identity issues.
2. Digital identity: citizen-controlled, reusable across services.
3. E-voting: transparent, auditable, accessible voting systems.
4. Land registry: immutable records, reduced disputes, faster transfers.
5. Key applications: identity, voting, land registry, tax, welfare, procurement.
6. Benefits: transparency, efficiency, reduced fraud, citizen empowerment.
7. Leading examples: Estonia, Georgia, Dubai, West Virginia.

Recommendations:
  - Start with pilot projects in specific services.
  - Ensure legal and regulatory framework alignment.
  - Build interoperability with existing government systems.
  - Engage citizens through education and participation.
  - Use permissioned blockchains for government applications.
  - Implement robust security and privacy measures.
  - Establish clear governance and accountability.
""")

print("="*70)
print("END OF LESSON 7 – MODULE 3")
print("="*70)