import gc
import random
import time    
import sys
from threading import Barrier, Thread
from itertools import count
import json

def single_reference_int():
    # Return int that has a single reference (with very high probability)
    return random.randint(2**80, 2**82)


class EvilMapping(dict):
    
    cnt = count()
    
    def __init__(self, data):
        mapping = {next(self.cnt): single_reference_int()} # generate a mapping with no outside references
        super().__init__(mapping)
        self.data = data

    def keys(self):
        return list(self.mapping)
    
    def items(self):
        # this is called in encoder_listencode_dict which is called from encoder_listencode_obj
        # try to get this thread to suspect on the outer lock
        
        self.data.clear() # this will remove self from the list, leaving no references to self (except cyclic references)
        gc.collect() # the EvilMapping without refcounts (e.g. this one) should be cleared
        repr(self) # do something with self
        return super().items()
    
    def __repr__(self):
        return f'{self.__class__.__name__} {super().__repr__()}'
    
run= True
    
def worker(barrier, data, index):
            global run
            barrier.wait()
            while run:               
                # worker clears the list to generate borrowed references with refcount 0
                #print(f'worker {index} {len(lst)=}')
                data.append(single_reference_int())
                data.append(EvilMapping(data)) # inject more evil mappings
                if len(data) > 10:
                    data.clear()
            #print(f'worker {index} done')
            print(f'worked {index=} {run=}')


# we want a list where encoding one of the elements clears elements from the list that have refcount 1
data= []
data.append(EvilMapping(data))
data.append(EvilMapping(data))
print(f'{data=}')
j=json.dumps(data)
print(j)
print(f'{data=}')

#%%
print('----- go! -------')
data= []
data.append(EvilMapping(data))

number_of_threads = 2
number_of_json_encodings=3

worker_threads = []
barrier = Barrier(number_of_threads)
run = True
for index in range(number_of_threads):
    worker_threads.append(
        Thread(target=worker, args=[barrier, data, index])
    )
for t in worker_threads:
    t.start()
for ii in range(number_of_json_encodings):
    print(f'dump {ii}')
    data.extend( [EvilMapping(data)]*10)
    json.dumps(data)

run = False

for t in worker_threads:
    t.join()