#!/usr/bin/env python3
"""
Import dat z analyzátoru plynu do databáze.
Tabulka: p_denik_plyn_{rok} (jedna za rok)
Datum a čas z CSV ve formátu dd.mm.rrrr hh:mm:ss se převádí na SQL formát.
"""

import os
import sys
import glob
import csv
import datetime
import pymysql

# ---------- Konfigurace ----------
DB_HOST = os.getenv('DB_HOST', 'localhost')
DB_USER = os.getenv('DB_USER', 'pavlat')
DB_PASSWORD = os.getenv('DB_PASSWORD', '//frpavl123')
LOG_DIR = '/mnt/logs/'

# Mapování názvů proměnných z CSV na sloupce v tabulce
MAPPING = {
    'Ostatni\Actuators\F_O2_Analyzator_Plynu': 'fkyslik',
    'Ostatni\Actuators\F_CH4_Analyzator_Plynu': 'fmetan',
    'Ostatni\Actuators\F_H2S_Analyzator_Plynu': 'fsira',
    'Ostatni\Actuators\PF_O2_Analyzator_Plynu': 'pfkyslik',
    'Ostatni\Actuators\PF_CH4_Analyzator_Plynu': 'pfmetan',
    'Ostatni\Actuators\PF_H2S_Analyzator_Plynu': 'pfsira',
    'Ostatni\Actuators\KGJ_O2_Analyzator_Plynu': 'mkyslik',
    'Ostatni\Actuators\KGJ_CH4_Analyzator_Plynu': 'mmetan',
    'Ostatni\Actuators\KGJ_H2S_Analyzator_Plynu': 'msira',
}
# ---------------------------------


def parse_time_to_sql(time_str):
    """
    Převede 'dd.mm.rrrr hh:mm:ss' na SQL formát.
    Podporuje i 'dd.mm.rrrr hh:mm' (bez vteřin).
    Vrací: (sql_datum, sql_cas) ve formátu 'YYYY-MM-DD' a 'HH:MM:SS'
    """
    try:
        time_str = time_str.strip()
        date_part, time_part = time_str.split(' ')
        day, month, year = date_part.split('.')
        
        # Zjistíme, zda máme vteřiny
        time_parts = time_part.split(':')
        if len(time_parts) == 3:
            hour, minute, second = time_parts
        else:
            hour, minute = time_parts
            second = '00'
        
        # Vytvoření datetime objektu
        dt = datetime.datetime(
            int(year), int(month), int(day),
            int(hour), int(minute), int(second)
        )
        
        # SQL formát
        sql_datum = dt.strftime('%Y-%m-%d')      # 2026-06-14
        sql_cas = dt.strftime('%H:%M:%S')       # 19:22:00
        
        return sql_datum, sql_cas
    except Exception as e:
        sys.stderr.write(f"Chyba parsování času '{time_str}': {e}\n")
        return None, None


def parse_value(val_str):
    """Převede řetězec s desetinnou čárkou na float."""
    val_str = val_str.strip()
    if val_str == '':
        return None
    val_str = val_str.replace(',', '.')
    try:
        return float(val_str)
    except ValueError:
        return None


def process_csv(filepath):
    """
    Zpracuje CSV a vrátí slovník:
        { 'dd.mm.rrrr hh:mm:ss': { 'sloupec': hodnota, ... }, ... }
    """
    data = {}
    with open(filepath, 'r', encoding='utf-8') as f:
        reader = csv.reader(f, delimiter=';')
        for row in reader:
            if len(row) < 5:
                continue
            varname, timestr, varvalue, validity, _ = row[:5]

            # Pouze validní záznamy (Validity = 1)
            if validity.strip() != '1':
                continue

            if varname not in MAPPING:
                continue

            col = MAPPING[varname]
            val = parse_value(varvalue)
            if val is None:
                continue

            if timestr not in data:
                data[timestr] = {}
            data[timestr][col] = val

    return data


