#!/usr/bin/env python3
"""
Parser for L0-L7 binary energy data files from meterdata.archive.
Liest das ZIP-Archiv meterdata.archive, durchsucht Verzeichnisse unter 'charts/',
parsed L0-L7 Dateien und schreibt CSV-Dateien pro Verzeichnis.
"""

import struct
import csv
import sys
import glob
import re
import zipfile
import os
from datetime import datetime, timedelta
from io import BytesIO


def decode_power_t(val_16bit):
    """
    Wie gehabt: 16 bit packed -> Int32 Wert gemäss power_t Format
    """
    if val_16bit == 0x5800:
        return 0x80000000
    mant = val_16bit & 0x3FF
    expo = (val_16bit >> 10) & 0x1F
    sign = (val_16bit >> 15) & 0x1
    if expo == 0:
        result = mant
    else:
        result = ((1 << 10) | mant) << (expo - 1)
    return -result if sign else result


def parse_l0_binary(data):
    """Parse L0 binary data from bytes"""
    magic = struct.unpack('<I', data[0:4])[0]
    version = data[4]
    level = data[5]
    hash_val = struct.unpack('<H', data[6:8])[0]
    time_val = struct.unpack('<I', data[8:12])[0]
    interval = struct.unpack('<I', data[16:20])[0]
    cnt = struct.unpack('<I', data[20:24])[0]
    base_date = datetime(2020, 1, 1, 0, 0, 0)
    end_time = base_date + timedelta(seconds=time_val)
    records = []
    for i in range(cnt):
        offset = 24 + i * 10
        energy_raw = struct.unpack('<i', data[offset:offset+4])[0]
        energy = energy_raw / 100.0
        power_min_raw = struct.unpack('<H', data[offset+4:offset+6])[0]
        power_max_raw = struct.unpack('<H', data[offset+6:offset+8])[0]
        power_avg_raw = struct.unpack('<H', data[offset+8:offset+10])[0]
        power_min = decode_power_t(power_min_raw)
        power_max = decode_power_t(power_max_raw)
        power_avg = decode_power_t(power_avg_raw)
        timestamp = end_time - timedelta(seconds=(cnt - i) * interval)
        records.append({
            'timestamp': timestamp,
            'energy': energy,
            'power_min': power_min,
            'power_max': power_max,
            'power_avg': power_avg,
            'source_file': None  # wird später gesetzt
        })
    return records


def extract_level(filename):
    """Extrahiert die Dateinummer aus 'L0' bis 'L7'"""
    match = re.search(r'L(\d)', filename)
    if match:
        return int(match.group(1))
    return 999


def has_na_value(record):
    """Prüft, ob ein Record einen N/A-Wert (0x80000000) enthält"""
    nan_val = 0x80000000
    return (record['power_min'] == nan_val or 
            record['power_max'] == nan_val or 
            record['power_avg'] == nan_val)


def process_chart_directory(zip_ref, chart_dir):
    """Processed ein Verzeichnis innerhalb des ZIP-Archivs"""
    all_records = []
    
    # Finde alle L0-L7 Dateien in diesem Verzeichnis
    for level in range(8):
        file_path = f"{chart_dir}/L{level}"
        try:
            data = zip_ref.read(file_path)
            print(f"  Lese {file_path} ({len(data)} Bytes)...")
            records = parse_l0_binary(data)
            for rec in records:
                rec['source_file'] = f"L{level}"
            all_records.extend(records)
        except KeyError:
            pass  # Datei existiert nicht in diesem Verzeichnis
    
    if not all_records:
        print(f"  Keine L0-L7 Dateien in {chart_dir} gefunden")
        return None
    
    print(f"  Insgesamt {len(all_records)} Einträge geladen.")
    
    # Sortiere nach Zeitstempel, dann nach Dateinummer
    all_records.sort(key=lambda x: (x['timestamp'], extract_level(x['source_file'])))
    
    # Entferne Duplikate bei gleichem Zeitstempel
    seen_timestamps = {}
    filtered_records = []
    for rec in all_records:
        ts = rec['timestamp']
        if ts not in seen_timestamps:
            seen_timestamps[ts] = True
            filtered_records.append(rec)
    
    print(f"  Nach Deduplizierung: {len(filtered_records)} Einträge.")
    
    # Entferne Zeilen mit N/A-Werten
    final_records = [rec for rec in filtered_records if not has_na_value(rec)]
    print(f"  Nach Filterung von N/A-Werten: {len(final_records)} Einträge.")
    
    return final_records


def main():
    archive_name = "meterdata.archive"
    
    if not os.path.exists(archive_name):
        print(f"Fehler: {archive_name} nicht gefunden!")
        sys.exit(1)
    
    print(f"Öffne {archive_name}...")
    
    with zipfile.ZipFile(archive_name, 'r') as zip_ref:
        # Finde alle Verzeichnisse unter 'charts/'
        all_paths = zip_ref.namelist()
        directories = set()
        
        for path in all_paths:
            if path.startswith('charts/') and '/' in path[7:]:
                # Extract directory name
                parts = path[7:].split('/')
                if parts[0]:
                    directories.add(f"charts/{parts[0]}")
        
        directories = sorted(directories)
        print(f"Gefundene Verzeichnisse: {directories}\n")
        
        for chart_dir in directories:
            print(f"Verarbeite {chart_dir}...")
            final_records = process_chart_directory(zip_ref, chart_dir)
            
            if final_records:
                # Schreibe CSV mit dem Namen des Verzeichnisses
                dir_name = chart_dir.split('/')[-1]
                out_name = f"{dir_name}.csv"
                
                with open(out_name, 'w', newline='') as f:
                    writer = csv.DictWriter(f, fieldnames=[
                        'timestamp', 'energy', 'power_min', 'power_max', 'power_avg', 'source_file'])
                    writer.writeheader()
                    for rec in final_records:
                        def fmt(v):
                            return "N/A" if v == 0x80000000 else str(v)
                        writer.writerow({
                            'timestamp': rec['timestamp'].strftime('%Y-%m-%d %H:%M:%S'),
                            'energy': f"{rec['energy']:.2f}",
                            'power_min': fmt(rec['power_min']),
                            'power_max': fmt(rec['power_max']),
                            'power_avg': fmt(rec['power_avg']),
                            'source_file': rec['source_file']
                        })
                
                print(f"  CSV geschrieben: {out_name}\n")
            else:
                print(f"  Übersprungen (keine Daten)\n")
    
    print("Verarbeitung abgeschlossen!")


if __name__ == '__main__':
    main()