# return int(s[::-1].encode('hex'), 16) if s else 0
        f.write("\n")
    f.close()

    # Use a low-round version of randmemohash
    for _ in range(CACHE_ROUNDS):
        for i in range(n):
            v = o[i][0] % n
            lala =o[(i-1+n) % n]
            o[i] = sha3_512(map(xor, o[(i-1+n) % n], o[v]))
            col1item = map(hex, o[i])
            g.write(str(col1item[1]))
            g.write("\n")
    return o

########### Make a fake light cache with all 0's
##########def mkfakecache(cache_size, seed):
    ##########n = cache_size // HASH_BYTES

    ########### Sequentially produce the initial dataset
    ###########o = [sha3_512(seed)]
    ##########o = [0]
    ##########for i in range(1, n):
        ##########o.append(0)
    ##########return o

FNV_PRIME = 0x01000193

def fnv(v1, v2):
    return ((v1 * FNV_PRIME) ^ v2) % 2**32

def calc_dataset_item(cache, i):
    n = len(cache)
    r = HASH_BYTES // WORD_BYTES
    # initialize the mix
    mix = copy.copy(cache[i % n])
    mix[0] ^= i
    mix = sha3_512(mix)
    # fnv it with a lot of random cache nodes based on i  (256 times)
    for j in range(DATASET_PARENTS):
        cache_index = fnv(i ^ j, mix[j % r])
        lala123 = cache[cache_index % n]
        mix = map(fnv, mix, cache[cache_index % n])
    return sha3_512(mix)

# Pad dataset with all zeros
def calc_fake_dataset_item(cache, i):
    #return an array of 16 four-byte numbers, 16 * 4 * 8 = 512
	#In the original dataset, you'd get the hash digest of a sha3_512
    return [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]

