#!/usr/bin/env python3
"""Položaj Sunca za zadani datum, sat i mjesto (kampanja "prikazi i tlocrti").

Algoritam: NOAA Solar Calculator (Meeus, Astronomical Algorithms, pogl. 25, skraćeni
redovi). Točnost reda 0,01-0,05 stupnja za godine 1900.-2100., što je za osvjetljenje
prikaza više nego dovoljno. Status rezultata: PRETPOSTAVKA-IZRAČUN.

    from sunce import polozaj_sunca
    s = polozaj_sunca("2026-06-21 12:00")            # lokalno vrijeme Europe/Zagreb
    s["visina_deg"], s["azimut_deg"]                  # azimut od sjevera u smjeru kazaljke

Ne ovisi o Blenderu ni o vanjskim paketima (samo standardna knjižnica).
"""
from __future__ import annotations

import datetime as _dt
import math
from zoneinfo import ZoneInfo

LAT0 = 45.8187
LON0 = 16.0185
ZONA = "Europe/Zagreb"


def _u_utc(kada, zona=ZONA):
    """Prihvaća datetime ili ISO tekst; vrijeme bez zone tumači se kao lokalno (zona)."""
    if isinstance(kada, str):
        kada = _dt.datetime.fromisoformat(kada)
    if kada.tzinfo is None:
        kada = kada.replace(tzinfo=ZoneInfo(zona))
    return kada.astimezone(_dt.timezone.utc)


def _julijanski_dan(utc):
    y, m = utc.year, utc.month
    d = utc.day + (utc.hour + (utc.minute + (utc.second + utc.microsecond / 1e6) / 60.0) / 60.0) / 24.0
    if m <= 2:
        y -= 1
        m += 12
    a = y // 100
    b = 2 - a + a // 4
    return math.floor(365.25 * (y + 4716)) + math.floor(30.6001 * (m + 1)) + d + b - 1524.5


def _efemeride(utc):
    """Deklinacija (rad) i jednadžba vremena (min) za trenutak UTC."""
    t = (_julijanski_dan(utc) - 2451545.0) / 36525.0
    l0 = math.radians((280.46646 + t * (36000.76983 + t * 0.0003032)) % 360.0)
    m = math.radians(357.52911 + t * (35999.05029 - 0.0001537 * t))
    e = 0.016708634 - t * (0.000042037 + 0.0000001267 * t)
    c = (
        math.sin(m) * (1.914602 - t * (0.004817 + 0.000014 * t))
        + math.sin(2 * m) * (0.019993 - 0.000101 * t)
        + math.sin(3 * m) * 0.000289
    )
    prava_duljina = math.degrees(l0) + c
    omega = math.radians(125.04 - 1934.136 * t)
    prividna = math.radians(prava_duljina - 0.00569 - 0.00478 * math.sin(omega))
    eps0 = 23.0 + (26.0 + (21.448 - t * (46.815 + t * (0.00059 - t * 0.001813))) / 60.0) / 60.0
    eps = math.radians(eps0 + 0.00256 * math.cos(omega))
    dekl = math.asin(math.sin(eps) * math.sin(prividna))
    y = math.tan(eps / 2.0) ** 2
    jv = 4.0 * math.degrees(
        y * math.sin(2 * l0)
        - 2 * e * math.sin(m)
        + 4 * e * y * math.sin(m) * math.cos(2 * l0)
        - 0.5 * y * y * math.sin(4 * l0)
        - 1.25 * e * e * math.sin(2 * m)
    )
    return dekl, jv


def _refrakcija_deg(visina_deg):
    """Približna atmosferska refrakcija (NOAA), u stupnjevima."""
    h = visina_deg
    if h > 85.0:
        return 0.0
    tg = math.tan(math.radians(h))
    if h > 5.0:
        r = 58.1 / tg - 0.07 / tg**3 + 0.000086 / tg**5
    elif h > -0.575:
        r = 1735.0 + h * (-518.2 + h * (103.4 + h * (-12.79 + h * 0.711)))
    else:
        r = -20.772 / tg
    return r / 3600.0


