#!/bin/bash
set -euo pipefail

sed -n '17,42p' src/OneScript.Core/Values/BslDateValue.cs
rg -n -C 3 'DateTime\.MaxValue|Normalize\(' src/Tests src/OneScript.Core

#!/bin/bash
set -euo pipefail

python3 - <<'PY'
import math
MAX_TICKS = 3155378975999999999
STEP = 1000

def current(ticks):
    q = float(ticks) / STEP
    # Math.Round(x, MidpointRounding.AwayFromZero), for nonnegative values.
    rounded_q = math.floor(q + 0.5)
    return rounded_q * STEP

def integer_round(ticks):
    base, rem = divmod(ticks, STEP)
    return (base + (rem >= STEP // 2)) * STEP

def proposed(ticks):
    base, rem = divmod(ticks, STEP)
    rounded = base * STEP
    if rem >= STEP // 2:
        rounded = min(rounded + STEP, MAX_TICKS)
    return rounded

print("upper-bound cases")
for ticks in range(MAX_TICKS - 1000, MAX_TICKS + 1):
    result = current(ticks)
    if result > MAX_TICKS:
        print("first overflow:", ticks, "remainder:", ticks % STEP, "result:", result)
        break
print("max:", MAX_TICKS, "remainder:", MAX_TICKS % STEP,
      "current:", current(MAX_TICKS), "proposed:", proposed(MAX_TICKS))

print("proposed boundary")
for ticks in range(MAX_TICKS - 505, MAX_TICKS + 1):
    if current(ticks) != proposed(ticks):
        print("first changed case:", ticks, "current:", current(ticks),
              "proposed:", proposed(ticks))
        break

# Search deterministic ranges for double-conversion differences.
differences = []
for ticks in list(range(0, 2_000_000)) + list(range(MAX_TICKS - 2_000_000, MAX_TICKS + 1)):
    exact = integer_round(ticks)
    actual = current(ticks)
    if exact != actual:
        differences.append((ticks, exact, actual))
        if len(differences) == 5:
            break
print("double-conversion differences:", differences)
PY

#!/bin/bash
set -euo pipefail

python3 - <<'PY'
import math
MAX_TICKS = 3155378975999999999
STEP = 1000

def current(ticks):
    return math.floor(float(ticks) / STEP + 0.5) * STEP

def exact(ticks):
    q, r = divmod(ticks, STEP)
    return (q + (r >= STEP // 2)) * STEP

def proposed(ticks):
    q, r = divmod(ticks, STEP)
    rounded = q * STEP
    if r >= STEP // 2:
        rounded = min(rounded + STEP, MAX_TICKS)
    return rounded

overflow = [t for t in range(MAX_TICKS - 5000, MAX_TICKS + 1)
            if current(t) > MAX_TICKS]
mismatch = [t for t in range(MAX_TICKS - 5000, MAX_TICKS + 1)
            if current(t) != exact(t)]

print("current overflow interval:",
      min(overflow), max(overflow), "count:", len(overflow))
print("current overflow distance from max:",
      MAX_TICKS - min(overflow), "through", MAX_TICKS - max(overflow))
print("current/exact mismatch interval:",
      min(mismatch), max(mismatch), "count:", len(mismatch))
print("proposed exceeds max:", any(proposed(t) > MAX_TICKS
                                  for t in range(MAX_TICKS + 1)))
print("proposed differs from exact below max:",
      [(t, proposed(t), exact(t))
       for t in range(MAX_TICKS - 5000, MAX_TICKS)
       if proposed(t) != exact(t)][:3])
PY