import pyray as pr
import numpy as np
import argparse
import createtrack
import math
import random

GRID = 8
TRACK_QUADS = 4
TRACK_WIDTH = GRID * TRACK_QUADS
INNER_WIDTH = TRACK_WIDTH - GRID

def ammorbidisci_pista(punti, precisione=25):
    out = []
    n = len(punti)
    for i in range(n):
        p0, p1, p2, p3 = punti[(i-1)%n], punti[i], punti[(i+1)%n], punti[(i+2)%n]
        for ti in range(precisione):
            t = ti / precisione
            x = 0.5*((2*p1.x)+(-p0.x+p2.x)*t+(2*p0.x-5*p1.x+4*p2.x-p3.x)*t*t+(-p0.x+3*p1.x-3*p2.x+p3.x)*t*t*t)
            y = 0.5*((2*p1.y)+(-p0.y+p2.y)*t+(2*p0.y-5*p1.y+4*p2.y-p3.y)*t*t+(-p0.y+3*p1.y-3*p2.y+p3.y)*t*t*t)
            out.append(pr.Vector2(x, y))
    return out

def genera_pista(seed):
    np.random.seed(seed)
    tg = createtrack.CreateTrack(
        num_points=18,
        x_bounds=[20, 180],
        y_bounds=[20, 180],
        corner_cells=2,
        seed=seed
    )
    raw = tg.create_racetrack(False)
    pts = [pr.Vector2(float(p[0]), float(p[1])) for p in raw]
    return ammorbidisci_pista(pts, precisione=6)

def disegna_sfondo(cam, sx, sy):
    step = GRID
    bold = 5
    x0 = int((cam.target.x - sx/cam.zoom)//step)*step
    x1 = int((cam.target.x + sx/cam.zoom)//step)*step
    y0 = int((cam.target.y - sy/cam.zoom)//step)*step
    y1 = int((cam.target.y + sy/cam.zoom)//step)*step
    for x in range(x0, x1, step):
        pr.draw_line(x, y0, x, y1, pr.LIGHTGRAY if (x//step)%bold else pr.GRAY)
    for y in range(y0, y1, step):
        pr.draw_line(x0, y, x1, y, pr.LIGHTGRAY if (y//step)%bold else pr.GRAY)

def disegna_tubo(punti, raggio, colore):
    for p in punti:
        pr.draw_circle_v(p, raggio, colore)

def disegna_pista(punti):
    disegna_tubo(punti, TRACK_WIDTH//2, pr.GRAY)
    disegna_tubo(punti, INNER_WIDTH//2, pr.RAYWHITE)
    disegna_tubo(punti, TRACK_WIDTH//2 + 1, pr.BLACK)

def disegna_partenza(punti, idx):
    p1 = punti[idx]
    p2 = punti[(idx+1)%len(punti)]
    dx, dy = p2.x-p1.x, p2.y-p1.y
    d = math.hypot(dx, dy)
    if d < 0.01: return
    nx, ny = -dy/d, dx/d
    h = TRACK_WIDTH//2 + GRID
    a = pr.Vector2(p1.x+nx*h, p1.y+ny*h)
    b = pr.Vector2(p1.x-nx*h, p1.y-ny*h)
    pr.draw_line_ex(a, b, 3, pr.RED)

if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument('--screen_x', type=int, default=1200)
    parser.add_argument('--screen_y', type=int, default=750)
    args = parser.parse_args()

    seed = np.random.randint(0, 2**31-1)
    punti = genera_pista(seed)
    start_idx = random.randint(0, len(punti)-1)

    pr.init_window(args.screen_x, args.screen_y, "Notebook Track – ORGANIC TUBE")
    pr.set_target_fps(60)

    cam = pr.Camera2D(
        pr.Vector2(args.screen_x/2, args.screen_y/2),
        pr.Vector2(100, 100),
        0.0,
        3.0
    )

    while not pr.window_should_close():
        if pr.is_key_pressed(pr.KEY_SPACE):
            seed = np.random.randint(0, 2**31-1)
            punti = genera_pista(seed)
            start_idx = random.randint(0, len(punti)-1)

        pr.begin_drawing()
        pr.clear_background(pr.RAYWHITE)
        pr.begin_mode_2d(cam)

        disegna_sfondo(cam, args.screen_x, args.screen_y)
        disegna_pista(punti)
        disegna_partenza(punti, start_idx)

        pr.end_mode_2d()
        pr.end_drawing()

    pr.close_window()