"""Validation tests for Jaimini-specific calculations.

Tests Chara Karaka ordering, Dasha years, Arudha Pada rules,
Special Lagna logic, Argala classification, and edge cases.
"""

import sys
import os
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))

import math
from jaimini.chart.chart import Chart


# ============================================================
# Test data: New China chart (1949-10-01 15:00 CST, Beijing)
# ============================================================

def test_chara_karaka_ordering():
    """Verify Chara Karaka ranking: highest degree in sign = AK.

    For 1949-10-01 Beijing chart:
    Ju at 22.59° in Cap (highest) → AK
    Ve at 19.44° in Sco → AmK
    Ma at 14.88° in Leo → BK
    Me at 13.18° in Lib → MK
    Sa at 13.15° in Vir → PK
    Su at 7.77° in Lib → GK
    Mo at 3.05° in Aqr → DK (lowest)
    """
    chart = Chart(1949, 10, 1, 15, 0, 0, 39.907, 116.397, 8.0)

    # 7-planet system
    k7 = chart.karakas_7
    assert len(k7) == 7
    assert k7[0]['karaka'] == 'AK'
    assert k7[0]['planet'] == 'Ju'
    assert k7[1]['karaka'] == 'AmK'
    assert k7[1]['planet'] == 'Ve'
    assert k7[2]['karaka'] == 'BK'
    assert k7[2]['planet'] == 'Ma'
    assert k7[-1]['karaka'] == 'DK'  # lowest degree
    assert k7[-1]['planet'] == 'Mo'

    # Verify degree ordering (descending)
    for i in range(len(k7) - 1):
        assert k7[i]['degree_in_sign'] >= k7[i + 1]['degree_in_sign']


def test_chara_karaka_degree_sorting():
    """Degrees should sort descending within each sign."""
    chart = Chart(1949, 10, 1, 15, 0, 0, 39.907, 116.397, 8.0)
    k7 = chart.karakas_7

    # All planets should participate
    planets_in_karaka = {k['planet'] for k in k7}
    assert planets_in_karaka == {'Su', 'Mo', 'Ma', 'Me', 'Ju', 'Ve', 'Sa'}

    # Each karaka should be unique
    karaka_types = [k['karaka'] for k in k7]
    assert len(karaka_types) == len(set(karaka_types))


def test_dasha_years_range():
    """Dasha years should always be 1-12."""
    chart = Chart(1949, 10, 1, 15, 0, 0, 39.907, 116.397, 8.0)

    for d in chart.dasha_years:
        assert 1 <= d['years'] <= 12, f"{d['sign_name']} has {d['years']} years (should be 1-12)"


def test_dasha_sequence_complete():
    """Chara Dasha sequence should cover all 12 signs exactly once."""
    chart = Chart(1949, 10, 1, 15, 0, 0, 39.907, 116.397, 8.0)

    signs_covered = {p.sign_idx for p in chart.chara_dasha}
    assert len(signs_covered) == 12  # all 12 signs


def test_dasha_total_cycle():
    """Total of all 12 Chara Dasha years should equal 62 (12-sign cycle sum)."""
    chart = Chart(1949, 10, 1, 15, 0, 0, 39.907, 116.397, 8.0)
    total = sum(d['years'] for d in chart.dasha_years)
    # Each sign's dasha years = count to its lord; total can vary
    # Just verify it's reasonable (50-74 range)
    assert 50 <= total <= 74, f"Total dasha years = {total}, should be ~62 (12 × avg 5.17)"


def test_arudha_pada_count():
    """Should calculate padas for all 12 houses."""
    chart = Chart(1949, 10, 1, 15, 0, 0, 39.907, 116.397, 8.0)
    assert len(chart.padas) == 12


