from flask import Flask, render_template, request, jsonify
import requests

from negativeYoga import detect_guru_chandal_yoga, detect_shrapit_yoga, detect_vish_yoga, detect_grahan_yoga


app = Flask(__name__)

# Base URLs for VedicAstroAPI
base_url = "https://api.vedicastroapi.com/v3-json/horoscope/planet-details"
dasha_url = "https://api.vedicastroapi.com/v3-json/dashas/maha-dasha"
antar_dasha_url = "https://api.vedicastroapi.com/v3-json/dashas/antar-dasha"
kaalsarp_url = "https://api.vedicastroapi.com/v3-json/dosha/kaalsarp-dosh"
mangal_url = "https://api.vedicastroapi.com/v3-json/dosha/mangal-dosh"
manglik_url = "https://api.vedicastroapi.com/v3-json/dosha/manglik-dosh"
pitra_url = "https://api.vedicastroapi.com/v3-json/dosha/pitra-dosh"
papasamaya_url = "https://api.vedicastroapi.com/v3-json/dosha/papasamaya"

# Your API key for VedicAstroAPI
API_KEY = "5dec6efe-2b0c-5060-b3c3-a55912105099"

# Mapping of exaltation and debilitation signs for each planet
exaltation_signs = {
    "Sun": "Aries",
    "Moon": "Taurus",
    "Mars": "Capricorn",
    "Mercury": "Virgo",
    "Jupiter": "Cancer",
    "Venus": "Pisces",
    "Saturn": "Libra"
}

debilitation_signs = {
    "Sun": "Libra",
    "Moon": "Scorpio",
    "Mars": "Cancer",
    "Mercury": "Pisces",
    "Jupiter": "Capricorn",
    "Venus": "Virgo",
    "Saturn": "Aries"
}

# Rulership signs for each planet
rulership_signs = {
    "Sun": ["Leo"],
    "Moon": ["Cancer"],
    "Mars": ["Aries", "Scorpio"],
    "Mercury": ["Gemini", "Virgo"],
    "Jupiter": ["Sagittarius", "Pisces"],
    "Venus": ["Taurus", "Libra"],
    "Saturn": ["Capricorn", "Aquarius"]
}

# Permanent friendships among planets
planetary_relationships = {
    "Sun": {"friends": ["Moon", "Mars", "Jupiter"], "enemies": ["Venus", "Saturn"]},
    "Moon": {"friends": ["Sun", "Mercury"], "enemies": ["None"]},
    "Mars": {"friends": ["Sun", "Moon", "Jupiter"], "enemies": ["Mercury"]},
    "Mercury": {"friends": ["Sun", "Venus"], "enemies": ["Moon"]},
    "Jupiter": {"friends": ["Sun", "Moon", "Mars"], "enemies": ["Venus", "Mercury"]},
    "Venus": {"friends": ["Mercury", "Saturn"], "enemies": ["Sun", "Moon"]},
    "Saturn": {"friends": ["Mercury", "Venus"], "enemies": ["Sun", "Moon", "Mars"]}
}

@app.route("/", methods=["GET"])
def get_index():
    return render_template("index.html")

@app.route("/result", methods=["GET"])
def get_result():
    return render_template("result.html")

@app.route("/", methods=["POST"])
def process_form():
    form_data = request.form
    print("Form Data Received:", form_data)
    return jsonify(form_data)

