"""Ce fichier permet de dessiner une rue à l'aide des fonctions suivantes :
+ dessiner_rue_aleatoire()
+ dessiner_rue_decrite(rue:dict)
"""
 
 
# Importation
 
from dessiner import triangle_equilateral,rectangle
import random as rd

# Constantes
 
IMMEUBLE = 140
ETAGE = 80
COTE_FENETRE = 30
COTE_CARREAUX = COTE_FENETRE//2
HAUTEUR_PORTE = 50
 
# Fonction privées

def immeuble_aleatoire(numero:int) -> dict:
    """Génère des informations aléatoires pour un immeuble

    :: param numero (int) :: le numéro identifiant l'immeuble
    
    Renvoi un dictionnaire contenant les informations de l'immeuble avec les clés suivantes :
        - 'couleur_facade': Couleur de la façade de l'immeuble.
        - 'numero': Numéro de l'immeuble.
        - 'nb_etage': Nombre d'étages de l'immeuble (entre 1 et 5).
        - 'pos_porte': Position de la porte (0, 1 ou 2).
        - 'couleur_porte': Couleur de la porte (une couleur foncée aléatoire).
        - 'type_fenetre': Liste des types de fenêtres pour chaque étage (0, 1 ou 2).
        - 'type_toit': Type de toit (booléen, où False indique un toit rectangulaire et True un toit triangulaire).
        
    Fait par Iyad
    """
    informations = {}
    #info immeuble
    informations['couleur_facade'] = couleur_aleatoire()
    informations['numero'] = numero
    informations['nb_etage'] = rd.randint(1,5)
    #info porte
    informations['pos_porte'] = rd.randint(0,2)
    informations['couleur_porte'] = couleur_aleatoire_fonce()
    #info fenetre
    informations['type_fenetre'] = []
    for _ in range(informations['nb_etage']*3) :
        informations['type_fenetre'].append(rd.randint(0,2)) # 0 -> normal, 1 -> balcon, 2 -> carreaux
    #info toit
    informations['type_toit'] = bool(rd.randint(0,1)) # False -> rectangle, True -> triangle
    return informations

def couleur_aleatoire() -> str:
    """Permet de fournir une couleur aléatoire non foncée

    Renvoi un str qui contient une couleur non foncée parmis :
                "yellow","magenta","green","cyan"
                
    Fait par Iyad
    """
    couleur = ("yellow","magenta","green","cyan")
    return couleur[rd.randint(0,3)]

def couleur_aleatoire_fonce() -> str :
    """Permet de fournir une couleur aléatoire foncée

    Renvoi un str qui contient une couleur foncée parmis :
                "purple","red","blue","black"

    Fait par Louay
    """
    couleur = ("purple","red","blue","black")
    return couleur[rd.randint(0,3)]

def coordonnees_facade(immeuble:dict) -> tuple:
    """Calcule les coordonnées de la façade d'un immeuble

    :: param immeuble (dict) :: un dictionnaire contenant les informations de l'immeuble tel que :
        - numero : le numéro de l'immeuble
        
    Renvoi un tuple contenant les coordonnées (x_gauche, y_bas) de la façade de l'immeuble
    
    Fait par Louay
    """
    x_gauche = -400 + 200 * immeuble['numero']
    y_bas = 0
    return (x_gauche, y_bas)

def dessiner_facade(immeuble:dict) -> None:
    """Permet de dessiner la façade de l'immeuble

    :: param immeuble (dict) :: un dictionnaire contenant les informations de l'immeuble tel que :
        - couleur_facade : la couleur de la façade de l'immeuble
        - nb_etage : le n'ombre d'étages de l'immeuble
        
    Fait par Iyad
    """
    crayon = {}
    crayon['écriture'] = "gray"
    crayon['fond'] = immeuble['couleur_facade']
    crayon['épaisseur'] = 5
    x, y = coordonnees_facade(immeuble)  
    rectangle((IMMEUBLE,(immeuble['nb_etage']*ETAGE)),crayon,(x,y+(immeuble['nb_etage']+ETAGE)))

def dessiner_porte(immeuble:dict) -> None:
    """Permet de dessiner la porte d'un immeuble

    :: param immeuble (dict) :: un dictionnaire contenant les informations de l'immeuble tel que :
        - couleur_porte : la couleur de la porte
        - pos_porte : la position de la porte définie aléatoirement
        - nb_etages : le nombre d'étages de l'immeuble
        
    Fait par Louay
    """
    crayon = {}
    crayon['écriture'] = "gray"
    crayon['fond'] = immeuble['couleur_porte']
    crayon['épaisseur'] = 3
    x,y = coordonnees_facade(immeuble)
    y += ETAGE + 4
    x += 20 + (immeuble['pos_porte']) * 40
    rectangle((COTE_FENETRE,HAUTEUR_PORTE),crayon, (x,y))
    
    

