WordZap 1.2

import random

#-------------------------------------------------------------------------
#TODO
#-------------------------------------------------------------------------

#-------------------------------------------------------------------------
# Funciones
#-------------------------------------------------------------------------
def restart():
    """ Reinicializa todo de nuevo """
    global chosen
    global ordered

    chosen = getSample()
    ordered = sorted(chosen)

    return ordered


def getSample():
    """ Regresa una muestra de 9 letras entre el alfabeto disponible """
    chosen = random.sample(letters,9)
    return chosen

def fill(letter,its):
    """ Llena its veces la letra que corresponda al alfabeto """
    for i in range(its):
        letters.append(letter)

def compare(x,y):
    """ Compara x vs y para ordenarlos en getValues """
    key_of_x=x[1]
    key_of_y=y[1]
    if key_of_x > key_of_y:
        return -1
    elif key_of_x < key_of_y:
        return 1
    else:
        return 0

def getValues(ordered):
    """ Regresa una lista ordenada de los valores de las letras escogidas """
    for i in ordered:
        if i in dictionary:
            values.append(dictionary.get(i))

    zipo2 = zip(ordered,values)
    order_by_value = sorted(zipo2,cmp=compare)
    return order_by_value

def busqueda(search_terms, resultados):
    """ Busca en el archivo palabras con las letras indicadas dentro de un arreglo """
    archivo.seek(0) #Principio del archivo
    resultados = []
    for word in archivo:
        for i in search_terms:
            word = word.rstrip()                    #Eliminar saltos de linea
            if word.find(i) != -1:
                resultados.append(word)
    return resultados

def toRAM(resultados):
    """ Agrega las palabras de los resultados al diccionario 'palabras' """
    palabras.clear()
    for word in resultados:
        if word not in palabras:
            palabras[word] = [resultados.count(word), len(word)]
    return palabras

def doubleCheck(palabras, chosen):
    """ Revisa los resultados y devuelve las palabras finales """
    flagged = []

    for word in palabras:
        if palabras.get(word)[0] < palabras.get(word)[1]:
            flagged.append(word) #Si tiene menos coincidencias que caracteres

    for word in flagged: #Borra palabras marcadas
        del palabras[word]

    used_chars = []
    finales = []
    palabrillas = palabras.keys()


    for word in palabrillas:

        available = list(chosen)
        used_chars[:] = []
        actual_word = list(word)

        for current_char in actual_word:
            if current_char in available:
                used_chars.append(current_char)
                available.remove(current_char)

        sorted(actual_word)
        sorted(used_chars)
        available[:]= []

        if actual_word == used_chars:
            finales.append(word)



    return finales

def learning():
    """ Entra al modo de aprendizaje en modo manual """
    archivo.seek(0,2) #Final del archivo
    pico = 'y'
    while pico == 'y':
        archivo.write(raw_input("Word? --> ") + "\n")
        pico =raw_input("\nOtra? y)Yes Otherwise) no --> ")
        archivo.flush()

def learn(wordlist):
    """ Copia las palabras al archivo """
    archivo.seek(0,2) #Final del archivo
    for word in wordlist:
        archivo.write(word + "\n")
        archivo.flush()

def validate(word):
    """ Valida word dentro de la db completa, regresa 1 si la encuentra, 0 si no """

    fulldb = open("dbval", "r")
    fulldb.seek(0)
    wordys = []

    for palabra in fulldb:
        palabra = palabra.rstrip()  #Eliminar saltos de linea y espacios
        wordys.append(palabra)

    if word in wordys:
        check = 1
    else:
        check = 0

    return check



def play():
    """ Comienza el juego"""
    wordlist = []
    global resultados
    global chosen

    chars_used = []

    restart()
    resultados = busqueda(ordered, resultados)
    palabras = toRAM(resultados)
    print "Las palabras de la AI son:\n" + str(doubleCheck(palabras, ordered))
    print "Las letras que tocaron ahora son:\n" + str(chosen)
    print "Typea tus palabras: "
    for word in range(10):
        word = raw_input("--> ")
        if (word == 'nvm'):
            break

        elif validate(word) == 0:
            print "La palabra " + word + " no existe"

        elif word not in resultados:
            wordy = list(word)
            for char in wordy:
                if char not in chosen:
                    print "No puedes formar la palabra " + word + " con estos caracteres"
            wordlist.append(word)

        else:
            print "La palabra " + word + " ya esta en el diccionario"

    for word in wordlist:
        if word not in resultados:
            archivo.write(word+"\n")
            archivo.flush()
        else:
            print "La palabra " + word + " ya esta en el diccionario"
#-------------------------------------------------------------------------
# Main & Globals
#-------------------------------------------------------------------------

# Inicia todo ~~~~~~~
lulz = "abcdefghijklmnopqrstuvwxyz"
letters = list(lulz)
its = [15,6,5,7,15,4,6,9,15,2,5,5,8,13,11,2,0,10,11,5,10,2,6,4,2,2]
zipo = zip(letters,its)
dictionary = dict(zipo)
for (x,y) in zipo:
    fill(x,y)   #

values = [] #Valores de las letras escogidas
resultados = [] #Resultados de busqueda
chosen = getSample() #Las 9 letras escogidas
ordered = sorted(chosen) #Las 9 letras escogidas, pero en orden alfabetico
values = getValues(ordered) #Los valores ordenados de las letras escogidas
archivo = open('dblol', 'r+') #Abre la db en modo lectura/escritura
palabras = {} #Diccionario en RAM de los resultados encontrados en la db
palabras = toRAM(resultados)

again = '1'
while again == '1':
    play()
    again = raw_input("Otra vez? 1) Si Otherwise No --> ")