using Distributions
using DataFrames
using Statistics

struct State
    a::Int
    b::Int
end

generate_state()::State = begin
    smaller = rand(DiscreteUniform(1, 50000), 1)[1]
    if rand(Bernoulli(0.5), 1)[1]
        return State(smaller, 2 * smaller)
    else
        return State(2 * smaller, smaller)
    end
end

is_definitely_smaller(pick::Int)::Bool = begin
    return pick == 1 || pick % 2 != 0
end

is_definitely_larger(pick::Int)::Bool = begin
    return pick > 50000
end

strategy_switch(state::State)::Int = begin
    local first_pick::Int
    local second_pick::Int
    if rand(Bernoulli(0.5), 1)[1]
        first_pick = state.a
        second_pick = state.b
    else
        first_pick = state.b
        second_pick = state.a
    end
    if is_definitely_larger(first_pick)
        return first_pick
    else
        return second_pick
    end
end

strategy_noswitch(state::State)::Int = begin
    local first_pick::Int
    local second_pick::Int
    if rand(Bernoulli(0.5), 1)[1]
        first_pick = state.a
        second_pick = state.b
    else
        first_pick = state.b
        second_pick = state.a
    end
    if is_definitely_smaller(first_pick)
        return second_pick
    else
        return first_pick
    end
end

do_simulation(n_iterations::Int)::DataFrame = begin
    switch = Vector{Float64}(undef, n_iterations)
    no_switch = Vector{Float64}(undef, n_iterations)
    for i = 1:n_iterations
        state = generate_state()
        switch[i] = convert(Float64, strategy_switch(state)) / 100.0
        no_switch[i] = convert(Float64, strategy_noswitch(state)) / 100.0
    end
    DataFrame(switch=switch, no_switch=no_switch)
end

n_iterations = 1000000
df = do_simulation(n_iterations)
mean.(eachcol(df))
std(df[:, "switch"]) / sqrt(n_iterations - 1), std(df[:, "no_switch"]) / sqrt(n_iterations - 1)