astrololo/services/logic/app/engine/chart.py

"""Złożenie pełnego horoskopu: pozycje + osie + domy (LOG-01 + LOG-05).

Silnik-agnostyczne: potrzebuje tylko `positions()` oraz (dla osi/domów)
`sidereal()`. Jeśli silnik nie umie policzyć czasu gwiazdowego, zwraca same
pozycje.
"""
from __future__ import annotations

from app.engine import houses as H
from app.engine import zodiac as Z
from app.engine.base import EphemerisEngine
from app.engine.formats import SIGNS, absolute, decimal, in_sign, norm360, sign_index
from app.engine.models import ChartMoment


def _fmt(name: str, lon: float, off: float = 0.0) -> dict:
    lon = norm360(lon - off)
    return {
        "name": name,
        "sign": SIGNS[sign_index(lon)],
        "in_sign": in_sign(lon),
        "decimal": round(lon, 6),
    }


def _shift_pos(pdict: dict, off: float) -> None:
    """Przelicza etykiety pozycji na wybrany zodiak (in-place). off=0 → bez zmian."""
    if not off:
        return
    lon = norm360(pdict["decimal"] - off)
    pdict["sign"] = SIGNS[sign_index(lon)]
    pdict["in_sign"] = in_sign(lon)
    pdict["absolute"] = absolute(lon)
    pdict["decimal"] = decimal(lon)


