responses.py

"""Response models for the Astrology API client."""

from __future__ import annotations

from typing import Any

from pydantic import BaseModel, ConfigDict


class PlanetaryPosition(BaseModel):
    """Planetary position data.

    Allows extra fields since API responses may include additional data.
    """

    model_config = ConfigDict(extra="allow")

    name: str
    longitude: float
    latitude: float | None = None
    speed: float | None = None
    distance: float | None = None
    sign: str | None = None
    sign_longitude: float | None = None
    house: int | None = None
    retrograde: bool | None = None


class HouseCusp(BaseModel):
    """House cusp data."""

    model_config = ConfigDict(extra="allow")

    house: int
    longitude: float
    sign: str | None = None
    sign_longitude: float | None = None


class Aspect(BaseModel):
    """Aspect between two points."""

    model_config = ConfigDict(extra="allow")

    point1: str
    point2: str
    type: str
    angle: float
    orb: float
    applying: bool | None = None


class PlanetaryPositionsResponse(BaseModel):
    """Response for planetary positions query."""

    model_config = ConfigDict(extra="allow")

    positions: list[PlanetaryPosition]
    timestamp: str | None = None


class ChartData(BaseModel):
    """Chart calculation response."""

    model_config = ConfigDict(extra="allow")

    planetary_positions: list[PlanetaryPosition] | None = None
    house_cusps: list[HouseCusp] | None = None
    aspects: list[Aspect] | None = None
    angles: dict[str, Any] | None = None
    fixed_stars: list[dict[str, Any]] | None = None


class NatalChartResponse(BaseModel):
    """Response for natal chart calculation."""

    model_config = ConfigDict(extra="allow")

    chart: ChartData | None = None
    subject: dict[str, Any] | None = None


class SynastryChartResponse(BaseModel):
    """Response for synastry chart calculation."""

    model_config = ConfigDict(extra="allow")

    subject1_chart: ChartData | None = None
    subject2_chart: ChartData | None = None
    inter_aspects: list[Aspect] | None = None
    composite_midpoints: list[dict[str, Any]] | None = None


class CompositeChartResponse(BaseModel):
    """Response for composite chart calculation."""

    model_config = ConfigDict(extra="allow")

    chart: ChartData | None = None
    method: str | None = None


class TransitChartResponse(BaseModel):
    """Response for transit chart calculation."""

    model_config = ConfigDict(extra="allow")

    natal_chart: ChartData | None = None
    transit_chart: ChartData | None = None
    transit_aspects: list[Aspect] | None = None


class ReturnChartResponse(BaseModel):
    """Response for return chart calculation (solar/lunar/planetary)."""

    model_config = ConfigDict(extra="allow")

    chart: ChartData | None = None
    return_date: str | None = None
    return_location: dict[str, Any] | None = None


class ProgressionResponse(BaseModel):
    """Response for progression calculation."""

    model_config = ConfigDict(extra="allow")

    natal_chart: ChartData | None = None
    progressed_chart: ChartData | None = None
    progression_type: str | None = None
    target_date: str | None = None


class DirectionResponse(BaseModel):
    """Response for direction calculation."""

    model_config = ConfigDict(extra="allow")

    natal_chart: ChartData | None = None
    directed_chart: ChartData | None = None
    direction_type: str | None = None
    target_date: str | None = None


class HoroscopeResponse(BaseModel):
    """Response for horoscope query."""

    model_config = ConfigDict(extra="allow")

    content: str | None = None
    date: str | None = None
    period: str | None = None
    sign: str | None = None
    transits: list[dict[str, Any]] | None = None


class AnalysisResponse(BaseModel):
    """Response for analysis/report query."""

    model_config = ConfigDict(extra="allow")

    title: str | None = None
    summary: str | None = None
    sections: list[dict[str, Any]] | None = None
    interpretations: list[dict[str, Any]] | None = None


class BaZiPillar(BaseModel):
    """BaZi pillar (Four Pillars) data."""

    model_config = ConfigDict(extra="allow")

    heavenly_stem: str
    earthly_branch: str
    element: str | None = None
    animal: str | None = None
    yin_yang: str | None = None


