"""Independent ephemeris checks, documented conventions and edge-case contracts."""
import math
import json
from pathlib import Path
from datetime import datetime, timezone, date
import pytest
import swisseph as swe
from fastapi.testclient import TestClient
from app import (app, calculate, ChartRequest, limbs_at, datetime_jd, jd_datetime,
    sunrise_panchanga, traditional_patterns, RULES)

def req(**kw):
    return ChartRequest(**dict({'birth_date':'2000-01-01','birth_time':'12:00:00','timezone':'UTC','latitude':27.7172,'longitude':85.324},**kw))

@pytest.mark.parametrize('planet',['Sun','Moon','Mercury','Venus','Mars','Jupiter','Saturn'])
@pytest.mark.parametrize('epoch',[0,1,2,3])
def test_independent_horizons_apparent_longitudes(planet,epoch):
    fixture=json.loads((Path(__file__).parent/'fixtures'/f'jpl_{planet.lower()}_multi_epoch.json').read_text())
    rows=fixture['response']['result'].split('$$SOE')[1].split('$$EOE')[0].strip().splitlines()
    values=rows[epoch].split(',')
    dt=datetime.strptime(values[0].strip(),'%Y-%b-%d %H:%M:%S.%f')
    expected=float(values[3])
    c=calculate(req(birth_date=dt.date(),birth_time=dt.time()),include_details=False)
    actual=(c['planets'][planet]['longitude']+c['ayanamsa_degrees'])%360
    delta=abs((actual-expected+180)%360-180)
    # Horizons apparent IAU76/80 ecliptic-of-date; Swiss uses current precession/
    # nutation models and built-in delta-T. Tolerance 0.01°=36 arcseconds, not
    # a claim of arcsecond certification or full 1900–2100 continuous coverage.
    assert delta<.01, (planet,dt,actual,expected,delta)

@pytest.mark.parametrize('mode',['lahiri','raman','krishnamurti'])
def test_sidereal_reconstruction_and_house_invariants(mode):
    c=calculate(req(ayanamsa=mode),include_details=False)
    for name,body in [('Sun',swe.SUN),('Moon',swe.MOON),('Mercury',swe.MERCURY),('Venus',swe.VENUS),('Mars',swe.MARS),('Jupiter',swe.JUPITER),('Saturn',swe.SATURN)]:
        tropical=swe.calc_ut(2451545,body,swe.FLG_MOSEPH|swe.FLG_SPEED)[0][0]
        assert (c['planets'][name]['longitude']+c['ayanamsa_degrees'])%360==pytest.approx(tropical,abs=1e-6)
        assert c['planets'][name]['house']==(c['planets'][name]['sign_index']-c['ascendant']['sign_index'])%12+1

@pytest.mark.parametrize('lat,lon',[(0,0),(27.7172,85.324),(-33.86,151.21),(51.5,-.12)])
def test_ascendant_independent_spherical_geometry(lat,lon):
    # Independently implement mean sidereal time / horizon-ecliptic intersection.
    # Meeus GMST polynomial at J2000, IAU mean obliquity 23°26'21.448".
    # Nutation omitted intentionally: tolerance0.03° accommodates that and frame differences.
    theta=math.radians((280.46061837+lon)%360)
    eps=math.radians(23+26/60+21.448/3600)
    tropical=(math.degrees(math.atan2(-math.cos(theta),math.sin(theta)*math.cos(eps)+math.tan(math.radians(lat))*math.sin(eps)))+180)%360
    c=calculate(req(latitude=lat,longitude=lon),include_details=False)
    actual=(c['ascendant']['longitude']+c['ayanamsa_degrees'])%360
    assert abs((actual-tropical+180)%360-180)<.03


def test_sunrise_panchanga_five_limbs_and_boundaries():
    c=calculate(req(timezone='Asia/Kathmandu'))
    p=c['panchanga'];rise=p['sunrise_day']
    assert rise and rise['vara']=='Saturday'
    assert datetime.fromisoformat(rise['sunrise_utc'])<=datetime.fromisoformat(c['utc'])
    assert all(key in rise for key in ['tithi','nakshatra','yoga','karana','vara'])
    assert all(datetime.fromisoformat(end)>datetime.fromisoformat(rise['sunrise_utc']) for end in rise['ends_utc'].values())
    # Boundary crossing checked against the exact numerical definitions.
    for key,end in rise['ends_utc'].items():
        jd=datetime_jd(datetime.fromisoformat(end))
        before=limbs_at(jd-1/86400)[key];after=limbs_at(jd+1/86400)[key]
        assert before != after


