# -*- coding: cp1252 -*-
###############################
### Mini-projet MasterMind ####
###  Nio - Piveteau 2S-04  ####
###       Version 01/02    ####
###############################



###############################
### Importation des Modules ###
###############################


from random import *
from sys import exit
from math import *

###############################
######### Fonctions ###########
###############################


def top() :
    '''
    Affiche le texte lors du lancement du jeu
    '''
    print '###############################'
    print '### Mini-projet MasterMind ####'
    print '###  Nio - Piveteau 2S-04  ####'
    print '###       Version 01/02    ####'
    print '###############################'
    return 


def alea(nombre=6,vide=0) :
    '''
    Génére un tableau de X couleurs alétoire, par défault 6 tirages SANS REMISE,
    nombre -> nombre de le pions.
    vide   -> si l'ordinateur est autorisé à tiré au sort un emplacement sans
    aucune
    couleur (pour le niveau EXPERT uniquement )
    '''

    # initialisation du tableau à NOMBRE ELEMENT
    # ex pour nombre = 6 -> t = [0,0,0,0,0,0]
    t = []
    for i in range(nombre) :
        t.append(0)

    # Tirage au sort de 6 nombre parmi les couleurs dispos et insertion dans t
    i = 0
    while (i < nombre) :
       # tirage de UN élement        # insertion de l'élement dans le tableau t
        t[i] = randint(1,8)
        i = i+1
    return t



def win(compteur,coef) :
    '''
    est utilisé lorsque le joueur a trouvé la combinaison EXACTE
    compteur -> nombre d'essai du joueur
    coef     -> indice multiplicateur (1,2,3 ou 4) en fonction du niveau
    '''
    score = compteur*coef
    print ''
    print '*********** Félicitation **************'
    print 'vous avez gagné !!!!!! votre score :',
    print score

def lose(score=0) :
    '''
    fonction appelée lorsqu'un joueur n'a pas pas trouvé la solution avec ces X essais
    '''
    print 'vous avez perdu'
    
def checkcolorok(t,proposition) :
    '''
    vérifie le nombre de pions appartenant à la combinaison. 
    couleurok -> renvoi le nombre de pions correctement placés
    '''

    # on initialise le nombre de pions trouvé dans la combinaison
    couleurok = 0

    # Boucle 1 : on partout les élément de la proposition du joueur
    for i in range(len(proposition)) :

            # Boucle 2 : on partout les élément de la solution tout en étant dans la boucle 1
        for j in range(len(t)) :

                        # si un pion de la solution correspond à un pion de la proposition on incrémente le compteur couleurok
                        if proposition[i] == t[j] :
                            couleurok = couleurok +1
    
    return couleurok

def check(historyessai,t,proposition,compteur) :
    '''
    Cette fonction vérifie la proposition du joueur en 2 étapes :
    - Calcul du nombre de pions bien placés.
    - Calcul du nombre de pions qui appartiennent à la combinaison. (via la fonction checkcolorok)
    
    historyessai -> tableau contenant l'historique des différents essais du joueur
    ainsi que les nombres de pions bien placés et présent dans la combinaison
    t -> tableau contenant la solution, c'est la combinaison générée aléatoirement
    par l'ordinateur
    proposition -> c'st le tableau contenant la proposition du joeur

    La fonction va donc comparer le tableau t avec le tableau proposition..
    '''
    
    #recherche d'élement correctement placé
    placeok = []
    for i in range(len(t)) :
        if t[i] == proposition[i] :
            placeok.append(i+1)

    # recherche d'élement contenu dans la propostion
    couleurok = checkcolorok(t,proposition)

    # on ajoute l'essai au tableau d'historique des essais :
    historyessai.append([placeok,couleurok,proposition,compteur])
    
    # on retourne le tableau de l'
    return historyessai
    