def polozaj_sunca(kada, lat=LAT0, lon=LON0, zona=ZONA, refrakcija=True):
    """Visina i azimut Sunca.

    kada  datetime ili ISO tekst ("2026-06-21 12:00"); bez zone = lokalno vrijeme `zona`
    lat, lon  stupnjevi (sjever i istok pozitivni)
    Vraća rječnik: visina_deg (iznad obzora), azimut_deg (0 = sjever, 90 = istok),
    deklinacija_deg, jednadzba_vremena_min, utc, lokalno, suncevo_podne_lokalno.
    """
    utc = _u_utc(kada, zona)
    dekl, jv = _efemeride(utc)
    minute_utc = utc.hour * 60.0 + utc.minute + utc.second / 60.0
    pravo_suncevo = (minute_utc + jv + 4.0 * lon) % 1440.0
    satni_kut = math.radians(pravo_suncevo / 4.0 - 180.0)
    fi = math.radians(lat)
    cos_zenit = math.sin(fi) * math.sin(dekl) + math.cos(fi) * math.cos(dekl) * math.cos(satni_kut)
    cos_zenit = max(-1.0, min(1.0, cos_zenit))
    visina = 90.0 - math.degrees(math.acos(cos_zenit))
    # azimut od sjevera u smjeru kazaljke na satu
    az = math.degrees(
        math.atan2(
            -math.sin(satni_kut) * math.cos(dekl),
            math.cos(fi) * math.sin(dekl) - math.sin(fi) * math.cos(dekl) * math.cos(satni_kut),
        )
    ) % 360.0
    if refrakcija:
        visina += _refrakcija_deg(visina)
    podne_utc_min = 720.0 - 4.0 * lon - jv
    podne = (utc.replace(hour=0, minute=0, second=0, microsecond=0) + _dt.timedelta(minutes=podne_utc_min)).astimezone(
        ZoneInfo(zona)
    )
    return {
        "visina_deg": visina,
        "azimut_deg": az,
        "deklinacija_deg": math.degrees(dekl),
        "jednadzba_vremena_min": jv,
        "utc": utc.isoformat(timespec="seconds"),
        "lokalno": utc.astimezone(ZoneInfo(zona)).isoformat(timespec="seconds"),
        "suncevo_podne_lokalno": podne.isoformat(timespec="seconds"),
        "lat": lat,
        "lon": lon,
        "status": "PRETPOSTAVKA-IZRAČUN (NOAA Solar Calculator, Meeus)",
    }


def izlaz_zalaz(datum, lat=LAT0, lon=LON0, zona=ZONA):
    """Izlaz i zalaz Sunca (gornji rub, standardna refrakcija: zenit 90,833 stupnja)."""
    if isinstance(datum, str):
        datum = _dt.date.fromisoformat(datum)
    podne = _dt.datetime(datum.year, datum.month, datum.day, 12, tzinfo=_dt.timezone.utc)
    dekl, jv = _efemeride(podne)
    fi = math.radians(lat)
    c = math.cos(math.radians(90.833)) / (math.cos(fi) * math.cos(dekl)) - math.tan(fi) * math.tan(dekl)
    if abs(c) > 1:
        return None
    ha = math.degrees(math.acos(c))
    pon = _dt.datetime(datum.year, datum.month, datum.day, tzinfo=_dt.timezone.utc)
    out = {}
    for ime, predznak in (("izlaz", -1), ("zalaz", 1)):
        minute = 720.0 - 4.0 * (lon - predznak * ha) - jv
        out[ime] = (pon + _dt.timedelta(minutes=minute)).astimezone(ZoneInfo(zona)).isoformat(timespec="minutes")
    return out


def smjer_sunca_enu(visina_deg, azimut_deg):
    """Jedinični vektor od tla prema Suncu u ENU (x istok, y sjever, z gore)."""
    h, a = math.radians(visina_deg), math.radians(azimut_deg)
    return (math.cos(h) * math.sin(a), math.cos(h) * math.cos(a), math.sin(h))