def build_chart(engine: EphemerisEngine, moment: ChartMoment, house_system: str = H.WHOLE_SIGN,
                lots_method: str = "degree", zodiac: str = Z.TROPICAL,
                house_systems: list[str] | None = None,
                aspect_orb: float = 8.0, aspect_luminary_bonus: float = 2.0,
                aspect_minor: bool = False) -> dict:
    from app.engine import glyphs as GL
    from app.engine.aspects import find_aspects
    from app.engine.houses import mean_obliquity
    from app.engine.out_of_zodiac import (
        declination,
        find_antiscia,
        find_declination_aspects,
        is_out_of_bounds,
    )

    positions = engine.positions(moment)
    result: dict = {"engine": engine.name, "positions": [p.as_dict() for p in positions]}
    # aspekty liczymy PRZED zmianą zodiaku — kąty między obiektami są niezmiennicze
    result["aspects"] = find_aspects(                       # aspekty (LOG-06), konfigurowalne (PRE-06)
        result["positions"], orb=aspect_orb,
        luminary_bonus=aspect_luminary_bonus, minor=aspect_minor)

    # Aspekty pozazodiakalne (LOG-07): deklinacja i antyscja liczone na
    # współrzędnych TROPIKALNYCH of-date — deklinacja jest fizyczna (równikowa),
    # a antyscja z definicji tropikalna. Dlatego PRZED przesunięciem na zodiak,
    # z surowych długości/szerokości silnika.
    # ε PRAWDZIWE — to samo, którym liczymy domy, bo pozycje ze Skyfielda są
    # POZORNE (uwzględniają nutację). Silnik bez sidereal() nutacji nie poda;
    # wtedy zostaje średnie, z jawnym oznaczeniem w wyniku.
    if hasattr(engine, "sidereal"):
        eps = engine.sidereal(moment)[1]
        result["obliquity_kind"] = "true"
    else:
        eps = mean_obliquity(Z.julian_day(moment.when_utc))
        result["obliquity_kind"] = "mean"
    result["obliquity"] = round(eps, 6)
    for pdict, obj in zip(result["positions"], positions):
        dec = declination(obj.longitude, obj.latitude, eps)
        pdict["declination"] = round(dec, 4)
        if is_out_of_bounds(dec, eps):
            pdict["out_of_bounds"] = True
    result["parallels"] = find_declination_aspects(result["positions"])
    result["antiscia"] = find_antiscia(result["positions"])

    # glify aspektów (LOG-22) — symbol aspektu nie zależy od zodiaku
    for a in result["aspects"]:
        a["glyph"] = GL.aspect_glyph(a["aspect"])

    # offset zodiaku (LOG-04): syderyczny = ayanamsa, draconic = długość węzła
    node_lon = next((p.longitude for p in positions if p.name == "North Node"), None)
    off = Z.offset(zodiac, Z.julian_day(moment.when_utc), node_lon)
    result["zodiac"] = zodiac
    if zodiac in Z.SIDEREAL:
        result["ayanamsha"] = round(off, 6)
    for pdict in result["positions"]:
        _shift_pos(pdict, off)

    # glify obiektów (LOG-22): symbol planety jest niezmienniczy, symbol ZNAKU
    # zależy od zodiaku, więc po przesunięciu. Pierścień 12 znaków pod kosmogram.
    for pdict in result["positions"]:
        pdict["glyph"] = GL.glyph_for(pdict["name"])
        pdict["sign_glyph"] = GL.sign_glyph(pdict["sign"])
    result["sign_glyphs"] = [{"sign": s, "glyph": GL.sign_glyph(s)} for s in SIGNS]

    if not hasattr(engine, "sidereal"):
        return result

    ramc, eps = engine.sidereal(moment)
    asc = H.compute_asc(ramc, eps, moment.lat)
    mc = H.compute_mc(ramc, eps)
    system = house_system if house_system in H.SYSTEMS else H.WHOLE_SIGN
    # cusps_detailed, nie cusps_for: Placidus i Koch nie istnieją powyżej koła
    # podbiegunowego, a astrolog z Tromsø ma dostać wynik ZE ŚLADEM, czym go
    # policzyliśmy. Ten ślad musi dojść aż do raportu i PDF-a.
    primary = H.cusps_detailed(ramc, eps, moment.lat, system)
    cusp_list = primary.cusps   # tropikalne — geometria domów jest niezmiennicza

    def _cusps_out(cl: list[float]) -> list[dict]:
        """Cuspy → wiersze pod UI/kosmogram: znak, stopień w znaku, długość, glif."""
        return [
            {"house": i + 1, "sign": SIGNS[sign_index(norm360(c - off))],
             "in_sign": in_sign(norm360(c - off)),
             "decimal": round(norm360(c - off), 6),       # długość cuspu — pod kosmogram (PRE-12)
             "sign_glyph": GL.sign_glyph(SIGNS[sign_index(norm360(c - off))])}
            for i, c in enumerate(cl)
        ]

    result["house_system"] = primary.system            # FAKTYCZNIE użyty
    result["house_system_requested"] = primary.requested
    # Lista ostrzeżeń dla całego horoskopu — prezentacja, raport i PDF czytają
    # jedno miejsce, więc żaden z nich nie może „zapomnieć" o fallbacku.
    result["house_warnings"] = [primary.notice] if primary.notice else []
    result["angles"] = {
        "Asc": _fmt("Asc", asc, off),
        "MC": _fmt("MC", mc, off),
        "Dsc": _fmt("Dsc", norm360(asc + 180.0), off),
        "IC": _fmt("IC", norm360(mc + 180.0), off),
    }
    for a in result["angles"].values():         # glif znaku osi (LOG-22)
        a["sign_glyph"] = GL.sign_glyph(a["sign"])
    result["cusps"] = _cusps_out(cusp_list)      # PRYMARNY system — pod kosmogram i wstecz
    for pdict, obj in zip(result["positions"], positions):
        pdict["house"] = H.assign_house(obj.longitude, cusp_list)  # dom po długości tropikalnej

    # Wiele systemów domów NARAZ (PRE-05/LOG-05) — do porównania obok siebie.
    # Osie (Asc/MC) są wspólne; różni się tylko PODZIAŁ na domy. Prymarny zostaje
    # w `cusps`/`house_system` (kosmogram i wstecz), a `house_systems` niesie pełen
    # zestaw; `positions[].houses[system]` mówi, w którym domu obiekt siedzi wg
    # danego systemu. Dokładamy tylko gdy poproszono o więcej niż jeden.
    requested = [system] + [s for s in (house_systems or []) if s in H.SYSTEMS]
    ordered = list(dict.fromkeys(requested))                  # prymarny pierwszy, bez duplikatów
    if len(ordered) > 1:
        result["house_systems"] = []
        for s in ordered:
            cs = primary if s == system else H.cusps_detailed(ramc, eps, moment.lat, s)
            block = {"system": s, "used_system": cs.system, "cusps": _cusps_out(cs.cusps)}
            if cs.notice:
                block["notice"] = cs.notice
                if cs.notice not in result["house_warnings"]:
                    result["house_warnings"].append(cs.notice)
            result["house_systems"].append(block)
            for pdict, obj in zip(result["positions"], positions):
                pdict.setdefault("houses", {})[s] = H.assign_house(obj.longitude, cs.cusps)

    # Lots (LOG-08) — wymagają Asc i sekty (dzień/noc)
    from app.engine.firdaria import is_day_birth
    from app.engine.lots import compute_lots

    pts = {p.name: p.longitude for p in positions}
    pts["Asc"] = asc
    day = is_day_birth(pts["Sun"], asc, mc) if "Sun" in pts else True
    result["sect"] = "day" if day else "night"
    result["lots"] = [
        {**lot,
         "longitude": decimal(norm360(lot["longitude"] - off)),   # w wybranym zodiaku
         "sign": SIGNS[sign_index(norm360(lot["longitude"] - off))],
         "in_sign": in_sign(norm360(lot["longitude"] - off)),
         "house": H.assign_house(lot["longitude"], cusp_list),     # dom po długości tropikalnej
         "glyph": GL.glyph_for(lot["name"]),                       # ⊗ dla Fortuny; reszta None (LOG-22)
         "sign_glyph": GL.sign_glyph(SIGNS[sign_index(norm360(lot["longitude"] - off))])}
        for lot in compute_lots(pts, day, lots_method)
    ]
    return result