import hashlib
import json
import time

# Block class for the Main Chain
class Block:
    def __init__(self, index, previous_hash, timestamp, data, nonce=0):
        self.index = index
        self.previous_hash = previous_hash
        self.timestamp = timestamp
        self.data = data
        self.nonce = nonce
        self.hash = self.calculate_hash()

    def calculate_hash(self):
        block_string = f"{self.index}{self.previous_hash}{self.timestamp}{self.data}{self.nonce}"
        return hashlib.sha256(block_string.encode()).hexdigest()

    def mine_block(self, difficulty):
        target = '0' * difficulty
        while self.hash[:difficulty] != target:
            self.nonce += 1
            self.hash = self.calculate_hash()

# Blockchain class for managing the chain
class Blockchain:
    def __init__(self):
        self.chain = [self.create_genesis_block()]
        self.difficulty = 4  # Set difficulty for PoW

    def create_genesis_block(self):
        return Block(0, "0", time.time(), "Genesis Block")

    def get_latest_block(self):
        return self.chain[-1]

    def add_block(self, new_block):
        new_block.previous_hash = self.get_latest_block().hash
        new_block.mine_block(self.difficulty)
        self.chain.append(new_block)

    def is_chain_valid(self):
        for i in range(1, len(self.chain)):
            current_block = self.chain[i]
            previous_block = self.chain[i - 1]

            if current_block.hash != current_block.calculate_hash():
                return False

            if current_block.previous_hash != previous_block.hash:
                return False

        return True

# Group class for handling group creation
class Group:
    def __init__(self, group_id, group_type, gpsk=None):
        self.group_id = group_id
        self.group_type = group_type
        self.gpsk = gpsk  # Group Private Shared Key for private groups

    @staticmethod
    def create_group(group_type):
        group_id = hashlib.sha256(f"{time.time()}".encode()).hexdigest()
        gpsk = None
        if group_type == "private":
            gpsk = hashlib.sha256(f"{group_id}{time.time()}".encode()).hexdigest()
        return Group(group_id, group_type, gpsk)

# DHT class for storing and retrieving messages
class DHT:
    def __init__(self):
        self.storage = {}

    def store_message(self, key, message):
        self.storage[key] = message

    def retrieve_message(self, key):
        return self.storage.get(key, None)

# Message class for handling message creation and encryption
class Message:
    def __init__(self, content, group):
        self.content = content
        self.group = group
        self.key = self.calculate_key()

    def calculate_key(self):
        return hashlib.sha256(self.content.encode()).hexdigest()

    def encrypt_message(self):
        if self.group.group_type == "private":
            return hashlib.sha256(f"{self.content}{self.group.gpsk}".encode()).hexdigest()
        return self.content

    def store(self, dht):
        encrypted_message = self.encrypt_message()
        dht.store_message(self.key, encrypted_message)

# Main execution script
def main():
    # Initialize the main blockchain
    blockchain = Blockchain()

    # Create a public group
    public_group = Group.create_group("public")
    blockchain.add_block(Block(len(blockchain.chain), blockchain.get_latest_block().hash, time.time(), f"Group {public_group.group_id} - open"))

    # Create a private group
    private_group = Group.create_group("private")
    blockchain.add_block(Block(len(blockchain.chain), blockchain.get_latest_block().hash, time.time(), f"Group {private_group.group_id} - open"))

    # Initialize DHT for message storage
    dht = DHT()

    # Measure performance: messages per second
    start_time = time.time()
    num_messages = 1000  # Simulate storing and retrieving 1000 messages

    for i in range(num_messages):
        # Create and store public messages
        message_public = Message(f"Public message {i}", public_group)
        message_public.store(dht)

        # Create and store private messages
        message_private = Message(f"Private message {i}", private_group)
        message_private.store(dht)

        # Retrieve messages from DHT to simulate full cycle
        dht.retrieve_message(message_public.key)
        dht.retrieve_message(message_private.key)

    end_time = time.time()

    # Calculate performance metrics
    total_time = end_time - start_time
    messages_per_second = (num_messages * 2) / total_time  # *2 because we store and retrieve each message

    # Test blockchain integrity
    blockchain_valid = blockchain.is_chain_valid()

    # Retrieve and test messages
    retrieved_message1 = dht.retrieve_message(message_public.key)
    retrieved_message2 = dht.retrieve_message(message_private.key)

    # Output results
    print("==== Blockchain Analysis ====")
    print(f"Blockchain valid: {blockchain_valid}")
    print(f"Blockchain length: {len(blockchain.chain)}")
    print(f"Latest Block Hash: {blockchain.get_latest_block().hash}")

    print("\n==== Group and Messaging Analysis ====")
    print(f"Public Group ID: {public_group.group_id}")
    print(f"Private Group ID: {private_group.group_id}")
    print(f"Private Group GPSK: {private_group.gpsk}")

    print("\n==== Message Retrieval ====")
    print(f"Retrieved Public Message: {retrieved_message1}")
    print(f"Retrieved Private Message: {retrieved_message2}")
    print(f"Original Private Message (unencrypted): {message_private.content}")

    print("\n==== Performance Metrics ====")
    print(f"Time to process {num_messages} public and private messages: {total_time:.4f} seconds")
    print(f"Estimated Throughput: {messages_per_second:.2f} messages/second")

if __name__ == "__main__":
    main()