def _samoprovjera():
    """Provjera na poznatim vrijednostima za Zagreb (45,8187 N, 16,0185 E).

    - Ljetni solsticij: visina u Sunčevo podne = 90 - lat + 23,44 = 67,62 stupnja (geometrijski),
      azimut 180. Zimski: 90 - lat - 23,44 = 20,74.
    - Sunčevo podne na 16,0185 E: 12:00 UTC - 4 min * 16,0185 - jednadžba vremena
      (21.6. oko -1,8 min) = oko 10:58 UTC = 12:58 po ljetnom vremenu.
    - Ravnodnevnica: visina u podne oko 90 - lat = 44,2; izlazak približno na istoku.
    - Izlaz i zalaz 21.6. u Zagrebu oko 5:05 i 20:47 (uobičajene tablične vrijednosti).
    """
    r = []
    s = polozaj_sunca("2026-06-21 12:58", refrakcija=False)
    assert abs(s["visina_deg"] - 67.62) < 0.05, s
    assert abs(s["azimut_deg"] - 180.0) < 1.0, s
    assert abs(s["deklinacija_deg"] - 23.44) < 0.02, s
    r.append(("ljetni solsticij, Sunčevo podne", s))
    s12 = polozaj_sunca("2026-06-21 12:00", refrakcija=False)
    assert 63.0 < s12["visina_deg"] < 66.5 and 140.0 < s12["azimut_deg"] < 160.0, s12
    r.append(("ljetni solsticij, 12:00 po satu", s12))
    # Sunčevo podne 21.12.: jednadžba vremena oko +2 min, dakle oko 11:54 po zimskom vremenu
    z = polozaj_sunca("2026-12-21 11:54", refrakcija=False)
    assert abs(z["visina_deg"] - 20.74) < 0.05, z
    assert abs(z["azimut_deg"] - 180.0) < 1.0, z
    r.append(("zimski solsticij, Sunčevo podne", z))
    # ravnodnevnica 20.3.: jednadžba vremena oko -7,5 min, podne oko 12:03 po zimskom vremenu
    e = polozaj_sunca("2026-03-20 12:03", refrakcija=False)
    assert abs(e["visina_deg"] - 44.2) < 0.3, e
    assert abs(e["azimut_deg"] - 180.0) < 1.0, e
    r.append(("proljetna ravnodnevnica, Sunčevo podne", e))
    iz = izlaz_zalaz("2026-06-21")
    hi = _dt.datetime.fromisoformat(iz["izlaz"])
    hz = _dt.datetime.fromisoformat(iz["zalaz"])
    assert abs((hi.hour * 60 + hi.minute) - (5 * 60 + 5)) <= 4, iz
    assert abs((hz.hour * 60 + hz.minute) - (20 * 60 + 47)) <= 4, iz
    # simetrija: jednak satni kut prije i poslije podneva daje jednaku visinu
    p = _dt.datetime.fromisoformat(polozaj_sunca("2026-06-21 12:00")["suncevo_podne_lokalno"])
    a = polozaj_sunca(p - _dt.timedelta(hours=3), refrakcija=False)
    b = polozaj_sunca(p + _dt.timedelta(hours=3), refrakcija=False)
    assert abs(a["visina_deg"] - b["visina_deg"]) < 0.05, (a, b)
    assert abs((360.0 - a["azimut_deg"]) - b["azimut_deg"]) < 0.1, (a, b)
    return r, iz


if __name__ == "__main__":
    import argparse

    ap = argparse.ArgumentParser(description="Položaj Sunca (visina, azimut)")
    ap.add_argument("kada", nargs="?", help='npr. "2026-06-21 12:00" (lokalno, Europe/Zagreb)')
    ap.add_argument("--lat", type=float, default=LAT0)
    ap.add_argument("--lon", type=float, default=LON0)
    a = ap.parse_args()
    if a.kada:
        s = polozaj_sunca(a.kada, a.lat, a.lon)
        print(f"{s['lokalno']}: visina {s['visina_deg']:.2f}, azimut {s['azimut_deg']:.2f}")
    else:
        r, iz = _samoprovjera()
        for ime, s in r:
            print(f"{ime}: {s['lokalno']} visina {s['visina_deg']:.2f}, azimut {s['azimut_deg']:.2f}")
        print("21.6.2026. izlaz", iz["izlaz"][11:16], "zalaz", iz["zalaz"][11:16])
        print("samoprovjera prošla")