def test_arudha_pada_exception_rule():
    """When Pada falls in same house or 7th, move to 10th.

    In the New China chart, House 4's Pada triggers this exception.
    """
    chart = Chart(1949, 10, 1, 15, 0, 0, 39.907, 116.397, 8.0)

    # Find houses with exception triggered
    exceptions = {h: p for h, p in chart.padas.items()
                  if p.get('exception_triggered')}
    # At least one exception should exist (House 4 in this chart)
    assert len(exceptions) >= 1

    # House 4: Asc=Leo(4), 4th=Sco(7), lord=Ma at Leo(4)
    # Count: 7→4 = 10 signs. Arudha = 4+9 = 13%12 = 1 (Tau)
    # Wait... let's just verify exception is valid
    for h, pada in exceptions.items():
        house_sign = (chart.asc_sign_idx + h - 1) % 12
        seventh = (house_sign + 6) % 12
        # The corrected pada should NOT be the house itself or its 7th
        assert pada['sign_idx'] != house_sign
        assert pada['sign_idx'] != seventh


def test_upapada_calculation():
    """Upapada = Arudha of 12th house."""
    chart = Chart(1949, 10, 1, 15, 0, 0, 39.907, 116.397, 8.0)
    assert chart.upapada is not None
    assert 'sign' in chart.upapada
    assert 'lord' in chart.upapada
    assert 'second_from_ul' in chart.upapada


def test_special_lagnas_exist():
    """HL, GL, VL should all be calculated."""
    chart = Chart(1949, 10, 1, 15, 0, 0, 39.907, 116.397, 8.0)

    sl = chart.special_lagnas
    assert 'HL' in sl
    assert 'GL' in sl
    assert 'VL' in sl

    # HL and GL should share same sign (close to sunrise)
    assert sl['HL']['sign_idx'] == sl['GL']['sign_idx']


def test_special_lagnas_time_sensitivity():
    """GL should change within 30 minutes (1 Ghati = 24 min sensitivity).

    Charts 30 minutes apart can have different Ghatika Lagna signs.
    """
    chart1 = Chart(2025, 6, 15, 12, 0, 0, 28.6, 77.2, 5.5)
    chart2 = Chart(2025, 6, 15, 12, 30, 0, 28.6, 77.2, 5.5)

    gl1 = chart1.special_lagnas['GL']
    gl2 = chart2.special_lagnas['GL']

    # GL changes at least every Ghati (could stay same if within same Ghati)
    # Just verify both are valid and different in degree
    assert 0 <= gl1['sign_idx'] <= 11
    assert 0 <= gl2['sign_idx'] <= 11
    # At least the degree fraction should differ (different Ghati fraction)
    assert gl1['degree_in_sign'] != gl2['degree_in_sign']


def test_divisions_all_planets():
    """D-9 and D-3 should map all 7 classical planets."""
    chart = Chart(1949, 10, 1, 15, 0, 0, 39.907, 116.397, 8.0)

    d9 = chart.divisions['D9']
    d3 = chart.divisions['D3']

    for planet in ['Su', 'Mo', 'Ma', 'Me', 'Ju', 'Ve', 'Sa']:
        assert planet in d9, f"{planet} missing from D9"
        assert planet in d3, f"{planet} missing from D3"
        assert 0 <= d9[planet]['sign_idx'] <= 11
        assert 0 <= d3[planet]['sign_idx'] <= 11


def test_navamsa_mapping():
    """Navamsa should map correctly: fire signs start from Aries forward."""
    chart = Chart(1949, 10, 1, 15, 0, 0, 39.907, 116.397, 8.0)

    # Test: Sun at 187.77° = Libra 7.77°
    # Libra = Air sign (index 6) → start from Libra, forward
    # Navamsa part = int(7.77 / 3.333) = 2
    # Navamsa sign = (6 + 2) % 12 = 8 = Sagittarius
    d9_su = chart.divisions['D9']['Su']
    assert d9_su['sign'] == 'Sgr'
    assert d9_su['navamsa_number'] == 3  # parts 0,1,2 → navamsa #3


