from ezgraphics import GraphicsWindow

SIZEX = 10
SIZEY = 5
MINES = 5
SIZE_CELLA = 50   # dimensione in pixel di una cella

# STATO DEL GIOCO CHE OCCORRE MEMORIZZARE
#
# - quali celle sono state aperte e quali no
# - posizione delle mine
# - opzionale: il numero di mine attorno ad ogni cella
#   (questo è calcolabile dalla posizione delle mine, quindi lo possiamo
#   fare una volta per tutte nel momento che il gioco parte, o di volta in volta
#   quando una scopriamo una cella).

#  Come memorizziamo la posizione delle mine:
#  - matrice delle dimensioni del campo da gioco con valori booleni:
#    False => la mina non c'è,  True => la mina c'è
#  - in alternativa, una lista di lunghezza pari al numero delle
#    mine (costante MINES) contenete le coordinate dove si trovano
#    le mine. Es: [ (2,3), (0,4), (5,5), ...]
# Decidiamo per la prima implementazione.

# Come memorizziamo quali celle sono state aperte e quali no:
# - come prima, matrice di booleani con False => chiuso, True => aperto


def crea_matrice(num_colonne, num_righe):
    """
    Restituisce una matrice di num_righe righe e num_colonne colonne
    riempita con False.
    """
    risultato = []
    for _ in range(num_righe):
        risultato.append([False] * num_colonne)
    return risultato


def posiziona_mine(pmine, num_mine):
    """
    Aggiunge casualmente num_mine mine nel campo di gioco, operando
    sul posto. Attualmente è
    """
    # Invece di implementare questa funzione sul serio, per ora
    # scriviamo una versione preliminare che mette delle mine in posti
    # fissi per poter provare il resto del codice.
    pmine[1][1] = True
    pmine[1][2] = True
    pmine[2][3] = True
    pmine[3][3] = True


def disegna_griglia(canvas, num_colonne, num_righe):
    """
    Disegna sul canvas una grigli num_colonne * num_righe
    """
    # disegno linee verticali
    for i in range(num_colonne):
        canvas.drawLine(i * SIZE_CELLA, 0, i *
                        SIZE_CELLA, num_righe*SIZE_CELLA)
    # disegno linee orizzontali
    for i in range(num_righe):
        canvas.drawLine(0, i * SIZE_CELLA, num_colonne *
                        SIZE_CELLA, i * SIZE_CELLA)


def calcola_mine_adiacenti(pmine, x, y):
    """
    Resituisce il numero di mine adiacenti alla posizione (x,y).
    """
    # In pratica, per ora facciamp restituire sempre 1... poi dovremo
    # inmplementarla sul serio.
    return 1


def main():
    # inizializzare le variabili che contengono lo stato del gioco creando due matrici piene di False
    pmine = crea_matrice(SIZEX, SIZEY)
    paperti = crea_matrice(SIZEX, SIZEY)

    # decidere dove mettere le mine e aggiornare lo stato
    posiziona_mine(pmine, MINES)

    # inizializzare la parte grafica e visualizzare la griglia
    win = GraphicsWindow(SIZEX * SIZE_CELLA, SIZEY * SIZE_CELLA)
    canvas = win.canvas()
    win.setTitle("Campo Minato")
    disegna_griglia(canvas, SIZEX, SIZEY)

    # ripetutamente:
    while True:
        # accettare un click, ottenendo le coordinate del punto dove l'utente ha cliccato in termine di pixel
        x, y = win.getMouse()

        # convertire queste coordinate in termini di coordinate della celletta dove l'utente ha cliccato
        x = x // SIZE_CELLA
        y = y // SIZE_CELLA

        # se c'è una mina in quella posizione:
        if pmine[y][x]:
            # gioco finisce
            print("HAI PERSO!")
            break
        # altrimenti
        else:
            # calcolare qaunte sono le mine adiacenti
            mine_adiacenti = calcola_mine_adiacenti(pmine, x, y)

            # scoprire la cella e visualizzare il numero di mine adiacenti
            paperti[y][x] = True
            canvas.setFontSize(SIZE_CELLA)
            canvas.drawText(x * SIZE_CELLA, y * SIZE_CELLA, str(mine_adiacenti))

            # se il numero di mine adiacenti è zero, scoprira anche le celle vicine

            # se abbiamo scoperto tutte le celle tranne le mine:

            # abbiamo vinto


if __name__ == "__main__":
    main()