import random
import numpy as np
import time
import os
import multiprocessing
from multiprocessing import Pool
import secp256k1 as ice
from random import sample


r = 0
cores=1

def generate_random_bits(n, k):
    while True:
        # Initially all digits are 0
        bits = ['0'] * n
        # Generate random 1
        positions = random.sample(range(n), k)
        for pos in positions:
            bits[pos] = '1'
       
        # How many 1's can in a row?
        if is_valid_combination(bits,max_consecutive_ones):
            return ''.join(bits)

def is_valid_combination(bits,max_consecutive_ones):
    count = 0
    for bit in bits:
        if bit == '1':
            count += 1
            if count > max_consecutive_ones:  # limit for consecutive ones
                return False
        else:
            count = 0
    return True

def priv_key(n, k):
    while True:
        random_bits = generate_random_bits(n, k)
        decimal_representation = int(random_bits, 2)
        if 2**(n-1) < decimal_representation < 2**n:
           return decimal_representation

# Parameters
n = 69  # Puzzle number
max_consecutive_ones = 6  # limit for consecutive ones

def seek(r):
    global num_threads
    LOG_EVERY_N = 100000
    start_time = time.time()
    i = 0
    print("Core " + str(r) +":  Searching Private Key..")
    db = '61eb8a50c86b0584bb727dd65bed8d2400d6d5aa'
    while True:
        i=i+1
        k = random.randrange(32, 35) # How many 1's are there?
        private_key = priv_key(n,k)
        #print(private_key)
#public_key = privtopub(private_key)       
        addr = ice.privatekey_to_h160(0, True, private_key).hex()
        time_diff = time.time() - start_time
        if (i % LOG_EVERY_N) == 0:
            print('Itaration :'+str(i)+" K/s = "+ str(i time_diff))

        if addr in db:
            f = open('KEYFOUND_KEYFOUND_KEYFOUND.txt','a')
            print ('------------------------------------------------------------------------- ')
            print ('!!! ---- KEYFOUND KEYFOUND KEYFOUND!!! ---- ' )
            print('Key: ', hex(private_key)[2:] )
            print('Adress: ', addr )
            f.write(hex(private_key)[2:])
            f.write('     ')
            f.write(addr)
            f.write('\n')
            f.close()
            time.sleep(10)
            print ('------------------------------------------------------------------------- ')


if __name__ == '__main__':
jobs = []
for r in range(cores):
p = multiprocessing.Process(target=seek, args=(r,))
jobs.append(p)
p.start() 

#include <random>

thread_local std::mt19937_64 rng(std::random_device{}());

void RandomXor(Int* currentKey, int bit_length, int flip_count) {
    alignas(32) uint64_t flipMasks[4] = {0};

    // Generate random positions and set bits in batches
    for (int i = 0; i < flip_count; ) {
        // Generate 4 random positions at once
        uint64_t rand_positions[4];
        for (int j = 0; j < 4 && i < flip_count; j++, i++) {
            rand_positions[j] = rng() % bit_length;
            int word = rand_positions[j] 64;
            int bit = rand_positions[j] % 64;
            flipMasks[word] ^= (1ULL << bit);
        }
    }

    // Apply XOR in one AVX2 operation
    __m256i keyVec = _mm256_loadu_si256((__m256i*)currentKey->bits64);
    __m256i maskVec = _mm256_loadu_si256((__m256i*)flipMasks);
    __m256i result = _mm256_xor_si256(keyVec, maskVec);
    _mm256_storeu_si256((__m256i*)currentKey->bits64, result);

    // Clear masks to zero for next iteration
    memset(flipMasks, 0, sizeof(flipMasks));
}

void worker(Secp256K1* secp, int bit_length, int flip_count, int threadId, AVXCounter start, AVXCounter end) {
    const int fullBatchSize = 2 * POINTS_BATCH_SIZE;
    alignas(32) uint8_t localPubKeys[HASH_BATCH_SIZE][33];
    alignas(32) uint8_t localHashResults[HASH_BATCH_SIZE][20];
    alignas(32) int pointIndices[HASH_BATCH_SIZE];

    __m256i target16 = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(TARGET_HASH160_RAW.data()));

    alignas(32) Point plusPoints[POINTS_BATCH_SIZE];
    alignas(32) Point minusPoints[POINTS_BATCH_SIZE];

    for (int i = 0; i < POINTS_BATCH_SIZE; i++) {
        Int tmp;
        tmp.SetInt32(i);
        plusPoints[i] = secp->ComputePublicKey(&tmp);
        minusPoints[i] = plusPoints[i];
        minusPoints[i].y.ModNeg();
    }

    alignas(32) Int deltaX[POINTS_BATCH_SIZE];
    IntGroup modGroup(POINTS_BATCH_SIZE);
    alignas(32) Int pointBatchX[fullBatchSize];
    alignas(32) Int pointBatchY[fullBatchSize];

    CombinationGenerator gen(bit_length, flip_count);
    gen.unrank(start.load());

    AVXCounter count;
    count.store(start.load());

    uint64_t actual_work_done = 0;
    auto last_report = chrono::high_resolution_clock::now();

    while (!stop_event.load() && count < end) {
    Int currentKey;
    currentKey.Set(&BASE_KEY);
    
    RandomXor(&currentKey, bit_length, flip_count);

    string keyStr = currentKey.GetBase16();
    keyStr = string(64 - keyStr.length(), '0') + keyStr;

     #pragma omp critical
    {
        g_threadPrivateKeys[threadId] = keyStr;
    }