use std::thread;
use std::sync::{Arc, Mutex};

const  MAX : usize = 500000;

fn prime_thread(_id : i32, nextnum : Arc<Mutex<u64>>, pcount : Arc<Mutex<usize>>, primes : Arc<Mutex<[u64; MAX]>> ) {
	let mut num : u64;
	let mut idx : usize;
	while *pcount.lock().unwrap() < MAX {
		{
			let mut lnextnum = nextnum.lock().unwrap(); 
			num = *lnextnum;
			*lnextnum += 2;
		}
		let mut prime : bool = true;
		idx = 0;
		let pcount_cval = *pcount.lock().unwrap();
		while idx < pcount_cval {
			let pidx_value : u64 = (*primes.lock().unwrap())[idx];
			if pidx_value * pidx_value <= num {
				if 0 == (num % pidx_value) {
					prime = false;
					break;
				}
				idx += 1;
			} else {
				break;
			}
		}
		if prime {
			let mut lpcount = pcount.lock().unwrap();
			let mut lprimes = primes.lock().unwrap();
			if *lpcount < MAX {
				(*lprimes)[*lpcount] = num;
				*lpcount += 1;
			} else {
				if (*lprimes)[*lpcount - 1] > num {
					(*lprimes)[*lpcount - 1] = num;
				}
				return;
			}
			let mut i = *lpcount - 1;
			while i > 1  {
				if (*lprimes)[i-1] > (*lprimes)[i] {
					let t = (*lprimes)[i-1];
					(*lprimes)[i-1] = (*lprimes)[i];
					(*lprimes)[i] = t;
				} else {
					break;
				}
				i -= 1;
			}
		}
	}
}

fn main() {
	let threads = 10;
	let pcount = Arc::new(Mutex::new(1));
	let primes = Arc::new(Mutex::new([2; MAX]));
	let nextnum = Arc::new(Mutex::new(3));
	let mut handles = vec![];

	for id in 0..threads {
		let pcount_clone = Arc::clone(&pcount);
		let primes_clone = Arc::clone(&primes);
		let nextnum_clone = Arc::clone(&nextnum);
		let handle = thread::spawn(move || {prime_thread(id, nextnum_clone, pcount_clone, primes_clone)});
		handles.push(handle);
	}

	for handle in handles {
		handle.join().unwrap();
	}

	let primeres = *primes.lock().unwrap();
	let pc = *pcount.lock().unwrap();

	/*
	for n in primeres {
		println!("{n}");
	}
	*/

	println!("Middle 25 primes:");
	for i in pc/2 .. pc/2+25 {
		print!("{} ", primeres[i]);
	}
	println!("");

	println!("Last 25 primes:");
	for i in pc-25 .. pc {
		print!("{} ", primeres[i]);
	}
	println!("");
	
	println!("Final pcount:  {}\n", pc);
/*
	for i in 0 .. pc - 1 {
		if primeres[i] == primeres[i + 1] {
			println!("Error:  Duplicate prime recorded at index {i} and {}", i+1);
		}
	}

	for i in 0 .. pc - 1 {
		if primeres[i] == primeres[i + 1] {
			println!("Note:  Out of order primes {} and {}", primeres[i], primeres[i+1]);
		}
	}

	let check_prime = |num : u64| -> bool {
		for i in 0 .. pc {
			if  primeres[i] > num {
				return true; 
			}
			if 0 == num % primeres[i] && num != primeres[i] {
				return false;
			}
		}
		return true;
	};

	for i in 0 .. pc {
		if !check_prime(primeres[i]) {
			println!("Error:  {} is not prime!", primeres[i]);
		}
	}

	let was_found = |num : u64| -> bool {
		for i in 0 .. pc {
			if primeres[i] == num {
				return true;
			}
		}
		false
	};

	let mut testval : u64 = 2;
	let mut cc : usize = 0;
	while cc < MAX {
		if check_prime(testval) {
			cc += 1;
			if !was_found(testval) {
				println!("Error:  {testval} is prime but was not found");
			}
		}
		testval += 1;
	}
*/
}