package main

import (
	"crypto/rand"
	"fmt"
	"io"
	"math/big"
	mrand "math/rand"
	"runtime"
	"time"
)

type job struct {
	p      *big.Int // Number to check
	i      int      // Iterations
	result bool
	id     int
}

func main() {
	runtime.GOMAXPROCS(101)
	s1 := mrand.NewSource(time.Now().UnixMicro())
	r1 := mrand.New(s1)
	start := time.Now()

	p, _ := prime(r1, 8096, 100)

	finish := time.Now()
	elapsed := finish.Sub(start)
	fmt.Printf("p: %v\n", p)
	fmt.Printf("That took: %dms\n", elapsed.Milliseconds())

	start = time.Now()
	p2, _ := rand.Prime(r1, 8096)
	finish = time.Now()
	elapsed = finish.Sub(start)
	fmt.Printf("p2: %v\n", p2)
	fmt.Printf("Normal generation took: %dms\n", elapsed.Milliseconds())

}

func prime(rand io.Reader, bits int, threads int) (p *big.Int, err error) {
	//bytes := make([]byte, (bits+7)/8)

	//p = new(big.Int)
	jobs := make(chan job, 100)
	results := make(chan job, 100)
	numbers := make(chan *big.Int, 100)
	done := new(bool)
	*done = false

	for i := 0; i < threads; i++ {
		go worker(i, jobs, results, done)
	}

	fmt.Printf("Seeding and starting worker pool\n")
	for i := 0; i < 10; i++ {
		go rng(i, bits, numbers, done)
		time.Sleep(1 * time.Millisecond)
	}

	fmt.Printf("Starting!\n")
	for i := 0; ; i++ {
		newjob := &job{
			p:  <-numbers,
			i:  20,
			id: i,
		}

		jobs <- *newjob

		r := <-results
		if r.result {
			fmt.Printf("Found one, closing the channel and returning\n")
			close(jobs)
			*done = true
			close(results)
			return r.p, nil
		}
	}

}

func rng(id int, bits int, num chan<- *big.Int, done *bool) {
	s1 := mrand.NewSource(time.Hour.Microseconds())
	rand := mrand.New(s1)
	bytes := make([]byte, (bits+7)/8)
	for !*done {
		p := new(big.Int)
		io.ReadFull(rand, bytes)
		// This makes sure that the least significant bit is always 1
		// meaning that the number is always odd, since even numbers
		// aren't prime
		bytes[len(bytes)-1] |= 1

		p.SetBytes(bytes)
		num <- p
	}
}

func worker(id int, jobs <-chan job, results chan<- job, done *bool) {
	//fmt.Printf("Worker %d starting now!\n", id)
	for j := range jobs {
		j.result = j.p.ProbablyPrime(j.i)
		fmt.Printf("Worker\t %d checked a number\n", id)
		if *done {
			return
		}
		results <- j
	}
}