def dessiner_fenetre(immeuble: dict) -> None:
    """Permet de tracer 3 types de fenêtres. Tel que une fenêtre simple mais aussi à carreaux ou avec un balcon.

    :: param immeuble (dict) :: un dictionnaire contenant les informations de l'immeuble tel que :
        - nb_etages : le nombre d'étages de l'immeuble
        - pos_porte : la position de la porte définie aléatoirement 
        - type_fenetre : une liste des types de fenêtres
        
    Fait par Louay et Iyad
    """
        
    crayon = {}
    crayon['écriture'] = "gray"
    crayon['fond'] = "cyan"
    crayon['épaisseur'] = 3
    nb_etages = immeuble['nb_etage']
    x_base, y_base = coordonnees_facade(immeuble)
    y_base += ETAGE + 20
    
    
    for etage in range(nb_etages):
        y = y_base + etage * ETAGE

        for colonne in range(3):
            x = x_base + 20 + colonne * 40
            type_fenetre = immeuble['type_fenetre']
            if etage == 0 and colonne == immeuble['pos_porte']:
                continue
            
            if immeuble['type_fenetre'][etage * 3 + colonne] == 0:
                rectangle((COTE_FENETRE, COTE_FENETRE), crayon, (x, y))
                
            elif immeuble['type_fenetre'][etage * 3 + colonne] == 1:
                rectangle((COTE_FENETRE, COTE_FENETRE), crayon, (x, y))
                rectangle((0, COTE_FENETRE), crayon, (x + COTE_CARREAUX, y))
                rectangle((COTE_FENETRE, 0), crayon, (x, y + COTE_CARREAUX))
                
            elif immeuble['type_fenetre'][etage * 3 + colonne] == 2:
                rectangle((COTE_FENETRE, HAUTEUR_PORTE), crayon, (x, y - 20))
                for i in range(5):
                    rectangle((0, COTE_FENETRE + 3), crayon, (x + i * 7, y - COTE_CARREAUX - 3))
                rectangle((COTE_FENETRE, 0), crayon, (x, y + COTE_CARREAUX))
                
def dessiner_toit(immeuble:dict) -> None:
    """Permet de dessiner 2 types de toits tel que pointu ou plat

    :: param immeuble (dict) :: un dictionnaire contenant les informations de l'immeuble tel que :
        - type_toit : indique le type de toit définie par un booléen
        - nb_etage : nombre d'étages de l'immeuble
        
    Fait par Iyad
    """
    crayon = {}
    crayon['écriture'] = "black"
    crayon['fond'] = "black"
    crayon['épaisseur'] = 5
    x, y = coordonnees_facade(immeuble)  
    x -= 10
    y += (immeuble['nb_etage']+1) * ETAGE
    if immeuble['type_toit'] == False :
        dim = (20 + IMMEUBLE), 20
        rectangle(dim, crayon, (x,y))
    else :
        dim = (20 + IMMEUBLE)
        triangle_equilateral(dim, crayon, (x,y))
        
def dessiner_immeuble(immeuble:dict) -> None:
    """Permet de dessiner un immeuble complet

    :: param immeuble (dict) :: un dictionnaire contenant toutes les informations de l'immeuble
    
    Fait par Iyad
    """
    dessiner_facade(immeuble)
    dessiner_fenetre(immeuble)
    dessiner_porte(immeuble)
    dessiner_toit(immeuble)
 
# Fonction publiques
 
def dessiner_rue_aleatoire() -> None:
    """Permet de dessiner une rue contenant 4 immeubles aux caractéristiques définies aléatoirement
    """
    for n in range(rd.randint(1,4)):
        informations_immeuble = immeuble_aleatoire(n)
        dessiner_immeuble(informations_immeuble)
        
def dessiner_rue_decrite(rue:list) -> None:
    """Permet de dessiner une rue contenant 4 immeubles aux caractéristiques définies dans ma_rue.txt
    """
    for dictionnaire in rue :
        dessiner_immeuble(dictionnaire)
        


# Programme principal
 
if __name__ == '__main__':
    dessiner_rue_aleatoire()