#!/usr/bin/env python3
"""
Excel to SQL Converter für Container Rates
Konvertiert Excel-Matrix-Daten in SQL INSERT-Statements für die country_matrix_rate Tabelle.
Rundet alle Raten automatisch auf 2 Nachkommastellen.
"""

import pandas as pd
import sys
from pathlib import Path
from datetime import datetime

def read_excel_data(file_path):
    """
    Liest die Excel-Datei und gibt die relevanten Daten zurück.
    """
    try:
        # Excel-Datei einlesen
        df = pd.read_excel(file_path)
        
        # Spalten-Mapping entsprechend der Excel-Struktur
        expected_columns = ['Relation', 'Title', 'recipient country', 'EUR_per_km', 'floater', 'CT per km']
        
        if not all(col in df.columns for col in expected_columns):
            raise ValueError(f"Erwartete Spalten nicht gefunden. Gefunden: {list(df.columns)}")
        
        # Nur relevante Spalten extrahieren
        result_data = []
        for _, row in df.iterrows():
            from_country = row['Title']
            to_country = row['recipient country']
            rate = row['CT per km']
            
            # Null-Werte und leere Zeilen überspringen
            if pd.isna(from_country) or pd.isna(to_country) or pd.isna(rate):
                continue
                
            result_data.append({
                'from_country': str(from_country).strip(),
                'to_country': str(to_country).strip(),
                'rate': round(float(rate), 2)  # Auf 2 Nachkommastellen runden
            })
        
        return result_data
    
    except Exception as e:
        print(f"Fehler beim Lesen der Excel-Datei: {e}")
        sys.exit(1)

def generate_sql_statements(data, output_file):
    """
    Generiert SQL-Statements und schreibt sie in eine Datei.
    """
    sql_statements = []
    
    # Header-Kommentar
    header = f"""-- Container Rates Import
-- Generiert am: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
-- Anzahl Records: {len(data)}
-- Hinweis: Alle Raten wurden auf 2 Nachkommastellen gerundet

-- Subquery zur Ermittlung der aktuell gültigen validity_period_id
-- Diese findet die ID der Periode, die den Status 'VALID' hat und 
-- deren Zeitraum das aktuelle Datum umfasst
SET @validity_period_id = (
    SELECT id 
    FROM validity_period 
    WHERE state = 'VALID' 
      AND start_date <= NOW() 
      AND (end_date IS NULL OR end_date > NOW())
    LIMIT 1
);

-- Fehlerbehandlung falls keine gültige Periode gefunden wird
SELECT CASE 
    WHEN @validity_period_id IS NULL THEN 
        SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT = 'Keine gültige validity_period gefunden!'
    ELSE @validity_period_id
END AS validity_period_check;

"""
    
    sql_statements.append(header)
    
    # INSERT-Statements generieren
    insert_statements = []
    
    for record in data:
        from_country = record['from_country']
        to_country = record['to_country']
        rate = record['rate']
        
        # SQL-Statement für jeden Datensatz
        sql = f"""INSERT INTO country_matrix_rate (
    from_country_id,
    to_country_id,
    rate,
    validity_period_id
) VALUES (
    (SELECT id FROM country WHERE iso_code = '{from_country}'),
    (SELECT id FROM country WHERE iso_code = '{to_country}'),
    {rate:.2f},
    @validity_period_id
);"""
        
        insert_statements.append(sql)
    
    # Alle INSERT-Statements zusammenfügen
    sql_statements.append("-- INSERT-Statements für country_matrix_rate\n")
    sql_statements.extend(insert_statements)
    
    # Abschluss-Kommentar
    footer = f"""
-- Import abgeschlossen
-- {len(data)} Records eingefügt
-- Prüfen Sie die Logs auf Fehler bei nicht gefundenen ISO-Codes

-- Verification Query (optional):
-- SELECT 
--     cmr.*,
--     c_from.iso_code as from_iso,
--     c_to.iso_code as to_iso
-- FROM country_matrix_rate cmr
-- JOIN country c_from ON cmr.from_country_id = c_from.id
-- JOIN country c_to ON cmr.to_country_id = c_to.id
-- WHERE cmr.validity_period_id = @validity_period_id;
"""
    
    sql_statements.append(footer)
    
    # In Datei schreiben
    try:
        with open(output_file, 'w', encoding='utf-8') as f:
            f.write('\n'.join(sql_statements))
        print(f"SQL-Datei erfolgreich erstellt: {output_file}")
        print(f"Anzahl der generierten INSERT-Statements: {len(insert_statements)}")
    except Exception as e:
        print(f"Fehler beim Schreiben der SQL-Datei: {e}")
        sys.exit(1)

def print_data_summary(data):
    """
    Gibt eine Zusammenfassung der gelesenen Daten aus.
    """
    print(f"\n=== DATEN-ZUSAMMENFASSUNG ===")
    print(f"Anzahl Records: {len(data)}")
    
    # Unique from countries
    from_countries = sorted(set(record['from_country'] for record in data))
    print(f"From Countries: {', '.join(from_countries)}")
    
    # Unique to countries  
    to_countries = sorted(set(record['to_country'] for record in data))
    print(f"To Countries: {', '.join(to_countries)}")
    
    # Rate-Statistiken
    rates = [record['rate'] for record in data]
    print(f"Rate Bereich: {min(rates):.2f} - {max(rates):.2f} EUR/km")
    print(f"Durchschnittliche Rate: {sum(rates)/len(rates):.2f} EUR/km")
    
    print(f"\n=== SAMPLE DATA ===")
    for i, record in enumerate(data[:5]):
        print(f"{i+1}. {record['from_country']} -> {record['to_country']}: {record['rate']:.2f} EUR/km")
    if len(data) > 5:
        print(f"... und {len(data)-5} weitere Records")

def main():
    """
    Hauptfunktion des Scripts.
    """
    if len(sys.argv) != 2:
        print("Usage: python excel_to_sql.py <excel_file_path>")
        print("Beispiel: python excel_to_sql.py matrix_data.xlsx")
        sys.exit(1)
    
    excel_file = sys.argv[1]
    
    # Prüfen ob Datei existiert
    if not Path(excel_file).exists():
        print(f"Error: Datei '{excel_file}' nicht gefunden!")
        sys.exit(1)
    
    # Output-Dateiname generieren
    output_file = Path(excel_file).stem + "_import.sql"
    
    print(f"Lese Excel-Datei: {excel_file}")
    
    # Excel-Daten lesen
    data = read_excel_data(excel_file)
    
    if not data:
        print("Keine gültigen Daten in der Excel-Datei gefunden!")
        sys.exit(1)
    
    # Daten-Zusammenfassung anzeigen
    print_data_summary(data)
    
    # SQL-Statements generieren
    print(f"\nGeneriere SQL-Statements...")
    generate_sql_statements(data, output_file)
    
    print(f"\n=== FERTIG ===")
    print(f"SQL-Datei: {output_file}")
    print(f"\nHinweise:")
    print(f"1. Stellen Sie sicher, dass alle ISO-Codes in der country-Tabelle existieren")
    print(f"2. Prüfen Sie, dass eine gültige validity_period mit state='VALID' existiert") 
    print(f"3. Führen Sie die SQL-Datei in Ihrer Datenbank aus")

if __name__ == "__main__":
    main()
