# -*- coding:utf-8 -*-
############################
### ARE-DYNAMIC.py
###
### Auteurs:
###     julianb (3670170)
###     lucieho ()
###     nicolasbsn ()
###     constancepoulain ()
###

######################
### Importations

import numpy

######################
### Variables Globales

# Grille
Grille = numpy.ndarray()

# taille de la grille
TailleGrilleX = 15
TailleGrilleY = 15

# historique des grilles aux itérations précédentes
# utilisé durant l'affichage dynamique
HistoriqueGrilles = list()

# chaque StratsResultats[i] est un triplet [nb_utilisations, total_ans_prisons, utilisation_detail] avec:
#       i = index de la stratégie en question
#       nb_utilisations = nombre total d'utilisations de la stratégie
#       total_ans_prisons = total d'années de prisons subies par les utilisateurs de la stratégie
#       utilisation_detail = une liste de paires (iter, uti) représentant le nombre d'utilisateurs à l'itération "iter"
StratsResultats = list()

# liste des stratégies (fonctions Coord^2 -> bool décidant si un joueur nie ou non en fonction de son adversaire)
ListeStrategies = list()

# liste des fonctions génératrices de grille
ListeGenGrille = list()

# génératrice de grille à utiliser
TypeGrilleInitiale = 0

"""
Types:
    Coord = type(x, y)
    Joueur = dict("etat", "historique_etats", "strategie", "historique_strategies", "annees_de_prison")
    GrilleJoueurs = matrice2d(Joueur)
"""

#####################################
### Génération de la matrice initiale
def gen_matrice_initiale():
    """
        NoneType -> GrilleJoueurs
    """
    fonction_gen = ListeGenGrille[TypeGrilleInitiale]
    
    return fonction_gen()

##############################
### Execution des tours / jeux

def partie1v1(joueur, adversaire):
    """
        Joueur^2 -> int
        
        Effectue une partie à deux joueurs
        Renvoie: paire (prison_joueur, prison_adversaire)
    """

    stratj = ListeStrategies[joueur["strategie"]]
    strata = ListeStrategies[adversaire["strategie"]]
    
    etatj = stratj(joueur, adversaire)
    etata = strata(adversaire, joueur)
    
    # 1 = avouer
    # 0 = nier
    if etatj == 0:
        if etata == 0:
            # nie-nie
            ans_prison = (2, 2)
        else:
            # nie-avoue
            ans_prison = (10, 0)
    else:
        if etata == 0:
            # avoue-nie
            ans_prison = (0, 10)
        else:
            # avoue-avoue
            ans_prison = (5, 5)
    
    resj = StratsResultats[joueur["strategie"]]
    resa = StratsResultats[adversaire["strategie"]]
    
    resj[0] += 1 # utilisation supplémentaire
    resj[1] += ans_prison[0]
    resa[0] += 1
    resa[1] += ans_prison[1]
    
    joueur["annees_de_prison"] += ans_prison[0]
    adversaire["annees_de_prison"] += ans_prison[1]
    
    return ans_prison

def partie8tours(coord_joueur):
    """
        Coord ->
    """
    pass

def partie_globale(mat):
    """
        GrilleJoueurs -> GrilleJoueurs
    """
    pass

##############
### Simulation

def simulation():
    pass

####################################
### Affichage et interface graphique

#####################################
### Fonction génératrices de matrices

def init_liste_gen_grilles():
    """
        NoneType -> NoneType
        
        Rajoute à ListeGenGrille toutes les fonctions de génération de grille
    """
    pass

#######################
### Fonction stratégies

def init_liste_strategies():
    """
        NoneType -> NoneType
        
        Rajoute à ListeStrategies toutes les fonctions stratégies
    """
    pass