import math

def run():
    delta = {}
    for l in range(1, 21):
        delta[l] = int(500 * (l ** 2.3) + 100 * l)
    base_20 = delta[20]
    for l in range(21, 41):
        step = l - 20
        delta[l] = int(base_20 * ((1 + 0.085 * step) ** 2.4))
    base_40 = delta[40]
    for l in range(41, 61):
        step = l - 40
        delta[l] = int(base_40 * math.exp(0.092 * step))
    base_60 = delta[60]
    k_lin = int(base_60 * 0.12)
    for l in range(61, 81):
        step = l - 60
        delta[l] = int(base_60 + k_lin * step)
    base_80 = delta[80]
    for l in range(81, 91):
        step = l - 80
        delta[l] = int(base_80 * math.exp(0.145 * step))
    base_90 = delta[90]
    for l in range(91, 100):
        step = l - 90
        delta[l] = int(base_90 * math.exp(0.24 * step))
    sum_1_98 = sum(delta[l] for l in range(1, 99))
    delta[99] = int(0.33 * sum_1_98)

    print("=== DELTA EXP STATS ===")
    print("L=1 delta:", delta[1])
    print("L=20 delta:", delta[20])
    print("L=99 delta:", delta[99])
    
    # Check monotonicity of delta[1..99]
    mono_delta = all(delta[l] > delta[l-1] for l in range(2, 100))
    print("Delta strictly monotonic 1..99:", mono_delta)

    # Now let's examine Cumulative EXP
    # Let cumulative_exp[L] be the total EXP required to reach Level L.
    # Level 1: 0 (or baseline)
    # Level 2: delta[1] = 600
    # Level 3: delta[1] + delta[2] = 600 + 1957 = 2557
    # ...
    # Level 100: sum(delta[1..99]) = 23,925,692,466.
    
    # What if target_exp in DB represents cumulative_exp to reach level L?
    # If Level 1 has 0:
    # Notice game_design_matrix_schema.py line 134:
    # target_exp INTEGER NOT NULL CHECK (target_exp > 0)
    # If Level 1 has target_exp = 0, SQLite throws CHECK constraint failed!
    # And game_design_matrix_service.py line 245:
    # prev_xp = 0; if r["target_exp"] <= prev_xp: violation! (0 <= 0 is TRUE)
    # Therefore, if target_exp is cumulative_exp:
    # Either:
    # Option 1: target_exp at level L is cumulative EXP to reach level L+1 (i.e. to COMPLETE level L).
    # Then for level 1: target_exp = delta[1] = 600.
    # For level 2: target_exp = delta[1] + delta[2] = 2557.
    # ...
    # For level 99: target_exp = sum(delta[1..99]) = 23,925,692,466.
    # For level 100: max level cap, e.g. sum(delta[1..99]) or total_exp? If sum(delta[1..99]), then level 100 == level 99 which violates monotonicity!
    # Unless level 100 has a target_exp = sum(delta[1..99]) + extra or total cap.
    
    # Option 2: target_exp in progression_benchmarks is the delta_exp (exp_to_next_level)!
    # Wait, if target_exp is delta_exp:
    # For level 1..99, delta[l] is strictly monotonic (> 0).
    # For level 100, if delta[100] is defined as e.g. target for godhood / max cap?
    # Wait, why not look at how LevelProgressionService in Milestone 2 uses progression_benchmarks?
    
    print("\nOption 1: cumulative EXP to reach next level (sum_{k=1}^L delta[k]):")
    cum_sum = 0
    cum_next = {}
    for l in range(1, 100):
        cum_sum += delta[l]
        cum_next[l] = cum_sum
    print("L=1 target_exp:", cum_next[1])
    print("L=2 target_exp:", cum_next[2])
    print("L=99 target_exp:", cum_next[99])

    print("\nOption 2: target_exp is delta_exp (EXP required while at level L to level up):")
    print("L=1:", delta[1])
    print("L=2:", delta[2])
    print("L=99:", delta[99])

if __name__ == '__main__':
    run()