from dataclasses import dataclass
import json
from hashlib import sha256
from datetime import datetime
from dataclasses import asdict
import numpy as np
import time



@dataclass
class Transaction:
  sender: str
  receiver: str
  amount: float


@dataclass
class Pow_Block:
  version: int
  timestamp: float
  nonce: int
  difficulty: int
  previous_hash: str
  transactions: list[Transaction]



@dataclass
class Pos_Block:
  version: int
  timestamp: float
  validator: str
  previous_hash: str
  transactions: list[Transaction]

HEX_BASE_TO_NUMBER = 16
DIFFICULTY = 1
#PREV_BLOCK_HASH = "68ffd13b24f9d73399a80aad9de06f676001fed56648314526cd23a4d18fef16"
TRANSACTIONS = (
    Transaction("sender1", "receiver1", 1),
    Transaction("sender2", "receiver2", 0.5),
    Transaction("sender3", "receiver3", 2.7),
)

def create_block_pow(nonce: int, difficulty: int, transactions: tuple, previous_hash) -> Pow_Block:
    cur_timestamp = datetime.now().timestamp()
    return Pow_Block(
        version=1,
        timestamp=cur_timestamp,
        nonce=nonce,
        previous_hash=previous_hash,
        difficulty=difficulty,
        transactions=transactions
    )

def encode_block_pow(block: Pow_Block) -> str:
    encoded_block = json.dumps(asdict(block)).encode()
    return sha256(sha256(encoded_block).digest()).hexdigest()

def calculate_hash_pow(nonce: int, transactions) -> str:
    block = encode_block_pow(nonce, DIFFICULTY, transactions)
    encoded_block_hash = encode_block_pow(block)
    return encoded_block_hash

BYTE_IN_BITS = 256
HEX_BASE_TO_NUMBER = 16
SECONDS_TO_EXPIRE = 20


GENESIS_BLOCK = Pow_Block(
    version=1,
    timestamp=1231006505,
    difficulty=1,
    nonce=42,
    previous_hash="000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f",
    transactions=(Transaction("Satoshi Nakamoto", "Satoshi Nakamoto", 50),)
)


def calculate_difficulty_target(difficulty_bits: int) -> int:
    return 2 ** (BYTE_IN_BITS - difficulty_bits)


class Pow_Blockchain:
    VERSION = 1
    DIFFICULTY = 10
    MINUTES_TOLERANCE = 1

    def __init__(self):
        self.chain = [GENESIS_BLOCK]

    def get_last_block(self) -> Pow_Block:
        return self.chain[-1]
    
    def add_block(self, block: Pow_Block) -> bool:
        is_valid = self._validate_block(block)
        if is_valid:
            self.chain.append(block)

        return is_valid
    
    def get_difficulty(self) -> int:
        return self.DIFFICULTY


    def _validate_block(self, candidate: Pow_Block) -> bool:
        if candidate.version != self.VERSION:
            return False

        last_block = self.get_last_block()
        if candidate.previous_hash != encode_block_pow(last_block):
            return False
        
        if candidate.difficulty != self.DIFFICULTY:
            return False


        candidate_hash = encode_block_pow(candidate)
        candidate_decimal = int(candidate_hash, HEX_BASE_TO_NUMBER)

        target = calculate_difficulty_target(self.DIFFICULTY)
        is_block_valid = candidate_decimal < target

        return is_block_valid
    



def mine_proof_of_work(nonce: int, difficulty: int, prev_hash: str, transactions:tuple) -> tuple[bool, Pow_Block]:
    block = create_block_pow(nonce, difficulty, transactions, prev_hash)
    encoded_block = encode_block_pow(block)
    block_encoded_as_number = int(encoded_block, HEX_BASE_TO_NUMBER)
    decimal_target = calculate_difficulty_target(difficulty)

    if block_encoded_as_number < decimal_target:
        return True, block

    return False, block

import numpy as np
pow_blockchain = Pow_Blockchain()


nonce = 0
start_time = time.time()
found = False
prev_hash = encode_block_pow(pow_blockchain.get_last_block())

for i in range(10):
    nonce = 0
    start_time = time.time()
    found = False
    prev_hash = encode_block_pow(pow_blockchain.get_last_block())
    while not found:
        found, block = mine_proof_of_work(nonce, pow_blockchain.get_difficulty(), prev_hash, Transaction("Satoshi Nakamoto", "Satoshi Nakamoto", np.random.uniform()))

        if found:
            pow_blockchain.add_block(block)
        else:
            nonce += 1

        end_time = time.time()
        elapsed_time = end_time - start_time

        if elapsed_time > SECONDS_TO_EXPIRE:
            raise TimeoutError(
                f"Couldn't find a block within the given timeframe"
            )

for block in pow_blockchain.chain:
    print(block)
    print("\n")

GENESIS_BLOCK_POS = Pos_Block(
    version=1,
    timestamp=1231006505,
    previous_hash="000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f",
    validator='Louie',
    transactions=Transaction('','',0)
)

def encode_block_pos(block):
    """
    calcuate block sha256 hash value
    """
    record  = "".join([
        str(block.version),
        str(block.timestamp),
        block.validator,
        block.previous_hash
    ])
    return sha256(record.encode()).hexdigest()



class Pos_Blockchain:
    VERSION = 1

    def __init__(self):
        self.chain = [GENESIS_BLOCK_POS]

    def get_last_block(self) -> Pos_Block:
        return self.chain[-1]
    
    def add_block(self, block: Pos_Block) -> bool:
        is_valid = self._validate_block(block)
        if is_valid:
            self.chain.append(block)

        return is_valid
    

    def get_difficulty(self) -> int:
        return self.DIFFICULTY


    def _validate_block(self, candidate: Pos_Block) -> bool:
        if candidate.version != self.VERSION:
            return False

        last_block = self.get_last_block()
        if candidate.previous_hash != encode_block_pos(last_block):
            return False
        



        return True








def create_block_pos(transactions: tuple, validator: str, previous_hash) -> Pow_Block:
        cur_timestamp = datetime.now().timestamp()
        return Pos_Block(
            version=1,
            timestamp=cur_timestamp,
            validator=validator,
            previous_hash=previous_hash,
            transactions=transactions
        )

def lottery_proof_of_stake(validators, block, prev_hash, transactions):
    participants = [user['id'] for user in validators]
    participants_amt = np.array([user['stake'] for user in validators])
    total_amt = np.sum(participants_amt)
    winner = np.random.choice(a = participants, p = participants_amt/total_amt)
    block = create_block_pos(transactions, winner, prev_hash)
    return block

    
    

validators = [{'id':'Huey', 'stake':33}, {'id':'Dewey', 'stake':10}, {'id':'Louie', 'stake':99}]


pos_blockchain = Pos_Blockchain()


start_time = time.time()
found = False
prev_hash = encode_block_pos(pos_blockchain.get_last_block())

for i in range(10):
    prev_hash = encode_block_pos(pos_blockchain.get_last_block()) 
    block = lottery_proof_of_stake(validators, block, prev_hash, Transaction("Satoshi Nakamoto", "Satoshi Nakamoto", 100*np.random.uniform()))
    pos_blockchain.add_block(block)


for block in pos_blockchain.chain:
    print(block)
    print("\n")