main.py

#!/usr/bin/env python3
"""
KSeF Monitor - Main Entry Point
Monitors KSeF API for new invoices and sends multi-channel notifications

Based on KSeF API v2.2.0/v2.3.0 specification:
https://github.com/CIRFMF/ksef-docs
"""

import os
import sys
import signal
import logging

from app import __version__
from app.config_manager import ConfigManager
from app.ksef_client import KSeFClient
from app.notifiers import NotificationManager
from app.invoice_monitor import InvoiceMonitor
from app.prometheus_metrics import PrometheusMetrics
from app.logging_config import setup_logging, apply_config
from app.database import Database

# Configure logging (system timezone until config is loaded)
setup_logging()

logger = logging.getLogger(__name__)

# Global monitor instance for signal handling
monitor = None


def signal_handler(signum, frame):
    """
    Handle shutdown signals gracefully

    Args:
        signum: Signal number
        frame: Current stack frame
    """
    logger.info(f"Received signal {signum}, shutting down gracefully...")
    if monitor:
        monitor.shutdown()
    sys.exit(0)


def trigger_handler(signum, frame):
    """Handle SIGUSR1 — trigger immediate invoice check."""
    if monitor:
        monitor.trigger_check()


def main():
    """Main entry point"""
    global monitor
    
    logger.info("=" * 70)
    logger.info(f"KSeF Monitor v{__version__}")
    logger.info("Based on KSeF API v2.4.0 (github.com/CIRFMF/ksef-docs)")
    logger.info("Multi-channel notifications with Jinja2 templates")
    logger.info("=" * 70)
    
    try:
        # Load configuration
        logger.info("Loading configuration...")
        # Search order: /config (dedicated mount), /data (legacy), local
        config_path = next(
            (p for p in ("/config/config.json", "/data/config.json", "config.json") if os.path.exists(p)),
            "config.json"
        )
        config = ConfigManager(config_path)
        logger.info("✓ Configuration loaded")

        # Reconfigure logging (level + timezone) from config
        apply_config(config)
        
        # Initialize KSeF client
        logger.info("Initializing KSeF client...")
        ksef_client = KSeFClient(config)
        logger.info("✓ KSeF client initialized")

        # Initialize database
        database = None
        db_enabled = config.get("database", "enabled", default=True)
        if db_enabled:
            try:
                db_path = config.get("database", "path", default="/data/invoices.db")
                logger.info(f"Initializing database: {db_path}")
                database = Database(db_path)
                database.create_tables()
                logger.info("✓ Database initialized")
            except Exception as e:
                logger.warning(f"Failed to initialize database: {e}")
                logger.info("Continuing without database persistence")
                database = None

            # Migrate last_check.json → DB (one-time, if needed)
            if database:
                try:
                    from pathlib import Path
                    state_file = Path("/data/last_check.json")
                    nip = config.get("ksef", "nip") or ""
                    subject_types = config.get("monitoring", "subject_types") or ["Subject1"]
                    database.migrate_from_json(state_file, nip, subject_types)
                except Exception as e:
                    logger.warning(f"JSON migration failed (non-fatal): {e}")
        else:
            logger.info("Database disabled in configuration")

        # Initialize Push Manager (iOS push notifications)
        push_manager = None
        ios_push_config = (config.get("notifications") or {}).get("ios_push")
        if ios_push_config and ios_push_config.get("enabled"):
            try:
                from app.push_manager import PushManager
                push_manager = PushManager(
                    ios_push_config,
                    data_dir="/data",
                    db=database,
                )
                # Inject auto-generated credentials into config for IosPushNotifier
                ios_push_config["instance_id"] = push_manager.instance_id
                ios_push_config["instance_key"] = push_manager.instance_key
                logger.info("✓ Push Manager initialized")
            except Exception as e:
                logger.warning(f"Failed to initialize Push Manager: {e}")
                logger.info("Continuing without iOS push notifications")

        # Initialize Initial Load Manager (historical invoice import)
        initial_load_manager = None
        initial_load_config = config.get("initial_load") or {}
        if database and initial_load_config.get("enabled"):
            try:
                from datetime import datetime as _dt
                from app.initial_load_manager import InitialLoadManager
                initial_load_manager = InitialLoadManager(config, ksef_client, database)
                logger.info("✓ Initial Load Manager initialized")

                # Auto-start job if configured and no active job exists
                start_date_str = initial_load_config.get("start_date", "")
                if start_date_str:
                    start_date = _dt.fromisoformat(start_date_str)
                    end_date = _dt.utcnow()
                    subject_types = initial_load_config.get("subject_types", ["Subject1", "Subject2"])
                    date_type = initial_load_config.get("date_type", "Invoicing")
                    initial_load_manager.resume_interrupted_jobs()
                    job_id = initial_load_manager.start_job(
                        start_date=start_date,
                        end_date=end_date,
                        subject_types=subject_types,
                        date_type=date_type,
                    )
                    if job_id:
                        logger.info("✓ Initial load job started: %s", job_id)
                    else:
                        logger.info("Initial load: job already running, not starting new one")
            except Exception as e:
                logger.warning(f"Failed to initialize Initial Load Manager: {e}")
                logger.info("Continuing without initial load")

        # Initialize notification manager
        logger.info("Initializing notification channels...")
        notification_manager = NotificationManager(config, database=database)
        logger.info("✓ Notification system initialized")

        # Display enabled channels
        if notification_manager.enabled_channels:
            logger.info(f"  Enabled channels: {', '.join(notification_manager.enabled_channels)}")
        else:
            logger.warning("  No notification channels enabled - notifications disabled")

        # Test notification connections (optional)
        notifications_config = config.get("notifications") or {}
        test_notification = notifications_config.get("test_notification")
        if test_notification is None:
            test_notification = config.get("monitoring", "test_notification", default=False)

        if test_notification is True:
            logger.info("Testing notification channels...")
            if notification_manager.test_connection():
                logger.info("✓ Notification test completed successfully")
            else:
                logger.warning("⚠ Notification test failed for all channels")

        # Initialize Prometheus metrics
        logger.info("Initializing Prometheus metrics...")
        prometheus_port = config.get("prometheus", "port", default=8000)
        prometheus_enabled = config.get("prometheus", "enabled", default=True)
        prometheus_bind = config.get("prometheus", "bind_address", default="127.0.0.1")

        prometheus_metrics = None
        if prometheus_enabled:
            if prometheus_bind == "0.0.0.0" and config.get("ksef", "environment") == "prod":
                logger.warning(
                    "⚠ Prometheus metrics bound to 0.0.0.0 in production — "
                    "consider setting prometheus.bind_address to '127.0.0.1'"
                )
            try:
                prometheus_metrics = PrometheusMetrics(port=prometheus_port, bind_address=prometheus_bind)
                prometheus_metrics.start_server()
            except Exception as e:
                logger.warning(f"Failed to initialize Prometheus metrics: {e}")
                logger.info("Continuing without Prometheus monitoring")
        else:
            logger.info("Prometheus metrics disabled in configuration")

        # Wire Prometheus metrics into KSeF client
        if prometheus_metrics:
            ksef_client.on_auth_failure = lambda sc: prometheus_metrics.increment_auth_failures(sc)
            ksef_client.prometheus_metrics = prometheus_metrics

        # Initialize and run monitor
        logger.info("Initializing invoice monitor...")
        monitor = InvoiceMonitor(config, ksef_client, notification_manager, prometheus_metrics, database=database)
        logger.info("✓ Invoice monitor initialized")
        
        # Start REST API server (R-03: wire API into main)
        api_config = config.get("api") or {}
        if api_config.get("enabled"):
            try:
                from app.api import create_app
                from app.api.server import APIServer

                # V5-13 upgrade-friendly bootstrap: if api.auth_token is set in
                # config and there are 0 UI users yet, auto-create the 'admin'
                # user with password = auth_token. Lets v0.5.0 deployments
                # upgrade without touching the API key — login as 'admin' with
                # the existing token, then change password via /ui/account.
                #
                # Skipped when token was auto-generated this run (fresh install):
                # /ui/login redirects to /ui/setup wizard so the user picks their
                # own credentials instead of fishing the auto-gen token out of
                # /data/api_token.txt.
                bootstrap_token = (api_config.get("auth_token") or "").strip()
                token_auto_generated = bool(
                    api_config.get("_auth_token_auto_generated")
                )
                if (
                    database is not None
                    and bootstrap_token
                    and len(bootstrap_token) >= 8
                    and not token_auto_generated
                ):
                    try:
                        from app.ui_auth import (
                            count_users as _count_users,
                            create_user as _create_user,
                        )

                        with database.get_session() as _s:
                            if _count_users(_s) == 0:
                                _create_user(_s, "admin", bootstrap_token)
                                logger.warning(
                                    "Bootstrap: created UI user 'admin' with "
                                    "password = api.auth_token. Login at /ui/login "
                                    "and change password via /ui/account."
                                )
                    except Exception as _e:
                        logger.warning(f"UI bootstrap admin skipped: {_e}")
                elif token_auto_generated and database is not None:
                    try:
                        from app.ui_auth import count_users as _count_users

                        with database.get_session() as _s:
                            if _count_users(_s) == 0:
                                logger.warning(
                                    "Fresh install detected (auto-generated auth_token, "
                                    "no UI users) — open /ui/setup to create the first "
                                    "admin account."
                                )
                    except Exception:
                        pass

                api_app = create_app(
                    db=database,
                    monitor_instance=monitor,
                    auth_token=api_config.get("auth_token", ""),
                    cors_origins=api_config.get("cors_origins"),
                    rate_limit_config=api_config.get("rate_limit"),
                    docs_enabled=api_config.get("docs_enabled", True),
                    prometheus_metrics=prometheus_metrics,
                    push_manager=push_manager,
                    initial_load_manager=initial_load_manager,
                    ui_enabled=api_config.get("ui_enabled", True),
                    ui_public=api_config.get("ui_public", False),
                    cookie_secure_mode=api_config.get("cookie_secure_mode", "auto"),
                    session_strict_binding=api_config.get("session_strict_binding", False),
                )
                api_server = APIServer(
                    api_app,
                    host=api_config.get("bind_address", "127.0.0.1"),
                    port=api_config.get("port", 8080),
                )
                api_server.start()
                logger.info("✓ REST API server started")
            except Exception as e:
                logger.warning(f"Failed to start REST API: {e}")
                logger.info("Continuing without REST API")

        # Register signal handlers
        signal.signal(signal.SIGINT, signal_handler)
        signal.signal(signal.SIGTERM, signal_handler)
        signal.signal(signal.SIGUSR1, trigger_handler)
        
        # Start monitoring
        monitor.run()
        
    except KeyboardInterrupt:
        logger.info("Received keyboard interrupt...")
        if monitor:
            monitor.shutdown()
        sys.exit(0)
        
    except Exception as e:
        logger.error(f"Fatal error: {e}", exc_info=True)
        if monitor:
            monitor.shutdown()
        sys.exit(1)


if __name__ == "__main__":
    main()