import logging
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)

import gradio as gr
from gradio_calendar import Calendar
from gematria import calculate_gematria, strip_diacritics
from datetime import datetime, timedelta
import json

# --- Hilfsfunktionen ---
def calculate_gematria_sum(text):
    """
    Berechnet die Gematria-Summe eines gegebenen Textes.

    Args:
      text: Der Text, für den die Gematria-Summe berechnet werden soll.

    Returns:
      Die Gematria-Summe des Textes, oder None, falls der Text leer ist.
    """
    if text:
        text_gematria = calculate_gematria(strip_diacritics(text))
        return text_gematria
    else:
        return None

def date_to_words(date_string):
    """
    Konvertiert ein Datum im Format YYYY-MM-DD in die englische Schreibweise des Tages.

    Args:
      date_string: Ein Datum im Format YYYY-MM-DD.

    Returns:
      Einen String mit der englischen Schreibweise des Tages.
    """
    date_obj = datetime.strptime(date_string, "%Y-%m-%d")
    return date_obj.strftime("%A")

def perform_gematria_calculation_for_date_range(start_date, end_date):
    """
    Führt die Gematria-Berechnung für einen Datumsbereich durch.

    Args:
      start_date: Das Startdatum als datetime-Objekt.
      end_date: Das Enddatum als datetime-Objekt.

    Returns:
      Ein Dictionary mit den Ergebnissen, gruppiert nach Gematria-Summe.
    """
    logger.info(f"Startdatum: {start_date}, Enddatum: {end_date}")
    results = {}
    delta = timedelta(days=1)
    current_date = start_date

    while current_date <= end_date:
        # Datum in String umwandeln
        date_string = current_date.strftime("%Y-%m-%d")
        date_words = date_to_words(date_string)
        logger.info(f"Datum: {current_date}, Tagesname: {date_words}")
        gematria_sum = calculate_gematria_sum(date_words)
        logger.info(f"Gematria-Summe: {gematria_sum}")

        if gematria_sum not in results:
            results[gematria_sum] = []

        results[gematria_sum].append({
            "date": current_date.strftime('%Y-%m-%d'),
            "date_words": date_words
        })

        current_date += delta

    return results

def generate_json_output(results, start_date, end_date):
    """
    Generiert die JSON-Ausgabe mit dem Datumsbereich und den Ergebnissen.

    Args:
      results: Ein Dictionary mit den Ergebnissen, gruppiert nach Gematria-Summe.
      start_date: Das Startdatum als datetime-Objekt.
      end_date: Das Enddatum als datetime-Objekt.

    Returns:
      Einen JSON-String mit den Ergebnissen.
    """
    result = {
        "DateRange": {
            "StartDate": start_date.strftime("%Y-%m-%d"),
            "EndDate": end_date.strftime("%Y-%m-%d")
        },
        "Results": results
    }
    return json.dumps(result, indent=4, ensure_ascii=False)

# --- Hauptanwendung mit Gradio ---
with gr.Blocks() as app:
    with gr.Row():
        start_date = Calendar(type="datetime", label="Startdatum")
        end_date = Calendar(type="datetime", label="Enddatum")

    calculate_btn = gr.Button("Gematria für Zeitraum berechnen")
    json_output = gr.Textbox(label="JSON-Ausgabe")

    # --- Event-Handler ---
    def perform_calculation(start_date, end_date):
        """
        Führt die Berechnung aus und generiert die JSON-Ausgabe.

        Args:
          start_date: Das Startdatum als datetime-Objekt.
          end_date: Das Enddatum als datetime-Objekt.

        Returns:
          Den JSON-String mit den Ergebnissen.
        """
        logger.info(f"perform_calculation aufgerufen mit: start_date={start_date}, end_date={end_date}")
        results = perform_gematria_calculation_for_date_range(start_date, end_date)
        json_result = generate_json_output(results, start_date, end_date)
        return json_result

    # --- Event-Trigger ---
    calculate_btn.click(
        perform_calculation,
        inputs=[start_date, end_date],
        outputs=[json_output],
        api_name="calculate_gematria"
    )

if __name__ == "__main__":
    app.launch(share=False)