import time
import hashlib
import random

max_diff = 256 # define a max difficulty for the shares (this prevents higher than block difficulty and/or absurd difficulty)
pool_start_diff = 32 # define a starting point for the pool

class PoolSimulator:

    def __init__(self):
        self.miners = {} # new miners are added here
        self.difficulty = pool_start_diff  # Starting difficulty for all miners
        self.time = time.time() # reference time
        self.hashrate = 0 # pool starting hashrate

    def register_miner(self, miner_id):
        self.miners[miner_id] = {
            'difficulty': self.difficulty, # current miner difficulty (used to calculate each update to the hashrate below)
            'submitted_shares': [], # list of Shares already submitted to the pool
            'hashrate': 0 # calculated hashrate for THIS miner
        }

    def set_difficulty(self, miner_id, new_difficulty):
        self.miners[miner_id]['difficulty'] = new_difficulty # set new difficulty by miner
        print(f"Miner {miner_id} difficulty set to {new_difficulty}") # display the new difficulty

    def submit_share(self, miner_id, nonce):
        miner = self.miners[miner_id] # get the current miner
        current_difficulty = miner['difficulty'] # get the current difficulty from that miner
        target = (2 ** 256) // current_difficulty # get the current target from that difficulty
       
        # Validate share
        nonce_str = f"{miner_id}-{nonce}" # prepare data as a STRING to be hashed
        hash_value = int(hashlib.sha256(nonce_str.encode()).hexdigest(), 16) # actually hash the data
        if hash_value < target: # check if the date is valid under the current difficulty
            miner['submitted_shares'].append({'nonce': nonce, 'difficulty': current_difficulty}) # add share to list o valid past shares
            print(f"Valid share from miner {miner_id} at difficulty {current_difficulty}") # print that
            return True # I was thinking of using this , but I skipped it...
        else:
            print(f"Invalid share from miner {miner_id}") # report if invalid
            return False # again... not really needed

    def calc_hashrate(self):
        elapsed_time = time.time() - self.time # total time from the start
        hashrates = 0 # pool total hashrate init at 0 (ended up not really using the full potential of this... figured... i already prove my point wit one miner)
        for miner in self.miners:
            hashrate = 0 # individual miner hashrate init at 0
            for share in self.miners[miner]['submitted_shares']:
                hashrate += share['difficulty'] / elapsed_time # each share has it's dificulty, by dividing by total time, we get the portion of Hashrate that share tells the pool the miner has in total
            self.miners[miner]['hashrate'] = hashrate # after we get the total hashrate from adding all shares (based on their difficulty) we set the miner's current Hashrate
            hashrates += hashrate # pool hashrate is the sum of all individual hashrates, so we add them together
        self.hashrate = hashrates # finaly we set the current pool hashrate... (BASED on calculated hashrate from each miner share... NOT real hashrate)

    def print_hashrate(self):
        print(f"Pool Calculated Hashrate: {self.hashrate}") # this is the pool's total calculated hashrate!

# Miner behavior simulation
class MinerSimulator:
    def __init__(self, miner_id, pool, hashrate):
        self.miner_id = miner_id # set the miner ID
        self.pool = pool # set the pool for this miner
        self.hashrate = hashrate  # Hashes per second

    def mine(self):
        # Simulate mining with constant hashrate (by throtteling with time.sleep(...) )
        nonce = (random.random()*1000000)//1000000 # ugly, I know..... but efective in this PoC: Generate a new nonce

        while True:
            nonce_str = f"{self.miner_id}-{nonce}" # prepare data as a STRING to be hashed
            hash_value = int(hashlib.sha256(nonce_str.encode()).hexdigest(), 16) # actually hash the data

            # Check if share is valid against current pool difficulty
            target = (2 ** 256) // self.pool.miners[self.miner_id]['difficulty']  # get the current target from pool
            pool_diff = (2 ** 256) // target # get pool diff from that target
            share_diff = (2 ** 256) // hash_value # get the current share difficulty
           
            if share_diff > pool_start_diff: # check to see if pool will accept at all...
                if share_diff < max_diff: # check to see if share is under the maximum
                    new_diff = share_diff # if it is, use it's difficult
                else: # if not,
                    new_diff = max_diff # use the max we defined at the start...

                print(f"\nNew SHARE found by miner: {self.miner_id}") # report this share to the console

                pool.set_difficulty(self.miner_id, new_diff) # ask the pool to change the difficulty... (we should WAIT for the response) [if you COMMENT this line of code, the pool should always report the correct hashrate]{THIS IS THE MAGIC LINE}
                pool.submit_share(self.miner_id, nonce) # send the share after the response from previous line
                pool.calc_hashrate() # update the Poolside Hashrate.... (again, NOT the REAL hashrate but the one the pool will think it has)

                print(f"Share Diff: {share_diff}") # report the diff from this found share
                print(f"Real Miner Hashrate: {self.hashrate}") # report the REAL hashrate from this miner (This is the REAL reate this miner should be finding accounted at the pool, but it's NOT)
                print(f"Pool Miner Hashrate: {pool.miners[self.miner_id]['hashrate']}") # report what the pool calculates from this miner!
                pool.print_hashrate() # report total pool hashrate..........i know this could be done in a different, more elegant way... but it works, so I didn't bother

            nonce += 1 # increase the nonce
            time.sleep(1 / self.hashrate) # throttle the miner to the desired hashrate

# RUN
pool = PoolSimulator()
pool.register_miner("Miner0")

miner0 = MinerSimulator("Miner0", pool, hashrate=32) # here you shoose the REAL hashrate from the miner, and then my code does it's magic! Enjoy!
miner0.mine()

# miner1 = MinerSimulator("Miner1", pool, hashrate=32)
# miner1.mine()