insights.py

"""Insights category client with nested sub-clients."""

from __future__ import annotations

from astroapi.categories.base import BaseCategoryClient
from astroapi.types.requests import (
    BradleyRequest,
    BusinessInsightRequest,
    BusinessMultipleRequest,
    BusinessSingleRequest,
    CryptoTimingRequest,
    FinancialInsightRequest,
    ForexTimingRequest,
    GannAnalysisRequest,
    MarketTimingRequest,
    MultiPetRequest,
    PetInsightRequest,
    PetPersonalityRequest,
    RelationshipInsightRequest,
    SingleSubjectRequest,
    WellnessInsightRequest,
)
from astroapi.types.responses import InsightResponse
from astroapi.utils.http import HttpHelper
from astroapi.utils.validators import validate_subject


class RelationshipInsightsClient(BaseCategoryClient):
    """Sub-client for relationship insights."""

    API_PREFIX = "/api/v3/insights/relationship"

    def get_compatibility(self, request: RelationshipInsightRequest) -> InsightResponse:
        """Get relationship compatibility insights.

        Args:
            request: Relationship insight request parameters

        Returns:
            Compatibility insights response

        Raises:
            AstrologyError: If validation fails or API request fails
        """
        validate_subject(request.subject1)
        validate_subject(request.subject2)

        url = self._build_url("compatibility")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return InsightResponse(**data)

    def get_dynamics(self, request: RelationshipInsightRequest) -> InsightResponse:
        """Get relationship dynamics insights.

        Args:
            request: Relationship insight request parameters

        Returns:
            Relationship dynamics insights response

        Raises:
            AstrologyError: If validation fails or API request fails
        """
        validate_subject(request.subject1)
        validate_subject(request.subject2)

        url = self._build_url("dynamics")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return InsightResponse(**data)

    def get_challenges(self, request: RelationshipInsightRequest) -> InsightResponse:
        """Get relationship challenges insights.

        Args:
            request: Relationship insight request parameters

        Returns:
            Relationship challenges insights response

        Raises:
            AstrologyError: If validation fails or API request fails
        """
        validate_subject(request.subject1)
        validate_subject(request.subject2)

        url = self._build_url("challenges")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return InsightResponse(**data)

    def get_compatibility_score(self, request: RelationshipInsightRequest) -> InsightResponse:
        """Get relationship compatibility score."""
        validate_subject(request.subject1)
        validate_subject(request.subject2)
        url = self._build_url("compatibility-score")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return InsightResponse(**data)

    def get_love_languages(self, request: RelationshipInsightRequest) -> InsightResponse:
        """Get love languages analysis."""
        validate_subject(request.subject1)
        validate_subject(request.subject2)
        url = self._build_url("love-languages")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return InsightResponse(**data)

    def get_davison_chart(self, request: RelationshipInsightRequest) -> InsightResponse:
        """Get Davison chart analysis."""
        validate_subject(request.subject1)
        validate_subject(request.subject2)
        url = self._build_url("davison")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return InsightResponse(**data)

    def get_timing(self, request: RelationshipInsightRequest) -> InsightResponse:
        """Get relationship timing insights."""
        validate_subject(request.subject1)
        validate_subject(request.subject2)
        url = self._build_url("timing")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return InsightResponse(**data)

    def get_red_flags(self, request: RelationshipInsightRequest) -> InsightResponse:
        """Get relationship red flags."""
        validate_subject(request.subject1)
        validate_subject(request.subject2)
        url = self._build_url("red-flags")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return InsightResponse(**data)