@app.route("/planet-details", methods=["POST"])
def get_data():
    day = request.form.get("day")
    month = request.form.get("month")
    year = request.form.get("year")
    hour = request.form.get("hour")
    minute = request.form.get("minute")
    latitude = request.form.get("lat")
    longitude = request.form.get("lon")
    tz = "5.5"
    lang = "en"

    try:
        minute = str(int(minute)).zfill(2)
    except (ValueError, TypeError):
        minute = "00"

    params = {
        "dob": f"{day}/{month}/{year}",
        "tob": f"{hour}:{minute}",
        "lat": latitude,
        "lon": longitude,
        "tz": tz,
        "api_key": API_KEY,
        "lang": lang
    }

    try:
        response = requests.get(base_url, params=params)
        response.raise_for_status()
        data = response.json()
        kundali_data = format_kundali_data(data)
        planetary_positions = format_planetary_positions(data)

        dasha_response = requests.get(dasha_url, params=params)
        dasha_response.raise_for_status()
        dasha_data = dasha_response.json()
        maha_dasha = dasha_data.get("response", [])

        antar_dasha_response = requests.get(antar_dasha_url, params=params)
        antar_dasha_response.raise_for_status()
        antar_dasha_data = antar_dasha_response.json()
        antar_dasha = antar_dasha_data.get("response", [])

        kaalsarp_data = requests.get(kaalsarp_url, params=params).json()
        mangal_data = requests.get(mangal_url, params=params).json()
        manglik_data = requests.get(manglik_url, params=params).json()
        pitra_data = requests.get(pitra_url, params=params).json() 

        vish_yoga = detect_vish_yoga(planetary_positions)
        shrapit_yoga = detect_shrapit_yoga(planetary_positions)
        guru_chandal_yoga = detect_guru_chandal_yoga(planetary_positions)
        grahan_yoga= detect_grahan_yoga(planetary_positions)

        return render_template(
            "result.html",
            data=kundali_data,
            planetary_positions=planetary_positions,
            maha_dasha=maha_dasha,
            antar_dasha=antar_dasha,
            kaalsarp_dosh=kaalsarp_data,
            mangal_dosh=mangal_data,
            manglik_dosh=manglik_data,
            pitra_dosh=pitra_data,
            vish_yoga=vish_yoga,
            shrapit_yoga=shrapit_yoga,
            guru_chandal_yoga=guru_chandal_yoga,
            grahan_yoga=grahan_yoga,
            user_data=request.form.to_dict()

        )

    except requests.exceptions.RequestException as e:
        return jsonify({'error': str(e)}), 500

def format_kundali_data(api_response):
    kundali = {}
    planet_data = api_response.get("response", {})
    for key, value in planet_data.items():
        if key.isdigit():
            planet_name = value.get("full_name", "Unknown")
            kundali[planet_name] = {
                "current_sign": value.get("rasi_no"),
                "fullDegree": value.get("global_degree"),
                "normDegree": value.get("local_degree"),
                "isRetro": str(value.get("retro", False)).lower()
            }
    return kundali

def determine_dignity(planet, sign):
    """
    Determines the dignity of a planet based on its sign.
    """
    if planet not in exaltation_signs:
        return " "

    if sign == exaltation_signs[planet]:
        return "Exalted"
    elif sign == debilitation_signs[planet]:
        return "Debilitated"
    elif sign in rulership_signs.get(planet, []):
        return "Own Sign"
    elif planet == "Moon" and sign == "Aries":
        return "Friendly Sign"
    elif sign in get_friendly_signs(planet):
        return "Friendly Sign"
    elif sign in get_enemy_signs(planet):
        return "Enemy Sign"
    else:
        return "Neutral"


def get_friendly_signs(planet):
    friends = planetary_relationships.get(planet, {}).get("friends", [])
    signs = []
    for friend in friends:
        signs.extend(rulership_signs.get(friend, []))
    return signs

def get_enemy_signs(planet):
    enemies = planetary_relationships.get(planet, {}).get("enemies", [])
    signs = []
    for enemy in enemies:
        signs.extend(rulership_signs.get(enemy, []))
    return signs




def format_planetary_positions(api_response):
    positions = []
    planet_data = api_response.get("response", {})
    for key, value in planet_data.items():
        if key.isdigit():
            planet_name = value.get("full_name", "Unknown")
            sign = value.get("zodiac", "Unknown")
            dignity = determine_dignity(planet_name, sign)
            positions.append({
                "Planet": planet_name,
                "Sign": sign,
                "Degree": round(value.get("local_degree", 0.0), 2),
                "Nakshatra": value.get("nakshatra", "Unknown"),
                "Nakshatra Lord": value.get("nakshatra_lord", "Unknown"),
                "House": value.get("house", "Unknown"),
                "Dignity": dignity
            })
    return positions

if __name__ == "__main__":
    app.run(debug=True)