def test_before_sunrise_uses_previous_solar_day():
    c=calculate(req(birth_time='01:00:00',timezone='Asia/Kathmandu'))
    assert c['panchanga']['sunrise_day']['local_date']=='1999-12-31'
    assert c['panchanga']['sunrise_day']['vara']=='Friday'


def test_polar_no_sunrise_explicit():
    c=calculate(req(birth_date='2025-06-21',latitude=89,longitude=0))
    assert c['panchanga']['sunrise_day'] is None
    assert 'No sunrise' in c['panchanga']['warning']
    assert c['panchanga']['basis']=='instant-only'


def test_karana_sequence_and_paksha():
    # Mock only longitudes to isolate the traditional karana indexing.
    from unittest.mock import patch
    for half,expected in [(0,'Kimstughna'),(1,'Bava'),(7,'Vishti'),(8,'Bava'),(57,'Shakuni'),(58,'Chatushpada'),(59,'Naga')]:
        with patch('app.swe.calc_ut',side_effect=[((0,0,0,0,0,0),0),((half*6+.1,0,0,0,0,0),0)]):
            p=limbs_at(2451545)
            assert p['karana']==expected
            assert p['paksha']==('Shukla' if half<30 else 'Krishna')


def test_uncertainty_has_sampled_sensitivity_and_provenance():
    c=calculate(req(accuracy='approximate',uncertainty_minutes=30))
    u=c['uncertainty'];assert len(u['samples'])==13
    assert u['plus_minus_minutes']==30 and not u['default_window']
    assert u['samples'][0]['offset_minutes']==-30
    assert u['samples'][-1]['offset_minutes']==30
    assert len(c['provenance']['calculator_source_sha256'])==64
    assert c['provenance']['tzdata']
    assert 'uncertainty' not in calculate(req())


def test_rules_are_versioned_defined_and_geometric():
    c=calculate(req(),include_details=False)
    assert c['patterns']['ruleset_version']=='1.0'
    for rule in c['patterns']['rules']:
        assert rule['version']=='1.0' and isinstance(rule['present'],bool) and rule['definition']
    fake={'planets':{name:{'sign_index':0,'house':1} for name in ['Sun','Mercury','Moon','Mars','Jupiter']}}
    assert all(x['present'] for x in traditional_patterns(fake)['rules'])

@pytest.mark.parametrize('calendar,source,ad,bs',[
    ('bs','1975-01-01','1918-04-13','1975-01-01'),
    ('bs','2100-12-30','2044-04-12','2100-12-30'),
    ('ad','2025-04-14','2025-04-14','2082-01-01'),
    ('ad','1918-04-13','1918-04-13','1975-01-01'),
])
def test_calendar_known_and_boundary_dates(monkeypatch,calendar,source,ad,bs):
    monkeypatch.setenv('CALCULATOR_TOKEN','test')
    c=TestClient(app)
    r=c.post('/v1/calendar/convert',json={'calendar':calendar,'date':source},headers={'Authorization':'Bearer test'})
    assert r.status_code==200,r.text
    assert r.json()['ad_date']==ad and r.json()['bs_date']==bs

@pytest.mark.parametrize('calendar,source', [('bs','1974-12-30'),('bs','2101-01-01'),('bs','2082-13-01'),('ad','1918-04-12'),('ad','2044-04-13')])
def test_calendar_out_of_range_rejected(monkeypatch,calendar,source):
    monkeypatch.setenv('CALCULATOR_TOKEN','test')
    assert TestClient(app).post('/v1/calendar/convert',json={'calendar':calendar,'date':source},headers={'Authorization':'Bearer test'}).status_code==422


def test_transit_contract_has_no_natal_dasha(monkeypatch):
    monkeypatch.setenv('CALCULATOR_TOKEN','test')
    r=TestClient(app).post('/v1/transits',json=req().model_dump(mode='json'),headers={'Authorization':'Bearer test'})
    assert r.status_code==200
    assert r.json()['kind']=='transit' and 'dashas' not in r.json()