class PetInsightsClient(BaseCategoryClient):
    """Sub-client for pet compatibility insights."""

    API_PREFIX = "/api/v3/insights/pet"

    def get_compatibility(self, request: PetInsightRequest) -> InsightResponse:
        """Get pet-owner compatibility insights.

        Args:
            request: Pet insight request parameters

        Returns:
            Pet compatibility insights response

        Raises:
            AstrologyError: If validation fails or API request fails
        """
        validate_subject(request.owner)
        validate_subject(request.pet)

        url = self._build_url("compatibility")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return InsightResponse(**data)

    def get_personality(self, request: PetPersonalityRequest) -> InsightResponse:
        """Get pet personality analysis."""
        validate_subject(request.subject)
        url = self._build_url("personality")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return InsightResponse(**data)

    def get_training_windows(self, request: SingleSubjectRequest) -> InsightResponse:
        """Get pet training windows."""
        validate_subject(request.subject)
        url = self._build_url("training-windows")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return InsightResponse(**data)

    def get_health_sensitivities(self, request: SingleSubjectRequest) -> InsightResponse:
        """Get pet health sensitivities."""
        validate_subject(request.subject)
        url = self._build_url("health-sensitivities")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return InsightResponse(**data)

    def get_multi_pet_dynamics(self, request: MultiPetRequest) -> InsightResponse:
        """Get multi-pet dynamics analysis."""
        url = self._build_url("multi-pet-dynamics")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return InsightResponse(**data)


class WellnessInsightsClient(BaseCategoryClient):
    """Sub-client for wellness insights."""

    API_PREFIX = "/api/v3/insights/wellness"

    def get_health_insights(self, request: WellnessInsightRequest) -> InsightResponse:
        """Get health insights.

        Args:
            request: Wellness insight request parameters

        Returns:
            Health insights response

        Raises:
            AstrologyError: If validation fails or API request fails
        """
        validate_subject(request.subject)

        url = self._build_url("health")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return InsightResponse(**data)

    def get_fitness_insights(self, request: WellnessInsightRequest) -> InsightResponse:
        """Get fitness insights.

        Args:
            request: Wellness insight request parameters

        Returns:
            Fitness insights response

        Raises:
            AstrologyError: If validation fails or API request fails
        """
        validate_subject(request.subject)

        url = self._build_url("fitness")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return InsightResponse(**data)

    def get_mental_wellness_insights(self, request: WellnessInsightRequest) -> InsightResponse:
        """Get mental wellness insights.

        Args:
            request: Wellness insight request parameters

        Returns:
            Mental wellness insights response

        Raises:
            AstrologyError: If validation fails or API request fails
        """
        validate_subject(request.subject)

        url = self._build_url("mental")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return InsightResponse(**data)

    def get_body_mapping(self, request: WellnessInsightRequest) -> InsightResponse:
        """Get body mapping insights."""
        validate_subject(request.subject)
        url = self._build_url("body-mapping")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return InsightResponse(**data)

    def get_biorhythms(self, request: WellnessInsightRequest) -> InsightResponse:
        """Get biorhythms insights."""
        validate_subject(request.subject)
        url = self._build_url("biorhythms")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return InsightResponse(**data)

    def get_wellness_timing(self, request: WellnessInsightRequest) -> InsightResponse:
        """Get wellness timing insights."""
        validate_subject(request.subject)
        url = self._build_url("wellness-timing")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return InsightResponse(**data)

    def get_energy_patterns(self, request: WellnessInsightRequest) -> InsightResponse:
        """Get energy patterns insights."""
        validate_subject(request.subject)
        url = self._build_url("energy-patterns")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return InsightResponse(**data)

    def get_wellness_score(self, request: WellnessInsightRequest) -> InsightResponse:
        """Get wellness score."""
        validate_subject(request.subject)
        url = self._build_url("wellness-score")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return InsightResponse(**data)

    def get_moon_wellness(self, request: WellnessInsightRequest) -> InsightResponse:
        """Get moon wellness insights."""
        validate_subject(request.subject)
        url = self._build_url("moon-wellness")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return InsightResponse(**data)


