import json
import logging
import argparse
import sys
import os
import re
import math
import csv # NEU: Für den Export der Ergebnisse
from gematria import calculate_gematria

# --- Konfiguration ---
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
BOOK_RANGE = range(1, 40)

# --- Kernfunktion (direkt aus Ihrem Beispiel) ---

def xor_with_highest_power(total_sum, query_value):
    """
    Berechnet XOR mit der höchsten Potenz des Anfrage-Wertes.
    Gibt (Exponent, Potenz, XOR-Ergebnis) zurück.
    """
    if total_sum <= 0 or query_value <= 1:
        return None, None, None # Fehlerfall elegant behandeln

    if query_value > total_sum:
        exponent = 0
        power = 1
    else:
        try:
            # floor(log_base(value))
            exponent = int(math.floor(math.log(total_sum) / math.log(query_value)))
            power = query_value ** exponent
        except ValueError: # math domain error, z.B. bei log(1)
            return None, None, None

    xor_result = total_sum ^ power
    return exponent, power, xor_result

# --- Hauptprogramm ---

def main(args):
    # 1. Berechne Gematria-Wert der Anfrage
    query_value = calculate_gematria(args.query)
    if query_value <= 1:
        sys.exit(f"Anfrage '{args.query}' hat einen ungültigen Gematria-Wert ({query_value}). Wert muss > 1 sein.")

    logging.info(f"Starte Vers-Matrix-Analyse für '{args.query}' (Gematria: {query_value})...")

    all_results = []

    # 2. Iteriere durch jeden Vers des Tanach
    for book_num in BOOK_RANGE:
        filepath = f"texts/torah/{book_num:02}.json"
        try:
            with open(filepath, 'r', encoding='utf-8') as file:
                data = json.load(file)
                book_title = data.get("title", f"Buch {book_num:02}")
                logging.info(f"Verarbeite {book_title}...")

                # Iteriere durch Kapitel und Verse
                for chap_idx, chapter in enumerate(data.get("text", []), start=1):
                    for verse_idx, verse_text in enumerate(chapter, start=1):

                        # Berechne Gematria-Summe des Verses
                        verse_sum = calculate_gematria(verse_text)
                        if verse_sum <= 1: continue

                        # Führe die XOR-Operation durch
                        k, power, xor_val = xor_with_highest_power(verse_sum, query_value)
                        if xor_val is None: continue

                        # Sammle die Ergebnisse
                        all_results.append({
                            "Book": book_num,
                            "Chapter": chap_idx,
                            "Verse": verse_idx,
                            "Query": args.query,
                            "Query Value": query_value,
                            "Verse Gematria": verse_sum,
                            "Exponent k": k,
                            "Power (Query^k)": power,
                            "XOR Result": xor_val,
                            "Verse Text": verse_text.strip()
                        })
        except FileNotFoundError:
            logging.warning(f"Datei {filepath} nicht gefunden, wird übersprungen.")
            continue

    # 3. Gib die Ergebnisse aus und speichere sie
    if not all_results:
        print("Keine Ergebnisse zum Anzeigen oder Speichern.")
        return

    # Ausgabe auf der Konsole (begrenzt, um sie nicht zu überfluten)
    print("\n" + "="*15 + f" RESONANZ-MATRIX FÜR '{args.query}' (erste {args.limit} Ergebnisse) " + "="*15)
    for r in all_results[:args.limit]:
        print(f"B{r['Book']:02d} C{r['Chapter']} V{r['Verse']} | G_sum={r['Verse Gematria']:<5} | k={r['Exponent k']:<2} | P={r['Power (Query^k)']:<8} | XOR={r['XOR Result']}")

    # Speichere die vollständigen Ergebnisse in einer CSV-Datei
    output_filename = f"analysis_{args.query.replace(' ', '_')}.csv"
    logging.info(f"Speichere alle {len(all_results)} Ergebnisse in '{output_filename}'...")
    with open(output_filename, 'w', newline='', encoding='utf-8') as csvfile:
        fieldnames = all_results[0].keys()
        writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
        writer.writeheader()
        writer.writerows(all_results)

    logging.info("Analyse abgeschlossen. Vollständige Daten wurden in der CSV-Datei gespeichert.")


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Tanakh Verse-by-Verse Resonance Matrix Analyzer.")
    parser.add_argument("query", type=str, help="Die Abfragephrase (z.B. 'יהוה').")
    parser.add_argument("--limit", type=int, default=50, help="Anzahl der auf der Konsole anzuzeigenden Ergebnisse.")
    args = parser.parse_args()
    main(args)