#!/usr/bin/env python3
import sys
import math
from datetime import datetime, timezone, timedelta
from skyfield.api import load, wgs84
from skyfield.almanac import fraction_illuminated

if len(sys.argv) < 11:
    sys.exit(1)

# Argumente einlesen (Fortran übergibt alle Parameter)
lat = sys.argv[1]
lon = sys.argv[2]
elev = float(sys.argv[3])

year = int(sys.argv[4])
month = int(sys.argv[5])
day = int(sys.argv[6])
hour = int(sys.argv[7])
minute = int(sys.argv[8])
second = int(sys.argv[9])
tz_str = sys.argv[10]  # z. B. "+0200" oder "+0100"

# Zeitzone verarbeiten und in UTC umrechnen
try:
    tz_sign = -1 if tz_str[0] == '-' else 1
    tz_hours = int(tz_str[1:3]) * tz_sign
    tz_mins = int(tz_str[3:5]) * tz_sign
    tz = timezone(timedelta(hours=tz_hours, minutes=tz_mins))
    local_dt = datetime(year, month, day, hour, minute, second, tzinfo=tz)
    utc_dt = local_dt.astimezone(timezone.utc)
except Exception:
    utc_dt = datetime(year, month, day, hour, minute, second, tzinfo=timezone.utc)

# Skyfield & DE440-Ephemeride laden
eph = load('de440.bsp')
earth = eph['earth']
moon = eph['moon']
sun = eph['sun']

ts = load.timescale()
t = ts.from_datetime(utc_dt)

# Beobachterstandort (Erde + WGS84 Koordinaten & Höhe)
observer = earth + wgs84.latlon(float(lat), float(lon), elevation_m=elev)

# Scheinbare Positionen von Mond und Sonne
app_moon = observer.at(t).observe(moon).apparent()
app_sun = observer.at(t).observe(sun).apparent()

alt_moon, az_moon, dist_moon = app_moon.altaz()
alt_sun, az_sun, dist_sun = app_sun.altaz()

az_moon_deg = az_moon.degrees
alt_moon_deg = alt_moon.degrees
az_sun_deg = az_sun.degrees
alt_sun_deg = alt_sun.degrees

dist_km = dist_moon.km

# Beleuchteter Anteil in Prozent (Phase)
phase_pct = fraction_illuminated(eph, 'moon', t) * 100.0

# Geozentrische Positionen für Elongation/Mondphasen-Bezeichnung & Erdschatten
geo_moon = earth.at(t).observe(moon).apparent()
geo_sun = earth.at(t).observe(sun).apparent()

ecl_moon = geo_moon.ecliptic_latlon()[1].degrees
ecl_sun = geo_sun.ecliptic_latlon()[1].degrees
diff_ecl = (ecl_moon - ecl_sun) % 360.0

if phase_pct > 97.0:
    phase_str = "VOLLMOND"
elif phase_pct < 3.0:
    phase_str = "NEUMOND"
elif diff_ecl < 180.0:
    phase_str = "ZUNEHMEND"
else:
    phase_str = "ABNEHMEND"

# Relativer Versatz der Sonne zum Mond im Horizontalsystem (in Grad)
d_az = math.radians((az_sun_deg - az_moon_deg + 180.0) % 360.0 - 180.0)
d_alt = math.radians(alt_sun_deg - alt_moon_deg)

sun_dx_deg = math.degrees(d_az * math.cos(math.radians(alt_moon_deg)))
sun_dy_deg = math.degrees(d_alt)

angle_sun_rad = math.atan2(d_az * math.cos(math.radians(alt_moon_deg)), d_alt)
angle_sun_deg = math.degrees(angle_sun_rad)

# --- MONDFINSTERNIS (Abstand des Mondes vom Erdschatten/Gegensonne) ---
pos_moon = geo_moon.position.au
pos_antisun = -geo_sun.position.au

u_moon = pos_moon / math.sqrt(sum(pos_moon**2))
u_antisun = pos_antisun / math.sqrt(sum(pos_antisun**2))

dot = max(-1.0, min(1.0, float(sum(u_moon * u_antisun))))
sep_shadow_deg = math.degrees(math.acos(dot))

r_umbra = 0.72
r_penumbra = 1.28
r_moon = 0.26

if sep_shadow_deg < (r_umbra + r_moon):
    if sep_shadow_deg < (r_umbra - r_moon):
        lunar_eclipse_factor = 1.0  # Totale Mondfinsternis
    else:
        lunar_eclipse_factor = 0.5 + 0.5 * ((r_umbra + r_moon - sep_shadow_deg) / (2.0 * r_moon))
elif sep_shadow_deg < (r_penumbra + r_moon):
    lunar_eclipse_factor = 0.1 + 0.4 * ((r_penumbra + r_moon - sep_shadow_deg) / (r_penumbra - r_umbra))
else:
    lunar_eclipse_factor = 0.0

# Exakte Ausgabe für Fortran
print(f"{az_moon_deg:.2f} {alt_moon_deg:.2f} {dist_km:.0f} {phase_pct:.1f} {phase_str} {angle_sun_deg:.2f} {az_sun_deg:.2f} {alt_sun_deg:.2f} {sun_dx_deg:.4f} {sun_dy_deg:.4f} {lunar_eclipse_factor:.2f}")
