package main

import (
    "flag"
    "fmt"
    "math"
    "sync"
    "time"
)

type palindrome struct {
    m1, m2, prod int
}

func main() {
    var primeLen int

    flag.IntVar(&primeLen, "len", 5, "length of the prime multipliers")
    flag.Parse()

    t := time.Now()
    fmt.Println(largestPalindrome(primeLen))
    fmt.Println("Done in", time.Since(t))
}

func largestPalindrome(primeLen int) palindrome {
    var wg sync.WaitGroup
    var best palindrome
    var palindroms chan palindrome

    palindroms = make(chan palindrome)

    from, to := boundaries(primeLen)

    primes := calculatePrimes(from, to)

    cap := int(math.Pow10(2*primeLen - 1))

    for i := len(primes) - 1; i > 1; i-- {
        wg.Add(1)
        go findPalindromeProducts(primes, i, cap, &best, &palindroms, &wg)
    }

    go closeChan(&wg, &palindroms)

    for result := range palindroms {
        if result.prod > best.prod {
            best = result
        }
    }

    return best
}

func findPalindromeProducts(primes []int, i, cap int, best *palindrome, pals *chan palindrome, wg *sync.WaitGroup) {
    for j := i; j > 0; j-- {
        mul := primes[i] * primes[j]
        if mul < cap && mul > best.prod && isPalindrome(mul) {
            *pals <- palindrome{primes[i], primes[j], mul}
        }
    }
    wg.Done()
}

func calculatePrimes(from, to int) (primes []int) {
    composite := make([]bool, to)

    for i := 2; i <= int(math.Sqrt(float64(to))); i++ {
        for j := i * i; j < to; j += i {
            composite[j] = true
        }
    }

    for k := from; k < to; k++ {
        if !composite[k] {
            primes = append(primes, k)
        }
    }

    return primes
}

func isPalindrome(n int) bool {
    order := int(math.Floor(math.Log10(float64(n))))

    for i := order / 2; i > 0; i-- {
        left := (n / int(math.Pow10(order-i+1))) % 10
        right := (n % int(math.Pow10(i))) / int(math.Pow10(i-1))

        if left != right {
            return false
        }
    }

    return true
}

func boundaries(l int) (int, int) {
    return int(math.Pow10(l - 1)), int(math.Pow10(l) - 1)
}

func closeChan(wg *sync.WaitGroup, c *chan palindrome) {
    wg.Wait()
    close(*c)
}