using namespace System.Collections.Generic; # for List

# define classes
class Card {
    [int16] $value

    Card([int16] $value) {
        $this.value = $value
    }
}

class Stack {
    [List[Card]] $cardList

    Stack() { [List[Card]] $this.cardList = @() }

    [int] Count() { return $this.cardList.Count }

    [Card] Deal($i) {
        $dealtCard = $this.cardList[$i]
        $this.cardList.RemoveAt($i)
        return $dealtCard
    }

    [void] Add([Card]$card) { $this.cardList.Add($card) }

    [int] Sum() {
        $sum = 0
        foreach ($card in $this.cardList) { $sum += $card.value }
        return $sum
    }
}


class Deck : Stack {
    Deck() {
        $startingDeck = @(
            @{ value = 2; number = 9 },
            @{ value = 3; number = 9 },
            @{ value = 4; number = 11 },
            @{ value = 5; number = 7 }
        )

        $startingDeck.ForEach({
                $thisValue = $_.value
                $thisNumber = $_.number

                for ($i = 0; $i -lt $thisNumber; $i++) {
                    $this.Add([Card]::new($thisValue))
                }
            })
    }

    [Card] Deal() {
        $deckCount = $this.Count()

        $randomNumber = if ($deckCount -gt 1) {
            Get-Random ($deckCount - 1)
        }
        else {
            0
        }

        $dealCard = $this.Deal($randomNumber)

        return $dealCard
    }
}

# define simulation functions

function pushYourLuck ([Deck] $deck) {
    $revealedCard = $deck.Deal()
    $revealPile.Add($revealedCard)
}

function simulate {
    
    $deck = [Deck]::new()
    $revealPile = [Stack]::new()

    while ($revealPile.Sum() -lt 7) {
        pushYourLuck($deck)
    }
    # Write-Host Total is $revealPile.Sum(), result is $result, $revealPile.Count() cards revealed.

    return [Stack] $revealPile
}

# set up simulation

$lives = 50000

[List[Stack]] $results = @()

[List[List[int]]] $resultsJson = @()

# run simulation

for ($l = $lives; $l -gt 0; $l --) {
    $revealPile = simulate
    $results.Add($revealPile)
}

# make results into in a list of lists of just numbers

$results | ForEach-Object {
    # each object here is an array of Cards
    [List[int]] $numbers = @()
    $_.cardList | ForEach-Object {
        # each object here is a Card
        $numbers.Add($_.value)
    }
    $resultsJson.Add($numbers)
}

# save results

$resultsJson | ConvertTo-Json | Out-File "$root\gamble.json"

// results
let
    Source = Json.Document(File.Contents(root & "\gamble.json")),
    #"Converted to Table" = Table.FromList(Source, Splitter.SplitByNothing(), null, null, ExtraValues.Error),
    Column1 = #"Converted to Table"[Column1]
in
    Column1

// analysis

let
    subset = results,

    maxNumberOfCards = List.Max(List.Transform(
        results, 
        each List.Count(_)
    )),
    
    limit = 7, 

    cardSequence = {1..maxNumberOfCards}, 

    makeCountRecord = (countingFunction as function) as record=> 
        let 
            values = List.Transform(
                cardSequence,
                countingFunction
            ),
            fieldNames = List.Transform(
                cardSequence,
                each "Card " & Text.From(_)
            )
        in Record.FromList(values, fieldNames),
    
    // counting functions
    count = (subset as list, cardNumber as number) as number => 
        List.Count(List.Select(subset, each List.Count(_) >= cardNumber)),
    
    blackjack = (subset as list, cardNumber as number) => 
        List.Count(
            List.Select(
                subset, 
                each List.Count(_) >= cardNumber
                and List.Sum(List.FirstN(_, cardNumber)) = limit )
        ) / count(subset, cardNumber),
    
    bust = (subset as list, cardNumber as number) =>
        List.Count(
            List.Select(
                subset, 
                each List.Count(_) >= cardNumber
                and List.Sum(List.FirstN(_, cardNumber)) > limit )
        ) / count(subset, cardNumber),
    
    live = (subset as list, cardNumber as number) =>
        List.Count(
            List.Select(
                subset, 
                each List.Count(_) >= cardNumber
                and List.Sum(List.FirstN(_, cardNumber)) < limit )
        ) / count(subset, cardNumber),
    
    // make "columns"
    makeResultsRecord = (subset as list, startingValue as number) as record => [
        startingValue = [Card 1 = startingValue],
        // count = makeCountRecord( each count(subset, _) ), 
        blackjack = makeCountRecord( each blackjack(subset, _) ),
        bust = makeCountRecord( each bust(subset, _) ),
        live = makeCountRecord( each live(subset, _) )
    ], 

    // these are the card values in the deck
    cardValues = {2, 3, 4, 5},

    subsets = List.Transform(
        cardValues, 
        each 
            let 
                thisCardValue = _,
                subset = List.Select(
                    results, 
                    each _{0} = thisCardValue
                )
            in makeResultsRecord(subset, thisCardValue)
    ),

    expandRecord = (subset as record) as table => 
        let
            convertToTable = Record.ToTable(subset),
            columnNames = Record.FieldNames(convertToTable[Value]{1}),
            expanded = Table.ExpandRecordColumn(convertToTable, "Value", columnNames, columnNames)
        in
            expanded,

    combined = Table.Combine(
        List.Transform(
            subsets,
            each expandRecord(_)
        )
    ),
    #"Changed Type" = Table.TransformColumnTypes(combined,{{"Card 2", Percentage.Type}, {"Card 3", Percentage.Type}, {"Card 4", Percentage.Type}})

in
    #"Changed Type"