import os
import numpy as np
from numba import njit, prange
from benchmark_common import G1
PARALLEL = os.environ.get("PLANET_NUMBA_PARALLEL", "0") == "1"
@njit(parallel=PARALLEL, cache=True)
def pairwise_accel_inplace_jit(m, r, a_out):
    """
    a_out に加速度を書き込む in-place 版。
    r2==0 の際は寄与をスキップしてゼロ割を回避（ウォームアップ等の安全策）。
    """
    N = r.shape[0]
    for i in prange(N):
        xi = r[i,0]; yi = r[i,1]; zi = r[i,2]
        ax = 0.0; ay = 0.0; az = 0.0
        for j in range(N):
            if i == j:
                continue
            dx = r[j,0]-xi; dy = r[j,1]-yi; dz = r[j,2]-zi
            r2 = dx*dx + dy*dy + dz*dz
            if r2 == 0.0:
                continue
            invr  = 1.0 / np.sqrt(r2)
            invr3 = invr * invr * invr
            s = G1 * m[j] * invr3
            ax += s*dx; ay += s*dy; az += s*dz
        a_out[i,0] = ax; a_out[i,1] = ay; a_out[i,2] = az

@njit(cache=True)
def potential_energy_jit(m, r):
    N = r.shape[0]
    U = 0.0
    for i in range(N):
        xi = r[i,0]; yi = r[i,1]; zi = r[i,2]
        mi = m[i]
        for j in range(i+1, N):
            dx = r[j,0]-xi; dy = r[j,1]-yi; dz = r[j,2]-zi
            dist = np.sqrt(dx*dx + dy*dy + dz*dz)
            U += G1 * mi * m[j] / dist
    return U

@njit(cache=True)
def kinetic_energy_jit(m, v):
    K = 0.0
    for i in range(m.shape[0]):
        vi2 = v[i,0]*v[i,0] + v[i,1]*v[i,1] + v[i,2]*v[i,2]
        K += 0.5 * m[i] * vi2
    return K

@njit(cache=True)
def momentum_jit(m, v):
    Px=0.0; Py=0.0; Pz=0.0
    for i in range(m.shape[0]):
        mi = m[i]
        Px += mi*v[i,0]; Py += mi*v[i,1]; Pz += mi*v[i,2]
    P2 = Px*Px + Py*Py + Pz*Pz
    Pmsm = np.sqrt(P2/(3.0*max(1, m.shape[0])))
    return Px, Py, Pz, Pmsm

@njit(cache=True)
def normalize_momentum_jit(m, v):
    Px=0.0; Py=0.0; Pz=0.0
    Mtot = 0.0
    for i in range(m.shape[0]):
        mi = m[i]; Mtot += mi
        Px += mi*v[i,0]; Py += mi*v[i,1]; Pz += mi*v[i,2]
    for i in range(m.shape[0]):
        v[i,0] -= Px/Mtot
        v[i,1] -= Py/Mtot
        v[i,2] -= Pz/Mtot

# --- JIT steppers: advance K steps in-place ---
@njit(cache=True)
def step_euler_k_jit(m, r, v, a, dt, k_steps):
    for _ in range(k_steps):
        v[:,0] += dt*a[:,0]; v[:,1] += dt*a[:,1]; v[:,2] += dt*a[:,2]
        r[:,0] += dt*v[:,0]; r[:,1] += dt*v[:,1]; r[:,2] += dt*v[:,2]
        pairwise_accel_inplace_jit(m, r, a)
    return a

@njit(cache=True)
def step_verlet_k_jit(m, r_prev, r, v, a, dt, k_steps):
    # r_prev, r, v, a updated in-place; v is estimated from positions
    for _ in range(k_steps):
        r_new_x = 2.0*r[:,0] - r_prev[:,0] + (dt*dt)*a[:,0]
        r_new_y = 2.0*r[:,1] - r_prev[:,1] + (dt*dt)*a[:,1]
        r_new_z = 2.0*r[:,2] - r_prev[:,2] + (dt*dt)*a[:,2]
        v[:,0] = (r_new_x - r_prev[:,0])/(2.0*dt)
        v[:,1] = (r_new_y - r_prev[:,1])/(2.0*dt)
        v[:,2] = (r_new_z - r_prev[:,2])/(2.0*dt)
        r_prev[:,0], r[:,0] = r[:,0], r_new_x
        r_prev[:,1], r[:,1] = r[:,1], r_new_y
        r_prev[:,2], r[:,2] = r[:,2], r_new_z
        pairwise_accel_inplace_jit(m, r, a)
    return a

@njit(cache=True)
def step_vverlet_k_jit(m, r, v, a, dt, k_steps):
    for _ in range(k_steps):
        v[:,0] += 0.5*dt*a[:,0]; v[:,1] += 0.5*dt*a[:,1]; v[:,2] += 0.5*dt*a[:,2]
        r[:,0] += dt*v[:,0];     r[:,1] += dt*v[:,1];     r[:,2] += dt*v[:,2]
        pairwise_accel_inplace_jit(m, r, a)
        v[:,0] += 0.5*dt*a[:,0]; v[:,1] += 0.5*dt*a[:,1]; v[:,2] += 0.5*dt*a[:,2]
    return a

