#!/usr/bin/env python3
"""
Excel zu SQL Converter für Material-Datenbank
Liest Excel-Datei aus und erzeugt SQL INSERT-Statements
"""

import pandas as pd
import re
from pathlib import Path

def clean_text(text):
    """Bereinigt Text von SQL-gefährlichen Zeichen"""
    if pd.isna(text) or text is None:
        return ""
    
    # Zu String konvertieren und Anführungszeichen escapen
    text = str(text).strip()
    text = text.replace("'", "''")  # SQL-Escape für single quotes
    return text

def normalize_part_number(part_number):
    """Normalisiert Part Number auf 12 Zeichen mit führenden Nullen"""
    if pd.isna(part_number) or part_number is None:
        return "000000000000"
    
    # Zu String konvertieren (ohne Float-Konvertierung)
    part_str = str(part_number).strip()

    if len(part_str) > 12:
        raise Exception("Part number longer than 12 digits. "+part_str)

    # Bei rein numerischen Werten: mit führenden Nullen auffüllen
    if part_str.isdigit():
        return part_str.zfill(12)
    else:
        # Bei alphanumerischen Part Numbers: auf 12 Zeichen begrenzen/auffüllen
        if len(part_str) > 12:
            raise Exception("Part number longer than 12 digits. "+part_str)
        else:
            return part_str.rjust(12, '0')  # Mit Nullen am Anfang auffüllen

def format_hs_code(hs_code):
    """Formatiert HS Code als 8-stelligen String"""
    if pd.isna(hs_code) or hs_code is None:
        return "NULL"
    
    # Zu String konvertieren
    hs_str = str(hs_code).strip()
    
    # Nur numerische HS Codes verarbeiten
    if hs_str.replace('.', '').isdigit():
        # Float zu Int zu String (entfernt Dezimalstellen)
        hs_str = str(int(float(hs_str))).zfill(8)
        return f"'{hs_str}'"
    else:
        # Nicht-numerische HS Codes direkt verwenden
        return f"'{hs_str}'"

def excel_to_sql(excel_file_path, output_sql_path=None):
    """
    Konvertiert Excel-Datei zu SQL INSERT-Statements
    
    Args:
        excel_file_path: Pfad zur Excel-Datei
        output_sql_path: Pfad für SQL-Output (optional)
    """
    
    print(f"Lese Excel-Datei: {excel_file_path}")
    
    try:
        # Excel-Datei einlesen
        # usecols="B:D" liest nur die Spalten B, C, D
        # skiprows=1 überspringt die erste Zeile (Row 0)
        # dtype=str stellt sicher, dass alle Werte als String gelesen werden
        df = pd.read_excel(
            excel_file_path, 
            usecols="B:D",  # Nur Spalten B, C, D
            skiprows=1,     # Überspringt leere erste Zeile
            sheet_name=0,   # Erstes Sheet
            dtype=str       # Alle Spalten als String lesen
        )
        
        # Spalten umbenennen für bessere Handhabung
        df.columns = ['part_number', 'description', 'hs_code']
        
        print(f"Gefundene Datensätze: {len(df)}")
        
        # Vorschau anzeigen
        show_preview(df)
        
        # Leere Zeilen entfernen
        df = df.dropna(subset=['part_number', 'description'], how='all')
        
        print(f"Datensätze nach Bereinigung: {len(df)}")
        
        # SQL-Statements generieren
        sql_statements = []
        sql_statements.append("-- Material Daten Import")
        sql_statements.append("-- Generiert aus Excel-Datei\n")

        existing_materials = set()
        
        for index, row in df.iterrows():
            try:
                # Daten extrahieren und bereinigen
                part_number = str(row['part_number']).strip() if pd.notna(row['part_number']) else ""
                normalized_part_number = normalize_part_number(row['part_number'])
                name = clean_text(row['description'])
                hs_code = format_hs_code(row['hs_code'])

         
                # Überspringe Zeilen ohne Part Number oder Description
                if not part_number or not name or part_number == 'nan':
                    print(f"Überspringe Zeile {index + 2}: Fehlende Daten")
                    continue
                
                # SQL INSERT-Statement erstellen
                sql = f"""INSERT INTO material (part_number, normalized_part_number, hs_code, name, is_deprecated) 
VALUES ('{part_number}', '{normalized_part_number}', {hs_code}, '{name}', FALSE);"""
                
                if not normalized_part_number in existing_materials:
                    existing_materials.add(normalized_part_number)
                    sql_statements.append(sql)
                else:
                    print(f"Duplikat gefunden: {normalized_part_number}")
                
            except Exception as e:
                print(f"Fehler bei Zeile {index + 2}: {e}")
                continue
        
        # SQL-Ausgabe
        sql_content = "\n".join(sql_statements)
        
        # In Datei schreiben wenn Pfad angegeben
        if output_sql_path:
            with open(output_sql_path, 'w', encoding='utf-8') as f:
                f.write(sql_content)
            print(f"\nSQL-Datei erstellt: {output_sql_path}")
        
        # Auch auf Konsole ausgeben
        print(f"\n--- SQL-Statements ({len(sql_statements) - 2} Datensätze) ---")
        #print(sql_content)
        
        return sql_content
        
    except Exception as e:
        print(f"Fehler beim Verarbeiten der Excel-Datei: {e}")
        return None

def show_preview(df, num_rows=5):
    """Zeigt eine Vorschau der zu verarbeitenden Daten"""
    print(f"\n📋 Vorschau der ersten {num_rows} Datensätze:")
    print("-" * 80)
    for i in range(min(num_rows, len(df))):
        row = df.iloc[i]
        part_num = str(row['part_number']).strip() if pd.notna(row['part_number']) else "N/A"
        normalized = normalize_part_number(row['part_number'])
        name = clean_text(row['description'])[:50] + "..." if len(clean_text(row['description'])) > 50 else clean_text(row['description'])
        hs = format_hs_code(row['hs_code']).replace("'", "")
        
        print(f"  {i+1}. Part: {part_num} → {normalized}")
        print(f"     Name: {name}")
        print(f"     HS:   {hs}")
        print()

def main():
    """Hauptfunktion"""
    # Pfade anpassen
    excel_file = "master_data.xlsx"  # Pfad zur Excel-Datei
    sql_file = "material_import.sql"  # Ausgabe-SQL-Datei
    
    print("🔄 Excel zu SQL Converter für Material-Datenbank")
    print("=" * 50)
    
    # Prüfen ob Excel-Datei existiert
    if not Path(excel_file).exists():
        print(f"❌ Fehler: Excel-Datei '{excel_file}' nicht gefunden!")
        print("Bitte Pfad in der main()-Funktion anpassen.")
        return
    
    # Konvertierung durchführen
    sql_content = excel_to_sql(excel_file, sql_file)
    
    if sql_content:
        print("\n✅ Konvertierung erfolgreich abgeschlossen!")
        print(f"📄 SQL-Statements wurden in '{sql_file}' gespeichert.")
        print(f"📊 Bereit für Import in die Material-Datenbank!")
    else:
        print("\n❌ Konvertierung fehlgeschlagen!")

if __name__ == "__main__":
    main()
