import os
import sys
import signal
import logging

# Profesyonel loglama yapılandırması
logging.basicConfig(
    format='%(asctime)s - 🛡️ [KernelLock] %(message)s',
    level=logging.INFO,
    datefmt='%H:%M:%S'
)
logger = logging.getLogger("kernellock")

class LockManager:
    _is_locked = False

    @classmethod
    def lock(cls):
        """Kernel'ı mühürler ve tüm kapatma vektörlerini kapatır."""
        if cls._is_locked:
            return

        cls._patch_ipython()
        cls._patch_os_kill()
        cls._patch_sys_exit()
        cls._mask_signals()
        
        cls._is_locked = True
        logger.info("Kernel Lock AKTİF. Restart ve Kill istekleri engellendi (GPU-Safe).")

    @classmethod
    def _patch_ipython(cls):
        """Jupyter/Colab/Kaggle arayüzünden gelen restart isteklerini kör eder."""
        try:
            import IPython
            ip = IPython.get_ipython()
            if ip and hasattr(ip, 'kernel'):
                orig_shutdown = ip.kernel.do_shutdown
                def guarded_shutdown(restart):
                    if restart:
                        logger.warning("Arayüzden gelen Kernel Restart isteği reddedildi!")
                        return {'status': 'ok', 'restart': False}
                    return orig_shutdown(restart)
                ip.kernel.do_shutdown = guarded_shutdown
        except Exception as e:
            logger.debug(f"IPython patch atlandı: {e}")

    @classmethod
    def _patch_os_kill(cls):
        """İşletim sistemi seviyesindeki kendi kendini öldürme çağrılarını engeller."""
        orig_kill = os.kill
        def safe_kill(pid, sig):
            if pid == os.getpid() and sig != signal.SIGKILL:
                logger.warning(f"os.kill çağrısı yakalandı ve engellendi (Sinyal: {sig}).")
                return
            orig_kill(pid, sig)
        os.kill = safe_kill

    @classmethod
    def _patch_sys_exit(cls):
        """Kod içindeki kazara sys.exit() çağrılarının kernel'ı çökertmesini önler."""
        orig_exit = sys.exit
        def safe_exit(arg=None):
            logger.warning(f"sys.exit({arg}) çağrısı engellendi. İşlem devam ediyor.")
            return
        sys.exit = safe_exit

    @classmethod
    def _mask_signals(cls):
        """OS tarafından gönderilen yumuşak kapatma sinyallerini maskeler."""
        signals = [signal.SIGTERM, signal.SIGINT]
        if hasattr(signal, "SIGHUP"):
            signals.append(signal.SIGHUP)
        
        for sig in signals:
            try:
                signal.signal(sig, signal.SIG_IGN)
            except Exception:
                pass

# Kullanıcı paketi import ettiği gibi aktif etmek istersen:
def activate():
    LockManager.lock()

# Varsayılan olarak import anında çalışır
activate()