def get_db_connection(year):
    """Vrátí připojení k databázi mar_{rok}."""
    db_name = f"mar_{year}"
    try:
        conn = pymysql.connect(
            host=DB_HOST,
            user=DB_USER,
            password=DB_PASSWORD,
            database=db_name,
            charset='latin1'
        )
        return conn
    except pymysql.err.OperationalError as e:
        sys.stderr.write(f"Chyba připojení k DB {db_name}: {e}\n")
        sys.exit(1)


def ensure_table(conn, year):
    """Vytvoří tabulku p_denik_plyn_{rok}, pokud neexistuje."""
    table_name = f"p_denik_plyn_{year}"
    with conn.cursor() as cur:
        cur.execute("SHOW TABLES LIKE %s", (table_name,))
        if not cur.fetchone():
            create_sql = f"""
            CREATE TABLE `{table_name}` (
              `id` int(10) NOT NULL AUTO_INCREMENT,
              `datum` date NOT NULL,
              `cas` time NOT NULL,
              `pfmetan` decimal(10,2) DEFAULT NULL,
              `pfkyslik` decimal(10,2) DEFAULT NULL,
              `pfsira` decimal(10,2) DEFAULT NULL,
              `fmetan` decimal(10,2) DEFAULT NULL,
              `fkyslik` decimal(10,2) DEFAULT NULL,
              `fsira` decimal(10,2) DEFAULT NULL,
              `mmetan` decimal(10,2) DEFAULT NULL,
              `mkyslik` decimal(10,2) DEFAULT NULL,
              `msira` decimal(10,2) DEFAULT NULL,
              PRIMARY KEY (`id`),
              UNIQUE KEY `datum_cas` (`datum`,`cas`)
            ) ENGINE=MyISAM DEFAULT CHARSET=latin1
            """
            cur.execute(create_sql)
            conn.commit()
            sys.stderr.write(f"Vytvořena tabulka {table_name}\n")
        else:
            # Přidáme UNIQUE index, pokud chybí
            try:
                cur.execute(f"ALTER TABLE {table_name} ADD UNIQUE INDEX (datum, cas)")
                conn.commit()
            except pymysql.err.OperationalError as e:
                if e.args[0] != 1061:
                    raise


def insert_or_update(conn, year, timestr, values):
    """Vloží nebo aktualizuje záznam pro daný čas."""
    # Převedeme čas na SQL formát
    sql_datum, sql_cas = parse_time_to_sql(timestr)
    if sql_datum is None:
        return
    
    table_name = f"p_denik_plyn_{year}"

    cols = ['datum', 'cas'] + list(values.keys())
    placeholders = ','.join(['%s'] * len(cols))
    update_parts = ','.join([f"{col}=VALUES({col})" for col in values.keys()])

    sql = f"""
        INSERT INTO {table_name} ({','.join(cols)})
        VALUES ({placeholders})
        ON DUPLICATE KEY UPDATE {update_parts}
    """

    # Vložíme SQL datum a čas jako stringy
    vals = [sql_datum, sql_cas]
    for col in cols[2:]:
        vals.append(values.get(col))

    with conn.cursor() as cur:
        cur.execute(sql, vals)
    conn.commit()


def main():
    year = datetime.datetime.now().year

    pattern = os.path.join(LOG_DIR, "Trends_Analizator_Plynu*.csv")
    files = glob.glob(pattern)
    if not files:
        sys.stderr.write("Žádné soubory nenalezeny.\n")
        sys.exit(1)

    all_data = {}
    for f in files:
        sys.stderr.write(f"Zpracovávám {f}\n")
        data = process_csv(f)
        for timestr, cols in data.items():
            if timestr not in all_data:
                all_data[timestr] = {}
            for col, val in cols.items():
                all_data[timestr][col] = val

    if not all_data:
        sys.stderr.write("Žádná platná data.\n")
        sys.exit(0)

    conn = get_db_connection(year)
    ensure_table(conn, year)

    for timestr, cols in all_data.items():
        insert_or_update(conn, year, timestr, cols)

    conn.close()
    sys.stderr.write("Import dokončen.\n")


if __name__ == "__main__":
    main()