import random
import datetime
import numpy
import matplotlib.pyplot as plt
plt.rcParams["figure.figsize"] = (5,3)

class Case:
    """ Esta clase maneja la lógica del juego.
        * Se esconde un premio en una de las puertas 
        * Se puede elegir una puerta (pick)
        * Se puede ver tras una puerta al azar (que no tenga premio) (getdoor)
        * Finalmente se puede mantener la elección (hold) o cambiar de elección (change)
    """
    def __init__(self, doors = 3):
        self.ndoors = doors
        self.doors = list(range(1,self.ndoors+1))
        self.car = random.randint(1,self.ndoors)
    def pick(self, ):
        self.picked = random.choice(self.doors)
        self.doors.remove(self.picked) # Can't pick it again
    def getdoor(self):
        for i in range(0, 20):
            self.opendoor = random.choice(self.doors)
            if self.opendoor != self.car:
                self.doors.remove(self.opendoor)  # Can't pick an opened door
                return
        raise Exception("couldn't find a non-car door")
    def hold(self, ):
        pass
    def change(self):
        self.pick()
    def iscar(self, n = None):
        return self.car == (n if n is not None else self.picked)

# Hold strategy:
def hold_strategy(n = 1000):
    wins = 0
    data = []
    for i in range(0,n):
        c = Case()
        c.pick()
        c.hold()
        wins += 1 if c.iscar() else 0
        data.append(wins/(i+1))
    return data, wins
ps = []
n = 200
plt.grid(); plt.axhline(1/3, color="red")
for i in range(50):  
    #random.seed(i)
    data, wins = hold_strategy(n)
    plt.plot(data, linewidth=0.6, alpha=0.6); 
    ps.append(wins/len(data))

plt.title("p = " + str(numpy.mean(ps)))
plt.xlabel("casos"); plt.ylabel("probabilidad")
plt.show()

# Change strategy:
def change_strategy(n = 1000):
    wins = 0
    data = []
    for i in range(0,n):
        c = Case()
        c.pick()
        c.getdoor()
        c.change()
        wins += 1 if c.iscar() else 0
        data.append(wins/(i+1))
    return data, wins
plt.grid(); plt.axhline(2/3, color="red")
ps = []
n = 200
for i in range(50):  
    data,wins = change_strategy(n)
    plt.plot(data, linewidth=0.6, alpha=0.6)
    ps.append(wins/len(data))
plt.title("p = " + str(numpy.mean(ps)))
plt.xlabel("casos"); plt.ylabel("probabilidad")
plt.show()

class Loteria:
    def __init__(self, boletos = 10):
        self.ganador = random.randint(1,boletos)
        self.boletos = list(range(1,boletos+1))
    def get_boleto(self):
        boleto = random.choice(self.boletos)
        self.boletos.remove(boleto)
        return boleto
    def wins_boleto(self, b):
        return self.ganador == b

def TestLoteria(tries = 200):
    hold = 0.0; change = 0.0; bchange = 0; bhold = 0
    for i in range(tries):
        lot = Loteria(3)
        a = lot.get_boleto()
        b1, b2 = lot.get_boleto(), lot.get_boleto()
        if not lot.wins_boleto(b1):
            hold += 1 if lot.wins_boleto(a) else 0
            change += 1 if lot.wins_boleto(b2) else 0
            bchange += 1 if lot.wins_boleto(a) else 0
            bhold += 1 if lot.wins_boleto(b2) else 0
        else:
            bchange += 1
            bhold += 1
    return hold/tries, change/tries, bchange/tries, bhold/tries

results = TestLoteria(10000)
print("Ana - prob. de ganar si se queda (hold): ", results[0])
print("Ana - prob. de ganar si cambia (change): ", results[1])
print("Beto - prob. de ganar si se queda (hold): ", results[2])
print("Beto - prob. de ganar si cambia (change): ", results[3])

import itertools
import pomegranate
import pandas as pd

def get_cond_prob(case):
    # case[0] ==> participante
    # case[1] ==> premio
    # case[2] ==> presentador
    # El presentador nunca abre la puerta con premio ni la misma puerta que el participante
    if case[1] == case[2] or case[0] == case[2]:
        return 0
    # El presentador abre ambas puertas por igual si no tienen premio
    if case[0] == case[1]:
        return 1/2
    # Si el participante no elige el premio inicialmente entonces el presentador sólo puede abrir la puerta sin premio
    if case[0] != case[1] and case[1] != case[2]:
        return 1
table = []
for case in itertools.product("123", "123", "123"):
    table.append( [ case[0], case[1], case[2], get_cond_prob(case) ] )

pd.DataFrame(table, columns=["Participante", "Premio", "Presentador", "CondProb"])

participante = pomegranate.distributions.DiscreteDistribution({'1': 1./3, '2': 1./3, '3': 1./3})
premio = pomegranate.distributions.DiscreteDistribution({'1': 1./3, '2': 1./3, '3': 1./3})
presentador = pomegranate.distributions.ConditionalProbabilityTable(table, [participante, premio])

# Ahora un poco de copy/paste para reusar el modelo del ejemplo de Pomegranate. 
# Aquí se construye la red bayesiana:
s1 = pomegranate.State(participante, name="partcp")
s2 = pomegranate.State(premio, name="premio")
s3 = pomegranate.State(presentador, name="prestdr")
model = pomegranate.BayesianNetwork("Monty Hall Problem")
# Add the three states to the network 
model.add_states(s1, s2, s3)
# Add edges which represent conditional dependencies, where the second node is 
# conditionally dependent on the first node (Monty is dependent on both guest and prize)
model.add_edge(s1, s3)
model.add_edge(s2, s3)
model.bake()

# Se deja en None el estado en la red bayesiana que se quiere predecir.
model.predict_proba([["1", None, "3"]])