class BaZiResponse(BaseModel):
    """Response for BaZi (Four Pillars) analysis."""

    model_config = ConfigDict(extra="allow")

    year_pillar: BaZiPillar | None = None
    month_pillar: BaZiPillar | None = None
    day_pillar: BaZiPillar | None = None
    hour_pillar: BaZiPillar | None = None
    day_master: dict[str, Any] | str | None = None  # Can be dict or string
    element_balance: dict[str, Any] | None = None
    interpretation: str | None = None


class NumerologyResponse(BaseModel):
    """Response for numerology analysis."""

    model_config = ConfigDict(extra="allow")

    life_path_number: int | None = None
    expression_number: int | None = None
    soul_urge_number: int | None = None
    personality_number: int | None = None
    birthday_number: int | None = None
    interpretations: dict[str, Any] | None = None


class TarotCard(BaseModel):
    """Tarot card data."""

    model_config = ConfigDict(extra="allow")

    id: str
    name: str
    suit: str | None = None
    number: int | None = None
    arcana: str | None = None
    upright: bool | None = None
    keywords: list[str] | None = None
    meaning: str | None = None


class DrawCardsResponse(BaseModel):
    """Response for drawing tarot cards."""

    model_config = ConfigDict(extra="allow")

    cards: list[TarotCard]


class TarotReadingResponse(BaseModel):
    """Response for tarot reading."""

    model_config = ConfigDict(extra="allow")

    cards: list[TarotCard] | None = None
    positions: list[dict[str, Any]] | None = None
    interpretation: str | None = None
    guidance: str | None = None


class Eclipse(BaseModel):
    """Eclipse data."""

    model_config = ConfigDict(extra="allow")

    date: str
    type: str
    eclipse_type: str | None = None
    magnitude: float | None = None
    saros_series: int | None = None
    visibility: list[str] | None = None


class EclipsesResponse(BaseModel):
    """Response for eclipses query."""

    model_config = ConfigDict(extra="allow")

    eclipses: list[Eclipse]


class MoonPhaseResponse(BaseModel):
    """Response for moon phase query."""

    model_config = ConfigDict(extra="allow")

    phase_name: str | None = None
    phase_percent: float | None = None
    illumination: float | None = None
    age_days: float | None = None
    distance_km: float | None = None
    next_new_moon: str | None = None
    next_full_moon: str | None = None


class AstrocartographyLine(BaseModel):
    """Astrocartography line data."""

    model_config = ConfigDict(extra="allow")

    planet: str
    line_type: str
    coordinates: list[dict[str, Any]] | None = None


class AstrocartographyResponse(BaseModel):
    """Response for astrocartography query."""

    model_config = ConfigDict(extra="allow")

    lines: list[AstrocartographyLine] | None = None
    subject: dict[str, Any] | None = None


class DignityResponse(BaseModel):
    """Response for planetary dignities."""

    model_config = ConfigDict(extra="allow")

    dignities: list[dict[str, Any]] | None = None
    rulerships: dict[str, Any] | None = None


class CityData(BaseModel):
    """City data from glossary."""

    model_config = ConfigDict(extra="allow")

    name: str
    country: str | None = None
    country_code: str | None = None
    latitude: float | None = None
    longitude: float | None = None
    timezone: str | None = None
    population: int | None = None


class GlossaryResponse(BaseModel):
    """Generic glossary response."""

    model_config = ConfigDict(extra="allow")

    items: list[dict[str, Any]] | None = None
    count: int | None = None


class InsightResponse(BaseModel):
    """Response for insight queries."""

    model_config = ConfigDict(extra="allow")

    title: str | None = None
    summary: str | None = None
    insights: list[dict[str, Any]] | None = None
    recommendations: list[str] | None = None
    scores: dict[str, Any] | None = None


class FixedStarPosition(BaseModel):
    """Fixed star position data."""

    model_config = ConfigDict(extra="allow")

    name: str
    longitude: float
    latitude: float
    magnitude: float | None = None
    spectral_type: str | None = None


class FixedStarsResponse(BaseModel):
    """Response for fixed stars query."""

    model_config = ConfigDict(extra="allow")

    stars: list[FixedStarPosition] | None = None


# Generic response for endpoints that return plain data
class GenericResponse(BaseModel):
    """Generic response for simple data returns."""

    model_config = ConfigDict(extra="allow")

    data: Any | None = None
    result: Any | None = None
    message: str | None = None