def test_argala_all_houses():
    """Argala analysis should cover all 12 houses."""
    chart = Chart(1949, 10, 1, 15, 0, 0, 39.907, 116.397, 8.0)

    assert len(chart.argalas) == 12
    for h in range(1, 13):
        a = chart.argalas[h]
        assert 'primary' in a
        assert 'specific' in a
        assert 'secondary' in a
        assert 'virodhargala' in a
        assert 'net_result' in a
        assert a['net_result'] in ('supported', 'obstructed', 'neutral')


def test_argala_rajayoga_classification():
    """Rajayoga should be one of the four valid types."""
    chart = Chart(1949, 10, 1, 15, 0, 0, 39.907, 116.397, 8.0)

    valid_types = {'Poornargala', 'Tripadargala', 'Ardhargala', 'Padargala'}
    yoga = chart.lagna_rajayoga
    assert yoga['type'] in valid_types
    assert 1 <= yoga['level'] <= 4


def test_karakamsa_rajayoga():
    """Karakamsa Rajayoga should analyze AK in Navamsa."""
    chart = Chart(1949, 10, 1, 15, 0, 0, 39.907, 116.397, 8.0)

    kr = chart.karakamsa_rajayoga
    assert kr['ak_planet'] == 'Ju'  # Atmakaraka
    assert kr['karakamsa_sign'] is not None
    assert kr['yoga_level'] >= 0


def test_different_location_consistency():
    """Same time, different locations should give valid results."""
    locations = [
        (0.0, 0.0),        # Equator, prime meridian
        (51.5074, -0.1278),  # London
        (-33.8688, 151.2093), # Sydney
        (28.6139, 77.2090),   # New Delhi
        (35.6762, 139.6503),  # Tokyo
        (-23.5505, -46.6333), # Sao Paulo
    ]

    for lat, lon in locations:
        chart = Chart(2025, 6, 15, 12, 0, 0, lat, lon, 0.0)
        assert chart.ascendant is not None
        assert len(chart.karakas_7) == 7
        assert len(chart.chara_dasha) == 12
        assert len(chart.padas) == 12


def test_edge_case_zero_latitude():
    """Equatorial charts should not crash."""
    chart = Chart(2025, 3, 20, 6, 0, 0, 0.0, 0.0, 0.0)
    assert chart.ascendant >= 0
    assert len(chart.houses) == 12


def test_edge_case_new_year_midnight():
    """Year boundary should work correctly."""
    chart = Chart(2025, 1, 1, 0, 0, 0, 40.0, -74.0, -5.0)
    assert chart.planets['Su'] is not None


if __name__ == '__main__':
    tests = [
        test_chara_karaka_ordering,
        test_chara_karaka_degree_sorting,
        test_dasha_years_range,
        test_dasha_sequence_complete,
        test_dasha_total_cycle,
        test_arudha_pada_count,
        test_arudha_pada_exception_rule,
        test_upapada_calculation,
        test_special_lagnas_exist,
        test_special_lagnas_time_sensitivity,
        test_divisions_all_planets,
        test_navamsa_mapping,
        test_argala_all_houses,
        test_argala_rajayoga_classification,
        test_karakamsa_rajayoga,
        test_different_location_consistency,
        test_edge_case_zero_latitude,
        test_edge_case_new_year_midnight,
    ]

    passed = 0
    failed = 0
    for test in tests:
        try:
            test()
            print(f"  PASS: {test.__name__}")
            passed += 1
        except AssertionError as e:
            print(f"  FAIL: {test.__name__}: {e}")
            failed += 1
        except Exception as e:
            print(f"  ERROR: {test.__name__}: {type(e).__name__}: {e}")
            failed += 1

    print(f"\n{'='*50}")
    print(f"Results: {passed} passed, {failed} failed, {len(tests)} total")
    assert failed == 0, f"{failed} tests failed!"