cnb_exchange_rates/src/rate_finder.py

import sys
import os
from datetime import datetime, timedelta
import sqlite3

# Přidání adresáře src do sys.path, aby bylo možné importovat moduly
sys.path.insert(0, os.path.join(os.path.dirname(__file__)))

import database
import holidays
import data_fetcher

# Global debug flag
DEBUG = False

def debug_print(*args, **kwargs):
    """Print debug messages only if debug mode is enabled."""
    if DEBUG:
        print(*args, **kwargs)

def set_debug_mode(debug):
    """Set the debug mode for this module."""
    global DEBUG
    DEBUG = debug

def check_year_data_in_db(year):
    """
    Zkontroluje, zda databáze obsahuje data pro zadaný rok.
    
    :param year: Rok, který se má zkontrolovat.
    :return: True pokud databáze obsahuje data pro daný rok, jinak False.
    """
    conn = sqlite3.connect(database.DB_PATH)
    cursor = conn.cursor()
    
    # Zkontrolujeme, zda existuje alespoň jeden záznam pro daný rok
    cursor.execute('''
        SELECT COUNT(*) FROM exchange_rates
        WHERE strftime('%Y', date) = ?
    ''', (str(year),))
    
    count = cursor.fetchone()[0]
    conn.close()
    
    return count > 0

def get_rate_for_date(date_str, currency_code):
    """
    Vyhledá kurz pro zadané datum a měnu. Pokud kurz pro dané datum neexistuje,
    aplikuje pravidla pro víkendy a státní svátky. Zahrnuje kontrolu data a času.
    Pokud data pro daný rok neexistují, automaticky stáhne roční data.

    :param date_str: Datum ve formátu DD.MM.YYYY.
    :param currency_code: Kód měny (např. USD).
    :return: Kurz jako desetinné číslo, nebo None pokud není nalezen.
    """
    try:
        requested_date = datetime.strptime(date_str, "%d.%m.%Y")
    except ValueError:
        debug_print(f"Neplatný formát data: {date_str}")
        return None
    
    year = requested_date.year
    today = datetime.now()
    
    # Kontrola, zda je datum v budoucnosti
    if requested_date.date() > today.date():
        debug_print(f"Chyba: Kurzy pro datum {date_str} ještě nebyly vydány, protože toto datum je v budoucnosti.")
        return None
    
    # Kontrola, zda je dnešní datum a čas je před 14:30
    if requested_date.date() == today.date() and today.time() < datetime.strptime("14:30", "%H:%M").time():
        debug_print(f"Chyba: Kurzy pro dnešní datum ({date_str}) jsou vyhlašovány po 14:30. Aktuální čas je {today.strftime('%H:%M')}.")
        return None
    
    # Kontrola, zda databáze obsahuje data pro daný rok
    if not check_year_data_in_db(year):
        debug_print(f"Databáze neobsahuje data pro rok {year}. Stahuji roční data...")
        # Stáhneme roční data s vynuceným stažením
        os.makedirs("data", exist_ok=True)
        data_fetcher.download_yearly_data(year, output_dir="data", force=True)
    
    # 1. Zkusíme najít kurz pro přesné datum
    rate = database.get_rate(date_str, currency_code)
    if rate is not None:
        return rate
    
    debug_print(f"Kurz pro {currency_code} na datum {date_str} nebyl nalezen. Hledám nejbližší pracovní den...")
    
    # 2. Pokud kurz neexistuje, aplikujeme pravidla
    # Zkontrolujeme, zda je datum víkend nebo svátek
    if holidays.is_weekend(date_str) or holidays.is_holiday(date_str):
        debug_print(f"Datum {date_str} je víkend nebo státní svátek. Hledám předchozí pracovní den...")
        # Pro víkendy a svátky použijeme kurz z předchozího pracovního dne
        previous_workday = holidays.get_previous_working_day(date_str)
        if previous_workday:
            debug_print(f"Používám kurz z předchozího pracovního dne: {previous_workday}")
            return database.get_rate(previous_workday, currency_code)
        else:
            debug_print("Nepodařilo se najít předchozí pracovní den.")
            return None
    else:
        # Pro běžné dny hledáme zpět po pracovních dnech
        debug_print(f"Datum {date_str} je běžný den. Hledám kurz zpětně po pracovních dnech...")
        # Odečítáme dny, dokud nenajdeme pracovní den s kurzem
        # Omezení na 10 dní zpět
        current_date = requested_date
        for _ in range(10):
            current_date -= timedelta(days=1)
            check_date_str = current_date.strftime("%d.%m.%Y")
            
            # Zkontrolujeme, zda je to pracovní den
            if not holidays.is_weekend(check_date_str) and not holidays.is_holiday(check_date_str):
                rate = database.get_rate(check_date_str, currency_code)
                if rate is not None:
                    debug_print(f"Nalezen kurz z pracovního dne {check_date_str}")
                    return rate
        
        debug_print("Nepodařilo se najít kurz v posledních 10 pracovních dnech.")
        return None

# Příklad použití
if __name__ == "__main__":
    # Inicializace databáze (pro případ spuštění samostatně)
    database.init_db()
    
    # Test
    test_date = "01.01.2025"  # Svátek
    test_currency = "USD"
    rate = get_rate_for_date(test_date, test_currency)
    if rate:
        print(f"Kurz {test_currency} na datum {test_date} (nebo nejbližší pracovní den): {rate}")
    else:
        print(f"Kurz {test_currency} na datum {test_date} (ani v předchozích dnech) nebyl nalezen.")