class FinancialInsightsClient(BaseCategoryClient):
    """Sub-client for financial insights."""

    API_PREFIX = "/api/v3/insights/financial"

    def get_investment_insights(self, request: FinancialInsightRequest) -> InsightResponse:
        """Get investment timing insights.

        Args:
            request: Financial insight request parameters

        Returns:
            Investment insights response

        Raises:
            AstrologyError: If validation fails or API request fails
        """
        validate_subject(request.subject)

        url = self._build_url("investment")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return InsightResponse(**data)

    def get_career_insights(self, request: FinancialInsightRequest) -> InsightResponse:
        """Get career and financial insights.

        Args:
            request: Financial insight request parameters

        Returns:
            Career insights response

        Raises:
            AstrologyError: If validation fails or API request fails
        """
        validate_subject(request.subject)

        url = self._build_url("career")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return InsightResponse(**data)

    def get_market_timing(self, request: MarketTimingRequest) -> InsightResponse:
        """Get market timing insights."""
        url = self._build_url("market-timing")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return InsightResponse(**data)

    def get_personal_trading(self, request: SingleSubjectRequest) -> InsightResponse:
        """Get personal trading insights."""
        validate_subject(request.subject)
        url = self._build_url("personal-trading")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return InsightResponse(**data)

    def get_gann_analysis(self, request: GannAnalysisRequest) -> InsightResponse:
        """Get Gann cycles analysis."""
        url = self._build_url("gann-analysis")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return InsightResponse(**data)

    def get_bradley_siderograph(self, request: BradleyRequest) -> InsightResponse:
        """Get Bradley siderograph."""
        url = self._build_url("bradley-siderograph")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return InsightResponse(**data)

    def get_crypto_timing(self, request: CryptoTimingRequest) -> InsightResponse:
        """Get crypto timing insights."""
        url = self._build_url("crypto-timing")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return InsightResponse(**data)

    def get_forex_timing(self, request: ForexTimingRequest) -> InsightResponse:
        """Get forex timing insights."""
        url = self._build_url("forex-timing")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return InsightResponse(**data)


class BusinessInsightsClient(BaseCategoryClient):
    """Sub-client for business timing insights."""

    API_PREFIX = "/api/v3/insights/business"

    def get_timing_insights(self, request: BusinessInsightRequest) -> InsightResponse:
        """Get business timing insights.

        Args:
            request: Business insight request parameters

        Returns:
            Business timing insights response

        Raises:
            AstrologyError: If validation fails or API request fails
        """
        validate_subject(request.subject)

        url = self._build_url("timing")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return InsightResponse(**data)

    def get_launch_insights(self, request: BusinessInsightRequest) -> InsightResponse:
        """Get business launch timing insights.

        Args:
            request: Business insight request parameters

        Returns:
            Launch timing insights response

        Raises:
            AstrologyError: If validation fails or API request fails
        """
        validate_subject(request.subject)

        url = self._build_url("launch")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return InsightResponse(**data)

    def get_team_dynamics(self, request: BusinessMultipleRequest) -> InsightResponse:
        """Get team dynamics insights."""
        url = self._build_url("team-dynamics")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return InsightResponse(**data)

    def get_hiring_compatibility(self, request: BusinessMultipleRequest) -> InsightResponse:
        """Get hiring compatibility insights."""
        url = self._build_url("hiring-compatibility")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return InsightResponse(**data)

    def get_leadership_style(self, request: BusinessSingleRequest) -> InsightResponse:
        """Get leadership style insights."""
        validate_subject(request.subject)
        url = self._build_url("leadership-style")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return InsightResponse(**data)

    def get_department_compatibility(self, request: BusinessMultipleRequest) -> InsightResponse:
        """Get department compatibility insights."""
        url = self._build_url("department-compatibility")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return InsightResponse(**data)

    def get_succession_planning(self, request: BusinessSingleRequest) -> InsightResponse:
        """Get succession planning insights."""
        validate_subject(request.subject)
        url = self._build_url("succession-planning")
        data = self._http.post(url, json=request.model_dump(exclude_none=True))
        return InsightResponse(**data)


class InsightsClient(BaseCategoryClient):
    """Client for insights endpoints.

    Provides access to specialized insight categories through nested sub-clients.
    """

    API_PREFIX = "/api/v3/insights"

    def __init__(self, http: HttpHelper) -> None:
        """Initialize insights client with sub-clients.

        Args:
            http: HTTP helper for making requests
        """
        super().__init__(http)
        self.relationship = RelationshipInsightsClient(http)
        self.pet = PetInsightsClient(http)
        self.wellness = WellnessInsightsClient(http)
        self.financial = FinancialInsightsClient(http)
        self.business = BusinessInsightsClient(http)