def proposition(level) :
        '''
        
        '''
        
        # on tire au sort un numéro à l'aide la fonction alea (par défault 6pions)
        t = alea()

        # la partie n'a pas commencé donc pour le moment on a pas gagné..
        winok = False

        #on initialise l'historique des essais
        historyessai = []
        
        print t
        print ''
        print '*************** C\'est parti *******************************************'
        print 'l\'ordinateur a généré une combinaison aléatoire, à vous de la trouver !'
        print '*************  GOOOOO !!!!! ********************************************'
        for a in range (level[2]) :
            if a != 0 :
                ## si ce n'es pas le 1er essai (a != 0) c'est qu'il y a
                ## eu une proposition incorrect..
                print ''
                print 'Proposition incorrect... essayer à nouveau'
                for o in range(len(checking)) :
                    printplaceok = ''
                    if level[4] == 1 :
                        printplaceok = checking[o][0]
                    print '* Essai N°', checking[o][3] ,' - ', 'avec la combinaisaion', checking[o][2], ':', len(checking[o][0]), 'pion(s) correctement placé(s) ',checking[o][0],'-', checking[o][1], 'pion(s) appartenant(s) à la combinaison.'
            else :
                print ''
                print level[5]
            # on prend compteur = a+1 car a est la position dans le tableau,
            #compteur + 1 sera donc le nombre exact de propositions deja effectuées
            compteur = a+1

            ### On affiche le nombre de propositions deja effectués...
            print ''
            print 'proposition',
            print compteur,
            print '/',
            print level[2]
            
            # on demande à l'utilisateur de rentrer une proposition..
            proposition = input('Effectuer une proposition :')
            
            # si les tableau sont identiques, c'est gagné !
            if t == proposition :
                
                winok = True
            
                # on lance la fonction victoire
                win(compteur,level[0])
                
                # on arrete tout car le joueur a gagné..
                break
            
            # sinon on vérifie le nombre de pions bien placés..
            else :
                checking = check(historyessai,t,proposition,compteur)

        # SORTIE DE LA BOUCLE DE DEMANDE DE PROPOSITION
        # si le nombre d'essai est finis et que la solution n'a pas été trouvé
        # c'est perdu !
        if winok == False :
            lose()

            
        return level
        #### fin de la fonction proposition ####


def alllevel() :
    '''
    fonction contenant tout les niveaux de difficulté
    '''
        #### [id_level,nom_level,essai_dispo,affichage_bien_placées,trou_combinaisaon] ####
    #### initialistion du tableau tlevel contenant les tableaux de niveau
    tlevel = [[],[],[],[]]
    # on insére les différents tableaux de niveau dans le tableau tlevel
    tlevel[0] =  [1,'Niveau Expert',10,0,1,'Help expert']
    tlevel[1] =  [2,'Niveau Difficile',6,0,0,'Help difficile']
    tlevel[2] =  [3,'Niveau Intermédiaire',10,0,0,'Help intermédiaire']
    tlevel[3] =  [4,'Niveau Facile',10,1,0,'niveau facile']
    print tlevel
    return tlevel

def showlevel(tlevel):
    '''
    on affiche les différents niveaux
    '''
    k = 0
    print ''
    print ''
    print '******* Choix du niveau ***********'
    while (k < len(tlevel)) :
        print tlevel[k][0],
        print ' - ',
        print tlevel[k][1]
        k = k +1
    return k

def chooselevel() :
    '''
    demande à l'utilisateur de choisir un niveau
    '''
    
    # demande à l'utilisateur de rentrer le niveau choisit
    level = input('Choissisez votre niveau de difficulté :')
    
    # si le niveau est différents de 1,2,3 ou 4 alors nouvelle demande
    while (level != 1 and level != 2 and level != 3 and level != 4) :
            level = input('Choissisez votre niveau de difficulté (1,2,3 ou 4 uniquement ):')
            
    # on enlève 1 à level car un tableau commence à 0 et non à 1..
    level = level - 1

    return level

def start() :
    '''
    Fonction qui lance le jeu, elle sert a présenter les différents niveau...
    '''

    # on récupére les niveaux
    tlevel = alllevel()
    
    #on affiche les différents niveau
    showlevel(tlevel)

    #on demande à l'utilisateur de choisir un niveau
    level = chooselevel()
    
    # on enregistre le niveau choisit par l'utilisateur dans la variable level
    level = tlevel[level]
    
    # on commence l'affichage ou le joueur pourra proposer ses solutions
    proposition(level)

    # la partie est terminé ? on recommence !
    start()
    
    return level
    ### fin de la fonction start ###


############################
####### EXECUTION ##########
############################

# on affiche le texte de départ
top()
# et c'est parti !
start()