#Create entire DAG
def calc_dataset(full_size, cache):
    print("Create Full DAG")
    return [calc_dataset_item(cache, i) for i in range(full_size // HASH_BYTES)]

def calc_fake_dataset(full_size, cache):
    return [calc_fake_dataset_item(cache, i) for i in range(full_size // HASH_BYTES)]

#Hashimoto is the "search function"
def hashimoto(header, nonce, full_size, dataset_lookup):
    n = full_size / HASH_BYTES
    w = MIX_BYTES // WORD_BYTES
    mixhashes = MIX_BYTES / HASH_BYTES
    # combine header+nonce into a 64 byte seed
    nonce = encode_int(nonce)
    #Before we start mix, gotta do a round of Keccak first
    s = sha3_512(header + nonce[::-1])
    # start the mix with replicated s
    mix = []
    for _ in range(MIX_BYTES / HASH_BYTES):
        mix.extend(s)
        print(mix)
        print(binascii.hexlify(serialize_hash(mix)))
    # mix in random dataset nodes
    for i in range(ACCESSES):
        p = fnv(i ^ s[0], mix[i % w]) % (n // mixhashes) * mixhashes
        newdata = []
        for j in range(MIX_BYTES / HASH_BYTES):
            newdata.extend(dataset_lookup(p + j))
        print("type mix is" , type(mix))
        print("type newdata is" , type(newdata))
        print("ACCESS is",i)
        mix = map(fnv, mix, newdata)
    # compress mix
    cmix = []
    for i in range(0, len(mix), 4):
        print("cmix is ", cmix)
        cmix.append(fnv(fnv(fnv(mix[i], mix[i+1]), mix[i+2]), mix[i+3]))
        print("cmix is ", cmix)
    print("cmix is ", cmix)
    return {
        "mix digest": serialize_hash(cmix),
        "result": serialize_hash(sha3_256(s+cmix))
    }


#Mix only algo - for Avnet reference
def mix_only(s, full_size, dataset_lookup):
    n = full_size / HASH_BYTES
    w = MIX_BYTES // WORD_BYTES
    mixhashes = MIX_BYTES / HASH_BYTES
    # combine header+nonce into a 64 byte seed
	# Avnet : comment below to parse s from object calls
    s = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
    print(s)
    s = sha3_512(s)
    print(s)
    s = serialize_hash(s)
    print("Initial s data in HEX:")
    print(binascii.hexlify(s))


    # start the mix with replicated s
    mix = []
    for _ in range(MIX_BYTES / HASH_BYTES):
        mix.extend(s)
        print("type mix is" , type(mix))
    # mix in random dataset nodes
    for i in range(ACCESSES):
        p = fnv(i ^ ord(s[0]), ord(mix[i % w])) % (n // mixhashes) * mixhashes
        newdata = []
        print("newdata is",newdata)
        for j in range(MIX_BYTES / HASH_BYTES):
            newdata.extend(dataset_lookup(p + j))
        print("mixmap is ")
        print("type mix is" , type(mix))
        print("type newdata is" , type(newdata))
        print("ACCESS is",i)
        mix = map(fnv, mix, newdata)
    # compress mix
    cmix = []
    for i in range(0, len(mix), 4):
        print("cmix start append")
        cmix.append(fnv(fnv(fnv(mix[i], mix[i+1]), mix[i+2]), mix[i+3]))
    print("returning cmix")
    return cmix

def hashimoto_light(full_size, cache, header, nonce):
    return hashimoto(header, nonce, full_size, lambda x: calc_dataset_item(cache, x))

def hashimoto_full(full_size, dataset, header, nonce):
    return hashimoto(header, nonce, full_size, lambda x: dataset[x])

def get_seedhash(block):
    s = '\x00' * 32
    for i in range(block.number // EPOCH_LENGTH):
        s = serialize_hash(sha3_256(s))
    return s

def mine(full_size, dataset, header, difficulty):
    print("Target: {}".format(float(2**256 // difficulty)))
    target = zpad(encode_int(2**256 // difficulty), 64) # [::-1]
    print("Target after padding: {}".format(float(decode_int(target))))
    from random import randint
    nonce = randint(0, 2**64)
    print("Nonce: {}".format(nonce))
    print(float(decode_int(hashimoto_full(full_size, dataset, header, nonce)['result'])))
    steps = 0
    while decode_int(hashimoto_full(full_size, dataset, header, nonce)['result']) > decode_int(target):
        nonce = (nonce + 1) % 2**64
        steps += 1
    print("Nonce: {}".format(nonce))
    print(float(decode_int(hashimoto_full(full_size, dataset, header, nonce)['result'])))
    print("Steps required: {}".format(steps))
    return nonce


class Block(object):
    def __init__(self, number):
        self.number = number


def main():
    header_size = 508 + 8 * 5

    block = Block(30010)
    #block = Block(7749409)
    header = str(bytearray(header_size))
    difficulty = 0x4000

    #fnvresult = fnv(0x12345678,0xffffffff)
    #print(hex(fnvresult))

    cache_size = get_cache_size(block.number)
    print("Cache size is", cache_size)
    full_size = get_full_size(block.number)
    print("Full size is", full_size)
    seedhash = get_seedhash(block)
    seedhash_hex = binascii.hexlify(seedhash)
    #print("Seedhash ASCII is", seedhash)

    asdf = sha3.keccak_256("")
    asdf = asdf.hexdigest()
    print(asdf)
    asdf3 = deserialize_hash(asdf)
    print(asdf3)

    asdf = sha3_512("")
    print(asdf)
    asdf2 = serialize_hash(asdf)
    print(binascii.hexlify(asdf2))
    asdf3 = deserialize_hash(asdf2)
    print(asdf3)

    print("Seedhash HEX is", seedhash_hex)
    lenofseed = len(seedhash)
    print("Length of seedhash is {} bytes".format(len(seedhash)))
    print("Prepare light cache...")

    #Make fake cache below
    #cache = mkfakecache(cache_size, seedhash)
    cache = mkcache(cache_size, seedhash)
    print("Length of cache is", len(cache))
    #print("Prepare zero-padded full dataset...")
    #dataset = calc_fake_dataset(full_size, cache)
    dataset = calc_dataset(full_size, cache)
    print("Dataset to be used for MIX")
    #s1 = [0,0,0,0,0,0,0,0,0,0,0,0,0]
    #mixoutput = mix_only( s1 , full_size, lambda x: dataset[x])
    #print("mix output is " , mixoutput)
    print("Mine a block")
    mine(full_size, dataset, header, difficulty)


if __name__ == "__main__":
    main()