"""Deterministic sidereal calculations. No generated interpretation."""
import os
import hmac
import threading
import sys
import hashlib
import platform
import importlib.metadata
from pathlib import Path
from datetime import date, datetime, time, timezone, timedelta
from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
from typing import Literal
import swisseph as swe
from fastapi import FastAPI, HTTPException, Header
from pydantic import BaseModel, Field

app = FastAPI(title='Kundali calculation service', version='1.1.0')
LOCK = threading.RLock()  # Swiss Ephemeris has process-global sidereal settings.
SIGNS = ['Aries','Taurus','Gemini','Cancer','Leo','Virgo','Libra','Scorpio','Sagittarius','Capricorn','Aquarius','Pisces']
NAKSHATRAS = ['Ashwini','Bharani','Krittika','Rohini','Mrigashira','Ardra','Punarvasu','Pushya','Ashlesha','Magha','Purva Phalguni','Uttara Phalguni','Hasta','Chitra','Swati','Vishakha','Anuradha','Jyeshtha','Mula','Purva Ashadha','Uttara Ashadha','Shravana','Dhanishta','Shatabhisha','Purva Bhadrapada','Uttara Bhadrapada','Revati']
LORDS = ['Ketu','Venus','Sun','Moon','Mars','Rahu','Jupiter','Saturn','Mercury']
YEARS = [7,20,6,10,7,18,16,19,17]
YEAR_DAYS = 365.25

class ChartRequest(BaseModel):
    birth_date: date
    birth_time: time | None = None
    timezone: str = Field(min_length=1, max_length=80)
    latitude: float = Field(ge=-89, le=89)
    longitude: float = Field(ge=-180, le=180)
    accuracy: Literal['exact','approximate','unknown'] = 'exact'
    ayanamsa: Literal['lahiri','raman','krishnamurti'] = 'lahiri'
    node: Literal['mean','true'] = 'mean'
    fold: Literal[0,1] | None = None
    uncertainty_minutes: int | None = Field(default=None,ge=1,le=120)

    model_config = {'extra':'forbid'}

def authorize(authorization):
    token = os.getenv('CALCULATOR_TOKEN','')
    if not token:
        raise HTTPException(503, 'CALCULATOR_TOKEN is not configured')
    if not authorization or not hmac.compare_digest(authorization, 'Bearer '+token):
        raise HTTPException(401, 'Invalid service credential')

def local_to_utc(req):
    try:
        zone = ZoneInfo(req.timezone)
    except ZoneInfoNotFoundError:
        raise ValueError('Unknown IANA timezone')
    if req.birth_time is None:
        raise ValueError('Birth time is required unless accuracy is unknown')
    if req.birth_time.tzinfo is not None:
        raise ValueError('Birth time must be a local time without UTC offset')
    naive = datetime.combine(req.birth_date, req.birth_time)
    valid = []
    for fold in (0,1):
        local = naive.replace(tzinfo=zone, fold=fold)
        if local.astimezone(timezone.utc).astimezone(zone).replace(tzinfo=None) == naive:
            valid.append(local)
    if not valid:
        raise ValueError('Local birth time does not exist due to a timezone transition')
    ambiguous = len(valid)==2 and valid[0].utcoffset()!=valid[1].utcoffset()
    if ambiguous and req.fold is None:
        raise ValueError('Ambiguous local birth time: specify fold 0 (first occurrence) or 1 (second)')
    local = naive.replace(tzinfo=zone,fold=req.fold or 0)
    return local.astimezone(timezone.utc), int(local.utcoffset().total_seconds())

