open System;

let random = new System.Random()

type Gene(r : int, g : int, b : int) =
    member this.r = r
    member this.g = g
    member this.b = b

let fitness (gene : Gene) =
    gene.r + gene.g + gene.b

let mutate (gene : Gene) =
    if random.Next(0, 100) > 94 then
        let randomGene = random.Next(0, 3);
        let randomValue = random.Next(0, 256);
        if randomGene = 0 then
            let result = new Gene(randomValue, gene.g, gene.b)
            result
        else if randomGene = 1 then
            let result = new Gene(gene.r, randomValue, gene.b)
            result
        else
            let result = new Gene(gene.r, gene.g, randomValue)
            result
    else
        gene

let randomChild (geneA : Gene) (geneB : Gene) =
    let randParent = random.Next(0, 6);

    if randParent = 0 then
        new Gene(geneA.r, geneB.g, geneA.b)
    else if randParent = 1 then
        new Gene(geneB.r, geneA.g, geneB.b)
    else if randParent = 2 then
        new Gene(geneA.r, geneA.g, geneB.b)
    else if randParent = 3 then
        new Gene(geneB.r, geneB.g, geneA.b)
    else if randParent = 4 then
        new Gene(geneA.r, geneB.g, geneB.b)
    else
        new Gene(geneB.r, geneB.g, geneA.b)

let spliceGenes (geneA : Gene) (geneB : Gene) =
    let fitA = fitness geneA
    let fitB = fitness geneB
    let randChild = randomChild geneA geneB

    if fitA > fitB then
        let childA = mutate randChild
        let childB = new Gene(geneA.r, geneA.g, geneA.b) |> mutate
        [childA; childB]
    else
        let childA = new Gene(geneB.r, geneB.g, geneB.b) |> mutate
        let childB = mutate randChild
        [childA; childB]

let rec doBreeding genes =
    if (List.length genes) > 1 then
        let g1 = List.head genes
        let g2 = List.head (List.tail genes)
        let list = spliceGenes g1 g2
        let res = list @ (doBreeding (List.tail (List.tail genes)))
        res
    else
        []

let randomGene = fun () ->
    let geneR = random.Next(0, 256)
    let geneG = random.Next(0, 256)
    let geneB = random.Next(0, 256)
    let g = new Gene(geneR, geneG, geneB);
    g

let printGene (g: Gene) =
    printfn "R: %i, G: %i, B: %i" g.r g.g g.b

let printGenes genes =
    genes
    |> Seq.iter(fun x -> printGene x)

let shuffle genes =
    genes |> List.sortBy (fun gene -> random.Next())

let checkPopulationFitness genes =
    let avg = List.averageBy(fun ele -> float (fitness ele)) genes
    avg < 765.0

let rec doXSeries x geneSeq =
    let popFails = checkPopulationFitness geneSeq
    if x > 0 && popFails then
        let newSeq = doBreeding (Seq.toList geneSeq)
        let num = x - 1
        let result = doXSeries num (newSeq |> shuffle)
        result
    else
        printfn "%i" (10000 - x)
        geneSeq

[<EntryPoint>]
let main argv =
    let geneSeq = seq { for x in 1..16 -> randomGene() } |> Seq.toList
    ignore (printGenes geneSeq)

    printfn "\n"

    let newSeq = doXSeries 10000 geneSeq
    ignore (printGenes newSeq)

    0