import pgzrun
from typing import List, Tuple, Optional

from labyrint import Labyrint
from los_labyrint import LosLabyrint

# Konstanter, IKKE ENDRE NAVN
WIDTH = 600
HEIGHT = 600
CELL_SIZE = 20

# rutenettst?rrelse
kolonner = WIDTH // CELL_SIZE
rader = HEIGHT // CELL_SIZE

# Farger (RGB)
VEGGFARGE = (0, 0, 0)         # Svart
STIFARGE = (0, 255, 0)       # Gr?nn
INNGANGFARGE = (0, 0, 255)      # Bl?
UTGANGFARGE = (255, 0, 0)       # R?d
BESOKTFARGE = (0, 100, 100)  # M?rk cyan
LOSNINGFARGE = (255, 255, 0) # Gul

# Globale instanser og tilstand
labyrint = Labyrint(kolonner=kolonner, rader=rader)
losning = LosLabyrint()

rutenett: List[List[int]] = []
inngang: Optional[Tuple[int, int]] = None
utgang: Optional[Tuple[int, int]] = None

besoksrekkefolge: List[Tuple[int, int]] = []
losningssti: List[Tuple[int, int]] = []
utgangsindeks: int = -1  # Indeksen til utgangen i lista visited_order

# Animasjonstilstand
aniamasjonsramme = 0
besokthastighet = 4  # Animasjonshastighet for bes?kte celler
stihastighet = 4     # Animasjonshastighet for l?snigen 

def generer_labyrint():
    global rutenett, inngang, utgang, besoksrekkefolge, losningssti, utgangsindeks, aniamasjonsramme
    labyrint.generer()
    rutenett = labyrint.hent_rutenett()
    inngang, utgang = labyrint.hent_ingang_og_utgang()

    # L?s labyrinten
    sti, besokt, funnet_utgang = losning.los(rutenett, inngang, utgang)
    besoksrekkefolge = besokt
    losningssti = sti

    # Finn posisjonen til utgangen listen over bes?kte celler
    utgangsindeks = besoksrekkefolge.index(utgang) if (funnet_utgang and utgang in besoksrekkefolge) else -1
    aniamasjonsramme = 0


    if utgang is not None:
        try:
            utgangsindeks = besoksrekkefolge.index(utgang)
        except ValueError:
            utgangsindeks = -1
    else:
        utgangsindeks = -1

    aniamasjonsramme = 0


def draw():
    screen.clear()
    screen.fill(VEGGFARGE)

    # Tegn stier
    for y in range(rader):
        for x in range(kolonner):
            if rutenett and rutenett[y][x] == 0:
                screen.draw.filled_rect(
                    Rect((x * CELL_SIZE, y * CELL_SIZE), (CELL_SIZE, CELL_SIZE)),
                    STIFARGE
                )

    # Animer bes?kte celler
    besoktsmengde = min(len(besoksrekkefolge), aniamasjonsramme * besokthastighet)
    for i in range(besoktsmengde):
        x, y = besoksrekkefolge[i]
        if (inngang and (x, y) == inngang) or (utgang and (x, y) == utgang):
            continue
        screen.draw.filled_rect(
            Rect((x * CELL_SIZE, y * CELL_SIZE), (CELL_SIZE, CELL_SIZE)),
            BESOKTFARGE
        )

    # Animer l?sningsstien S? SNART vi kommer til utgangen
    # Dvs. n?r visited_count > exit_index (og exit_index != -1)
    if utgangsindeks != -1 and besoktsmengde > utgangsindeks and losningssti:
        # Starttiden for sti-animasjon settes til (exit_index + 1) "enheter"
        enhet_naa = aniamasjonsramme * stihastighet - (utgangsindeks + 1)
        stimengde = max(0, min(len(losningssti), enhet_naa))

        for i in range(stimengde):
            x, y = losningssti[i]
            if (inngang and (x, y) == inngang) or (utgang and (x, y) == utgang):
                continue
            screen.draw.filled_rect(
                Rect((x * CELL_SIZE, y * CELL_SIZE), (CELL_SIZE, CELL_SIZE)),
                LOSNINGFARGE
            )

    # Tegn entry/exit til slutt
    if inngang:
        screen.draw.filled_rect(
            Rect((inngang[0] * CELL_SIZE, inngang[1] * CELL_SIZE), (CELL_SIZE, CELL_SIZE)),
            INNGANGFARGE
        )
    if utgang:
        screen.draw.filled_rect(
            Rect((utgang[0] * CELL_SIZE, utgang[1] * CELL_SIZE), (CELL_SIZE, CELL_SIZE)),
            UTGANGFARGE
        )


def update():
    global aniamasjonsramme
    aniamasjonsramme += 1


def on_key_down(key):
    global aniamasjonsramme
    if key == keys.SPACE:
        generer_labyrint()
    elif key == keys.R:
        aniamasjonsramme = 0


# Initialiser
generer_labyrint()
pgzrun.go()