def placement(longitude, speed=0, asc_sign=None):
    longitude %= 360
    sign = int(longitude//30)
    nak = int(longitude/(40/3))
    # Each sign spans nine navamsas; multiplying full longitude by nine is equivalent.
    nav = int((longitude*9)%360//30)
    return {'longitude':round(longitude,8),'degree':round(longitude%30,8),
            'sign':SIGNS[sign],'sign_index':sign,'navamsa_sign':SIGNS[nav],
            'navamsa_sign_index':nav,'nakshatra':NAKSHATRAS[nak],
            'pada':int((longitude%(40/3))/(10/3))+1,
            'retrograde':speed<0,'speed':round(speed,8),
            'house':((sign-asc_sign)%12+1) if asc_sign is not None else None}

def dashas(moon_longitude, born):
    nak = moon_longitude/(40/3)
    lord = int(nak)%9
    elapsed = nak%1
    start = born - timedelta(days=elapsed*YEARS[lord]*YEAR_DAYS)
    result=[]
    for step in range(10):
        idx=(lord+step)%9
        end=start+timedelta(days=YEARS[idx]*YEAR_DAYS)
        ant=[]
        cursor=start
        for sub in range(9):
            j=(idx+sub)%9
            boundary=cursor+timedelta(days=YEARS[idx]*YEARS[j]/120*YEAR_DAYS)
            ant.append({'lord':LORDS[j],'start':cursor.isoformat(),'end':boundary.isoformat()})
            cursor=boundary
        result.append({'lord':LORDS[idx],'start':start.isoformat(),'end':end.isoformat(),'antardashas':ant})
        start=end
    return result

def calculate(req, *, include_details=True):
    if not 1900 <= req.birth_date.year <= 2100:
        raise ValueError('Supported birth dates: 1900–2100')
    try:
        ZoneInfo(req.timezone)
    except ZoneInfoNotFoundError:
        raise ValueError('Unknown IANA timezone')
    base={'schema_version':'1.0','engine':'Swiss Ephemeris '+swe.version,
          'ephemeris':'Moshier analytic ephemeris (explicit; no external data files)',
          'settings':{'ayanamsa':req.ayanamsa,'node':req.node,'houses':'whole-sign','dasha_year_days':YEAR_DAYS,'ephemeris_flags':swe.FLG_MOSEPH|swe.FLG_SPEED|swe.FLG_SIDEREAL,'sunrise':'Hindu rising; flat sea-level horizon'},
          'provenance':provenance(), 'accuracy':req.accuracy,'warnings':[], 'planets':{},'ascendant':None,'dashas':[]}
    if req.accuracy=='unknown':
        base['warnings']=['Birth time unknown: no instant, Ascendant, houses, D9, or dasha has been invented. Supply a time to generate this chart.']
        return base
    utc, offset=local_to_utc(req)
    base.update({'utc':utc.isoformat(),'utc_offset_seconds':offset})
    if req.accuracy=='approximate':
        base['warnings'].append('Approximate birth time: Ascendant, houses, D9 and dasha boundaries are uncertain; results use the supplied time only.')
    with LOCK:
        swe.set_sid_mode({'lahiri':swe.SIDM_LAHIRI,'raman':swe.SIDM_RAMAN,'krishnamurti':swe.SIDM_KRISHNAMURTI}[req.ayanamsa])
        jd=swe.julday(utc.year,utc.month,utc.day,utc.hour+utc.minute/60+utc.second/3600+utc.microsecond/3.6e9)
        flags=swe.FLG_MOSEPH|swe.FLG_SPEED|swe.FLG_SIDEREAL
        _, ascmc=swe.houses_ex(jd,req.latitude,req.longitude,b'W',swe.FLG_SIDEREAL)
        asc=placement(ascmc[0]); asc_sign=asc['sign_index']
        base['ascendant']=asc
        bodies=[('Sun',swe.SUN),('Moon',swe.MOON),('Mars',swe.MARS),('Mercury',swe.MERCURY),('Jupiter',swe.JUPITER),('Venus',swe.VENUS),('Saturn',swe.SATURN),('Rahu',swe.MEAN_NODE if req.node=='mean' else swe.TRUE_NODE)]
        for name, body in bodies:
            values,ret=swe.calc_ut(jd,body,flags)
            base['planets'][name]=placement(values[0],values[3],asc_sign)
        rahu=base['planets']['Rahu']
        base['planets']['Ketu']=placement(rahu['longitude']+180,rahu['speed'],asc_sign)
        base['ayanamsa_degrees']=swe.get_ayanamsa_ex_ut(jd,swe.FLG_MOSEPH)[1]
        base['mean_ayanamsa_degrees']=swe.get_ayanamsa_ut(jd)
    base['dashas']=dashas(base['planets']['Moon']['longitude'],utc)
    sun=base['planets']['Sun']['longitude'];moon=base['planets']['Moon']['longitude']
    base['panchanga']={'tithi':int(((moon-sun)%360)//12)+1,'yoga':int(((moon+sun)%360)/(40/3))+1,'nakshatra':base['planets']['Moon']['nakshatra'],'note':'Instant-based tithi and yoga only; sunrise-based vara and karana labels are not implemented.'}
    base['d1']={k:v['sign_index'] for k,v in base['planets'].items()}
    base['d9']={k:v['navamsa_sign_index'] for k,v in base['planets'].items()}
    base['patterns']=traditional_patterns(base)
    if include_details:
        with LOCK:
            base['panchanga']=sunrise_panchanga(req,utc)
        if req.accuracy=='approximate':
            base['uncertainty']=sensitivity(req,utc)
    return base

# Pure rule definitions are versioned and identify variation rather than predicting events.
RULES = [
    {'id':'budha-aditya-conjunction','version':'1.0','name':'Budha-Aditya pattern','definition':'Sun and Mercury occupy the same sidereal sign; combustion, strength and other cancellation variants are not evaluated.'},
    {'id':'gaja-kesari-kendra','version':'1.0','name':'Gaja-Kesari pattern','definition':'Jupiter occupies the 1st, 4th, 7th or 10th whole sign counted from the Moon; strength, aspects and cancellation variants are not evaluated.'},
    {'id':'chandra-mangala-conjunction','version':'1.0','name':'Chandra-Mangala pattern','definition':'Moon and Mars occupy the same sidereal sign; mutual-aspect variants are not included.'},
    {'id':'manglik-lagna-selected-houses','version':'1.0','name':'Manglik house pattern','definition':'Mars occupies whole-sign house 1, 2, 4, 7, 8 or 12 from Lagna. Traditions differ on house 2 and cancellation rules; those exclusions and Moon/Venus reference variants are not evaluated.'},
]

def traditional_patterns(chart):
    p=chart['planets']
    conditions=[p['Sun']['sign_index']==p['Mercury']['sign_index'],
                (p['Jupiter']['sign_index']-p['Moon']['sign_index'])%12+1 in (1,4,7,10),
                p['Moon']['sign_index']==p['Mars']['sign_index'],
                p['Mars']['house'] in (1,2,4,7,8,12)]
    return {'ruleset_version':'1.0','notice':'Traditional geometric patterns only, not proven predictions or judgments about relationships. No remedies or adverse outcomes are inferred.',
            'rules':[{**rule,'present':present} for rule,present in zip(RULES,conditions)]}

def provenance():
    paths=['/usr/share/zoneinfo/tzdata.zi','/usr/share/zoneinfo/+VERSION']
    tz='system zoneinfo (version file unavailable)'
    for path in paths:
        if Path(path).exists():
            tz=Path(path).read_text(errors='replace').splitlines()[0]
            break
    return {'python':platform.python_version(),'swisseph':swe.version,
            'pyswisseph':importlib.metadata.version('pyswisseph'),'tzdata':tz,
            'calculator_source_sha256':hashlib.sha256(Path(__file__).read_bytes()).hexdigest(),
            'time_basis':'UTC represented as UT for swe.calc_ut; pre-1972 UTC/UT1 distinction and leap seconds are not modeled',
            'coordinates':'geocentric apparent sidereal longitude of date',
            'delta_t':'Swiss Ephemeris built-in model', 'rule_version':'1.0'}

def jd_datetime(jd):
    # Convert through Unix epoch to preserve fractional seconds and avoid 24:00 rounding.
    return datetime(1970,1,1,tzinfo=timezone.utc)+timedelta(days=jd-2440587.5)

def datetime_jd(dt):
    return 2440587.5+(dt-datetime(1970,1,1,tzinfo=timezone.utc)).total_seconds()/86400

YOGAS=['Vishkambha','Priti','Ayushman','Saubhagya','Shobhana','Atiganda','Sukarma','Dhriti','Shula','Ganda','Vriddhi','Dhruva','Vyaghata','Harshana','Vajra','Siddhi','Vyatipata','Variyana','Parigha','Shiva','Siddha','Sadhya','Shubha','Shukla','Brahma','Indra','Vaidhriti']
KARANAS=['Bava','Balava','Kaulava','Taitila','Garaja','Vanija','Vishti']
WEEKDAYS=['Monday','Tuesday','Wednesday','Thursday','Friday','Saturday','Sunday']

def limbs_at(jd):
    flags=swe.FLG_MOSEPH|swe.FLG_SIDEREAL
    sun=swe.calc_ut(jd,swe.SUN,flags)[0][0]
    moon=swe.calc_ut(jd,swe.MOON,flags)[0][0]
    elong=(moon-sun)%360
    half=int(elong//6)
    karana='Kimstughna' if half==0 else ('Shakuni','Chatushpada','Naga')[half-57] if half>=57 else KARANAS[(half-1)%7]
    tithi=int(elong//12)+1
    nak=int(moon/(40/3)); yoga=int(((moon+sun)%360)/(40/3))
    return {'tithi':tithi,'paksha':'Shukla' if tithi<=15 else 'Krishna','tithi_in_paksha':(tithi-1)%15+1,
            'nakshatra':NAKSHATRAS[nak],'nakshatra_index':nak+1,'yoga':yoga+1,'yoga_name':YOGAS[yoga],
            'karana':karana,'karana_index':half+1}

def limb_end(jd,key,initial):
    # Bracket the next transition with 30-minute steps; then bisect to <0.1 second.
    lower=jd
    for i in range(1,145):
        upper=jd+i/48
        if limbs_at(upper)[key] != initial:
            for _ in range(24):
                mid=(lower+upper)/2
                if limbs_at(mid)[key]==initial: lower=mid
                else: upper=mid
            return jd_datetime((lower+upper)/2).isoformat()
        lower=upper
    return None

def solar_event(local_day,req,event):
    zone=ZoneInfo(req.timezone)
    start=datetime.combine(local_day,time.min).replace(tzinfo=zone).astimezone(timezone.utc)
    result,times=swe.rise_trans(datetime_jd(start),swe.SUN,event|swe.BIT_HINDU_RISING,
        (req.longitude,req.latitude,0),0,0,swe.FLG_MOSEPH)
    if result!=0: return None
    when=jd_datetime(times[0])
    return when if when.astimezone(zone).date()==local_day else None

def sunrise_panchanga(req,utc):
    swe.set_sid_mode({'lahiri':swe.SIDM_LAHIRI,'raman':swe.SIDM_RAMAN,'krishnamurti':swe.SIDM_KRISHNAMURTI}[req.ayanamsa])
    instant=limbs_at(datetime_jd(utc))
    convention='Hindu rising: center of Sun, no atmospheric refraction, geocentric ecliptic projection; sea-level flat horizon'
    day=utc.astimezone(ZoneInfo(req.timezone)).date()
    rise=solar_event(day,req,swe.CALC_RISE)
    if rise is not None and rise>utc:
        day-=timedelta(days=1)
        rise=solar_event(day,req,swe.CALC_RISE)
    if rise is None:
        return {**instant,'basis':'instant-only','sunrise_day':None,'sunrise_convention':convention,
                'warning':'No sunrise on the relevant local date at this latitude. Sunrise-based Panchanga and vara are unavailable; instant limbs remain available.'}
    jd=datetime_jd(rise)
    limbs=limbs_at(jd)
    set_status,set_times=swe.rise_trans(jd+1/86400,swe.SUN,swe.CALC_SET|swe.BIT_HINDU_RISING,(req.longitude,req.latitude,0),0,0,swe.FLG_MOSEPH)
    setting=jd_datetime(set_times[0]) if set_status==0 else None
    ends={key:limb_end(jd,key,limbs[key]) for key in ('tithi','nakshatra','yoga','karana')}
    return {**instant,'basis':'instant plus most recent sunrise','sunrise_convention':convention,
            'sunrise_day':{'local_date':str(day),'sunrise_utc':rise.isoformat(),
                'sunrise_local':rise.astimezone(ZoneInfo(req.timezone)).isoformat(),
                'sunset_utc':setting.isoformat() if setting else None,
                'vara':WEEKDAYS[day.weekday()],**limbs,'ends_utc':ends},
            'note':'Five limbs at the most recent local sunrise, plus instant limbs at the requested time. Transition times are numerical boundaries for the documented convention; no local terrain, elevation or atmospheric corrections.'}

def sensitivity(req,utc):
    minutes=req.uncertainty_minutes or 15
    samples=[]
    for step in range(-6,7):
        shifted=utc+timedelta(minutes=minutes*step/6)
        local=shifted.astimezone(ZoneInfo(req.timezone))
        sampled=req.model_copy(update={'birth_date':local.date(),'birth_time':local.time().replace(tzinfo=None),
            'fold':local.fold,'accuracy':'exact','uncertainty_minutes':None})
        try:
            chart=calculate(sampled,include_details=False)
            samples.append({'offset_minutes':minutes*step/6,'utc':shifted.isoformat(),
                'ascendant_sign':chart['ascendant']['sign'],'ascendant_d9_sign':chart['ascendant']['navamsa_sign'],
                'd9':chart['d9'],'starting_dasha':chart['dashas'][0]['lord'],
                'starting_dasha_end':chart['dashas'][0]['end']})
        except (ValueError,swe.Error) as error:
            samples.append({'offset_minutes':minutes*step/6,'error':str(error)})
    valid=[s for s in samples if 'error' not in s]
    asc=sorted({s['ascendant_sign'] for s in valid})
    asc9=sorted({s['ascendant_d9_sign'] for s in valid})
    d9={name:sorted({s['d9'][name] for s in valid}) for name in req_planet_names()}
    boundaries=[s['starting_dasha_end'] for s in valid]
    return {'plus_minus_minutes':minutes,'default_window':req.uncertainty_minutes is None,
            'method':'13 equally spaced instants across a UTC duration around supplied time; sampled sensitivity, not exhaustive interval proof or probability',
            'ascendant_signs':asc,'ascendant_d9_signs':asc9,'d9_possible_sampled_signs':d9,
            'starting_dasha_lords':sorted({s['starting_dasha'] for s in valid}),
            'starting_dasha_end_range':{'earliest':min(boundaries),'latest':max(boundaries)} if boundaries else None,
            'samples':samples}

def req_planet_names():
    return ['Sun','Moon','Mars','Mercury','Jupiter','Venus','Saturn','Rahu','Ketu']

class CalendarRequest(BaseModel):
    calendar: Literal['bs','ad']
    date: str = Field(pattern=r'^\d{4}-\d{2}-\d{2}$')
    model_config={'extra':'forbid'}

@app.post('/v1/calendar/convert')
def calendar_convert(req:CalendarRequest,authorization:str|None=Header(default=None)):
    authorize(authorization)
    import nepali_datetime as nd
    try:
        if req.calendar=='bs':
            y,m,d=map(int,req.date.split('-'))
            bs=nd.date(y,m,d); ad=bs.to_datetime_date()
        else:
            ad=date.fromisoformat(req.date);bs=nd.date.from_datetime_date(ad)
        return {'original':{'calendar':req.calendar,'date':req.date},'gregorian':str(ad),'bs':str(bs),'ad_date':str(ad),'bs_date':str(bs),
                'library':'nepali-datetime '+importlib.metadata.version('nepali-datetime'),
                'supported':{'bs_start':'1975-01-01','bs_end':'2100-12-30','ad_start':'1918-04-13','ad_end':'2044-04-12'}}
    except (ValueError,OverflowError):
        raise HTTPException(422,'Invalid or unsupported date. Supported BS 1975-01-01 through 2100-12-30 (AD 1918-04-13 through 2044-04-12).')

@app.get('/health')
def health():
    return {'status':'ok','engine':swe.version,'configured':bool(os.getenv('CALCULATOR_TOKEN'))}

@app.post('/v1/charts')
def chart(req:ChartRequest, authorization:str|None=Header(default=None)):
    authorize(authorization)
    try:
        return calculate(req)
    except (ValueError,swe.Error) as error:
        raise HTTPException(422,str(error))

class TransitRequest(ChartRequest):
    pass

@app.post('/v1/transits')
def transits(req:TransitRequest, authorization:str|None=Header(default=None)):
    """Caller supplies the transit date/time explicitly; never use a hidden current instant."""
    result=chart(req,authorization)
    result['kind']='transit'
    result.pop('dashas',None)
    result.pop('patterns',None)
    if 'uncertainty' in result:
        result['uncertainty'].pop('starting_dasha_lords',None)
        result['uncertainty'].pop('starting_dasha_end_range',None)
        for sample in result['uncertainty'].get('samples',[]):
            sample.pop('starting_dasha',None)
            sample.pop('starting_dasha_end',None)
    return result

class ReportRequest(BaseModel):
    profile: dict
    chart: dict
    model_config = {'extra':'forbid'}

@app.post('/v1/reports')
def report(req:ReportRequest, authorization:str|None=Header(default=None)):
    authorize(authorization)
    from fastapi.responses import Response
    from reporting import build_report
    try:
        data=build_report(req.profile,req.chart)
    except (ValueError, TypeError, KeyError):
        raise HTTPException(422,'Invalid report profile or chart data')
    return Response(data,media_type='application/pdf',headers={'Cache-Control':'no-store','Content-Disposition':'attachment; filename="kundali.pdf"'})
