time.py

import subprocess
import threading
import logging
import tkinter as tk
from tkinter import ttk, scrolledtext, messagebox
from datetime import datetime, timedelta, timezone
import time
import platform
import os
import re
import webbrowser


class TextHandler(logging.Handler):
    """Klasa przechwytująca logi i przekierowująca je do widgetu Text."""

    def __init__(self, text_widget):
        logging.Handler.__init__(self)
        self.text_widget = text_widget

    def emit(self, record):
        msg = self.format(record)

        def append():
            self.text_widget.configure(state='normal')
            self.text_widget.insert(tk.END, msg + '\n')
            self.text_widget.see(tk.END)  # Przewijanie do końca
            self.text_widget.configure(state='disabled')

        # Uruchamianie w głównym wątku Tkinter
        self.text_widget.after(0, append)


class TimeSyncApp:
    def __init__(self, root):
        self.root = root
        self.root.title("ZegarSync - Aplikacja zegara systemowego")
        self.root.geometry("700x650")
        self.root.resizable(True, True)

        # Ustawienie minimalnego rozmiaru okna
        self.root.minsize(600, 550)

        # Zmienne
        self.ntp_server = tk.StringVar(value="tempus1.gum.gov.pl")
        self.is_syncing = False
        self.sync_thread = None

        # Tryb testowy
        self.test_mode = tk.BooleanVar(value=True)

        # Zmienna dla wirtualnego czasu
        self.virtual_time_offset = 0  # Offset w sekundach

        # Utworzenie i skonfigurowanie widżetów
        self.create_widgets()
        self.setup_logging()

        # Sprawdzenie uprawnień administratora przy starcie
        self.is_admin_mode = self.is_admin()
        if not self.is_admin_mode:
            logging.warning("Aplikacja nie została uruchomiona z uprawnieniami administratora.")
            logging.info("Synchronizacja czasu systemowego będzie niedostępna.")
            logging.info("Dostępna jest praca z czasem wirtualnym (bez modyfikacji czasu systemowego).")

    def create_widgets(self):
        """Tworzenie elementów interfejsu."""
        # Główny kontener
        main_frame = ttk.Frame(self.root, padding="10")
        main_frame.pack(fill=tk.BOTH, expand=True)

        # Zakładki
        notebook = ttk.Notebook(main_frame)
        notebook.pack(fill=tk.BOTH, expand=True)

        # Zakładka 1: Podstawowe zegary
        basic_frame = ttk.Frame(notebook, padding="10")
        notebook.add(basic_frame, text="Zegary")

        # Zakładka 2: Zaawansowana synchronizacja
        sync_frame = ttk.Frame(notebook, padding="10")
        notebook.add(sync_frame, text="Synchronizacja")

        # === ZAKŁADKA 1: ZEGARY ===
        # Rama z zegarami
        clocks_frame = ttk.LabelFrame(basic_frame, text="Zegary", padding="10")
        clocks_frame.pack(fill=tk.X, padx=5, pady=5)

        # Styl dla zegarów - czarny tekst
        style = ttk.Style()
        style.configure('Clock.TLabel', font=('Arial', 24, 'bold'), background='white', foreground='black')
        style.configure('VirtualClock.TLabel', font=('Arial', 24, 'bold'), background='lightblue', foreground='black')

        # Kontener dla 3 zegarów w rzędzie
        clock_container = ttk.Frame(clocks_frame)
        clock_container.pack(fill=tk.X)

        # 1. Zegar lokalny (systemowy)
        local_clock_frame = ttk.LabelFrame(clock_container, text="Czas systemowy", padding="5")
        local_clock_frame.pack(side=tk.LEFT, fill=tk.BOTH, expand=True, padx=5)

        self.local_date_label = ttk.Label(local_clock_frame, font=('Arial', 12))
        self.local_date_label.pack(fill=tk.X)

        self.local_time_label = ttk.Label(local_clock_frame, style='Clock.TLabel')
        self.local_time_label.pack(fill=tk.X, pady=5)

        # 2. Zegar UTC
        utc_clock_frame = ttk.LabelFrame(clock_container, text="Czas UTC", padding="5")
        utc_clock_frame.pack(side=tk.LEFT, fill=tk.BOTH, expand=True, padx=5)

        self.utc_date_label = ttk.Label(utc_clock_frame, font=('Arial', 12))
        self.utc_date_label.pack(fill=tk.X)

        self.utc_time_label = ttk.Label(utc_clock_frame, style='Clock.TLabel')
        self.utc_time_label.pack(fill=tk.X, pady=5)

        # 3. Zegar wirtualny
        virtual_clock_frame = ttk.LabelFrame(clock_container, text="Czas wirtualny", padding="5")
        virtual_clock_frame.pack(side=tk.LEFT, fill=tk.BOTH, expand=True, padx=5)

        self.virtual_date_label = ttk.Label(virtual_clock_frame, font=('Arial', 12))
        self.virtual_date_label.pack(fill=tk.X)

        self.virtual_time_label = ttk.Label(virtual_clock_frame, style='VirtualClock.TLabel')
        self.virtual_time_label.pack(fill=tk.X, pady=5)

        # Rama z kontrolą czasu wirtualnego
        virtual_control_frame = ttk.LabelFrame(basic_frame, text="Zarządzanie czasem wirtualnym", padding="10")
        virtual_control_frame.pack(fill=tk.X, padx=5, pady=5)

        # Przyciski do regulacji czasu wirtualnego
        adjust_frame = ttk.Frame(virtual_control_frame)
        adjust_frame.pack(fill=tk.X, pady=5)

        # Przyciski po lewej
        left_buttons = ttk.Frame(adjust_frame)
        left_buttons.pack(side=tk.LEFT, padx=5)

        ttk.Button(left_buttons, text="-1 godzina", command=lambda: self.adjust_virtual_time(-3600)).pack(side=tk.LEFT,
                                                                                                          padx=2)
        ttk.Button(left_buttons, text="-10 minut", command=lambda: self.adjust_virtual_time(-600)).pack(side=tk.LEFT,
                                                                                                        padx=2)
        ttk.Button(left_buttons, text="-1 minuta", command=lambda: self.adjust_virtual_time(-60)).pack(side=tk.LEFT,
                                                                                                       padx=2)

        # Przyciski po prawej
        right_buttons = ttk.Frame(adjust_frame)
        right_buttons.pack(side=tk.RIGHT, padx=5)

        ttk.Button(right_buttons, text="+1 minuta", command=lambda: self.adjust_virtual_time(60)).pack(side=tk.LEFT,
                                                                                                       padx=2)
        ttk.Button(right_buttons, text="+10 minut", command=lambda: self.adjust_virtual_time(600)).pack(side=tk.LEFT,
                                                                                                        padx=2)
        ttk.Button(right_buttons, text="+1 godzina", command=lambda: self.adjust_virtual_time(3600)).pack(side=tk.LEFT,
                                                                                                          padx=2)

        # Przyciski zarządzania
        manage_frame = ttk.Frame(virtual_control_frame)
        manage_frame.pack(fill=tk.X, pady=5)

        ttk.Button(manage_frame, text="Resetuj zegar wirtualny",
                   command=self.reset_virtual_time).pack(side=tk.LEFT, expand=True)

        ttk.Button(manage_frame, text="Zapisz ustawienie",
                   command=self.save_time_settings).pack(side=tk.LEFT, expand=True)

        ttk.Button(manage_frame, text="Wczytaj ustawienie",
                   command=self.load_time_settings).pack(side=tk.LEFT, expand=True)

        # === ZAKŁADKA 2: SYNCHRONIZACJA ===
        sync_label = ttk.Label(sync_frame, text="Synchronizacja czasu systemowego z serwerem NTP",
                               font=("Arial", 12, "bold"))
        sync_label.pack(pady=10)

        # Informacja o uprawnieniach
        admin_frame = ttk.Frame(sync_frame)
        admin_frame.pack(fill=tk.X, pady=5)

        self.admin_icon = ttk.Label(admin_frame, text="⚠️", font=("Arial", 16))
        self.admin_icon.pack(side=tk.LEFT, padx=5)

        admin_text = "Ta funkcja wymaga uruchomienia aplikacji z uprawnieniami administratora."
        self.admin_label = ttk.Label(admin_frame, text=admin_text, font=("Arial", 10))
        self.admin_label.pack(side=tk.LEFT, padx=5)

        ttk.Separator(sync_frame, orient='horizontal').pack(fill=tk.X, pady=10)

        # Ustawienia serwera NTP
        ntp_frame = ttk.LabelFrame(sync_frame, text="Serwer NTP", padding="10")
        ntp_frame.pack(fill=tk.X, padx=5, pady=5)

        ttk.Label(ntp_frame, text="Adres serwera NTP:").grid(row=0, column=0, sticky=tk.W, padx=5, pady=5)
        self.server_entry = ttk.Entry(ntp_frame, width=40, textvariable=self.ntp_server)
        self.server_entry.grid(row=0, column=1, sticky=tk.W + tk.E, padx=5, pady=5)

        # Lista popularnych serwerów
        ttk.Label(ntp_frame, text="Popularne serwery:").grid(row=1, column=0, sticky=tk.W, padx=5, pady=5)

        server_frame = ttk.Frame(ntp_frame)
        server_frame.grid(row=1, column=1, sticky=tk.W, padx=5, pady=5)

        for server in ["tempus1.gum.gov.pl", "time.windows.com", "pool.ntp.org"]:
            btn = ttk.Button(server_frame, text=server,
                             command=lambda s=server: self.ntp_server.set(s))
            btn.pack(side=tk.LEFT, padx=5)

        # Opcje synchronizacji
        options_frame = ttk.LabelFrame(sync_frame, text="Opcje synchronizacji", padding="10")
        options_frame.pack(fill=tk.X, padx=5, pady=5)

        # Checkbox dla trybu testowego
        self.test_mode_cb = ttk.Checkbutton(options_frame, text="Tryb testowy (bez synchronizacji)",
                                            variable=self.test_mode)
        self.test_mode_cb.pack(anchor=tk.W, pady=5)

        # Przycisk synchronizacji
        sync_button_frame = ttk.Frame(options_frame)
        sync_button_frame.pack(fill=tk.X, pady=10)

        self.sync_button = ttk.Button(sync_button_frame, text="Synchronizuj czas z serwerem NTP",
                                      command=self.start_sync, width=30)
        self.sync_button.pack(pady=5)

        # Pasek postępu
        self.progress = ttk.Progressbar(options_frame, mode='indeterminate')
        self.progress.pack(fill=tk.X, pady=5)

        # Informacje o usłudze Windows Time (tylko Windows)
        service_frame = ttk.LabelFrame(sync_frame, text="Usługa Windows Time (tylko Windows)", padding="10")
        service_frame.pack(fill=tk.X, padx=5, pady=5)

        service_buttons = ttk.Frame(service_frame)
        service_buttons.pack(fill=tk.X)

        ttk.Button(service_buttons, text="Sprawdź status usługi",
                   command=self.check_time_service).pack(side=tk.LEFT, expand=True, padx=5, pady=5)

        ttk.Button(service_buttons, text="Uruchom usługę",
                   command=lambda: self.manage_time_service("start")).pack(side=tk.LEFT, expand=True, padx=5, pady=5)

        ttk.Button(service_buttons, text="Zatrzymaj usługę",
                   command=lambda: self.manage_time_service("stop")).pack(side=tk.LEFT, expand=True, padx=5, pady=5)

        # WSPÓLNE ELEMENTY DLA OBU ZAKŁADEK
        # Okno logów
        log_frame = ttk.LabelFrame(main_frame, text="Logi", padding="10")
        log_frame.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)

        self.log_area = scrolledtext.ScrolledText(log_frame, state='disabled', height=8)
        self.log_area.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)

        # Status systemu operacyjnego i GitHub link (nowa ramka)
        status_frame = ttk.Frame(main_frame)
        status_frame.pack(fill=tk.X, padx=5, pady=5)

        # Informacja o systemie (lewa strona)
        self.system_label = ttk.Label(status_frame, text=f"System: {platform.system()} {platform.release()}")
        self.system_label.pack(side=tk.LEFT)

        # Link do repozytorium GitHub (prawa strona)
        self.github_link = ttk.Label(status_frame, text="GitHub",
                                     foreground="blue", cursor="hand2")
        self.github_link.pack(side=tk.RIGHT, padx=10)
        self.github_link.bind("<Button-1>", self.open_github)

        # Etykieta autora, która wyświetli popup po kliknięciu
        self.author_label = ttk.Label(status_frame, text="Autor", foreground="blue", cursor="hand2")
        self.author_label.pack(side=tk.RIGHT)
        self.author_label.bind("<Button-1>", self.show_author)

        # Uruchomienie aktualizacji zegarów
        self.update_clocks()

        # Aktualizacja stanu przycisków w zależności od uprawnień
        self.update_admin_status()

    def update_admin_status(self):
        """Aktualizuje interfejs na podstawie uprawnień administratora."""
        if self.is_admin():
            self.admin_icon.config(text="✅")
            self.admin_label.config(text="Aplikacja uruchomiona z uprawnieniami administratora.")
        else:
            self.admin_icon.config(text="⚠️")
            self.admin_label.config(
                text="Brak uprawnień administratora — dostępny tryb testowy i czas wirtualny.")
        # Przycisk jest zawsze aktywny; uprawnienia weryfikowane przy starcie synchronizacji
        self.sync_button.config(state=tk.NORMAL)

    def open_github(self, event):
        """Otwiera repozytorium GitHub w przeglądarce."""
        webbrowser.open_new("https://github.com/dkoryto/time_sync")

    def show_author(self, event):
        """Wyświetla popup z informacją o autorze."""
        messagebox.showinfo("Autor",
                            "Dariusz Koryto\nE-mail: dariusz@koryto.eu\n\nAplikacja do synchronizacji czasu\nLicencja: MIT")

    def update_clocks(self):
        """Aktualizacja wyświetlania zegarów co sekundę."""
        # Pobranie aktualnego czasu lokalnego
        now_local = datetime.now()
        local_date = now_local.strftime("%Y-%m-%d")
        local_time = now_local.strftime("%H:%M:%S")

        # Pobranie aktualnego czasu UTC
        now_utc = datetime.now(timezone.utc)
        utc_date = now_utc.strftime("%Y-%m-%d")
        utc_time = now_utc.strftime("%H:%M:%S")

        # Obliczenie czasu wirtualnego
        virtual_time = now_local + timedelta(seconds=self.virtual_time_offset)
        virtual_date = virtual_time.strftime("%Y-%m-%d")
        virtual_time_str = virtual_time.strftime("%H:%M:%S")

        # Aktualizacja etykiet
        self.local_date_label.config(text=f"Data: {local_date}")
        self.local_time_label.config(text=f"{local_time}")

        self.utc_date_label.config(text=f"Data: {utc_date}")
        self.utc_time_label.config(text=f"{utc_time}")

        self.virtual_date_label.config(text=f"Data: {virtual_date}")
        self.virtual_time_label.config(text=f"{virtual_time_str}")

        # Wywołanie funkcji ponownie po 1000ms (1 sekunda)
        self.root.after(1000, self.update_clocks)

    def setup_logging(self):
        """Konfiguracja logowania do okna tekstowego."""
        # Konfiguracja loggera
        root_logger = logging.getLogger()
        root_logger.setLevel(logging.INFO)

        # Usuwanie istniejących handlerów, aby uniknąć duplikacji logów
        for handler in root_logger.handlers[:]:
            root_logger.removeHandler(handler)

        # Handler do przekierowania logów do widgetu Text
        text_handler = TextHandler(self.log_area)
        text_handler.setLevel(logging.INFO)
        text_handler.setFormatter(logging.Formatter('%(asctime)s - %(levelname)s - %(message)s'))
        root_logger.addHandler(text_handler)

        # Handler do pliku logów
        log_filename = 'timesync_gui.log'
        file_handler = logging.FileHandler(log_filename)
        file_handler.setFormatter(logging.Formatter('%(asctime)s - %(levelname)s - %(message)s'))
        root_logger.addHandler(file_handler)

        # Log początkowy
        logging.info(f"Uruchomiono aplikację na {platform.system()} {platform.release()}")

    def is_admin(self):
        """Sprawdza, czy aplikacja jest uruchomiona z uprawnieniami administratora."""
        if platform.system() == "Windows":
            try:
                import ctypes
                return ctypes.windll.shell32.IsUserAnAdmin() != 0
            except Exception:
                return False
        # macOS / Linux: sprawdzenie uprawnień roota
        return hasattr(os, "geteuid") and os.geteuid() == 0

    def adjust_virtual_time(self, seconds):
        """Dostosowuje wirtualny czas o podaną liczbę sekund."""
        self.virtual_time_offset += seconds
        offset_str = self.format_time_offset(self.virtual_time_offset)
        logging.info(f"Zmieniono czas wirtualny o {seconds} sekund. Obecny offset: {offset_str}")

    def format_time_offset(self, seconds):
        """Formatuje offset czasu do czytelnej postaci."""
        sign = "+" if seconds >= 0 else "-"
        abs_seconds = abs(seconds)
        hours = abs_seconds // 3600
        minutes = (abs_seconds % 3600) // 60
        secs = abs_seconds % 60

        return f"{sign}{hours:02d}:{minutes:02d}:{secs:02d}"

    def reset_virtual_time(self):
        """Resetuje wirtualny czas do czasu systemowego."""
        self.virtual_time_offset = 0
        logging.info("Zresetowano zegar wirtualny do czasu systemowego")

    def save_time_settings(self):
        """Zapisuje obecne ustawienie czasu do pliku."""
        try:
            with open("time_settings.txt", "w") as file:
                file.write(str(self.virtual_time_offset))
            offset_str = self.format_time_offset(self.virtual_time_offset)
            logging.info(f"Zapisano ustawienia czasu wirtualnego (offset: {offset_str})")
            messagebox.showinfo("Zapisano", "Ustawienia czasu zostały zapisane")
        except Exception as e:
            logging.error(f"Błąd podczas zapisywania ustawień: {str(e)}")
            messagebox.showerror("Błąd", f"Nie udało się zapisać ustawień: {str(e)}")

    def load_time_settings(self):
        """Wczytuje ustawienie czasu z pliku."""
        try:
            if os.path.exists("time_settings.txt"):
                with open("time_settings.txt", "r") as file:
                    self.virtual_time_offset = int(file.read().strip())

                offset_str = self.format_time_offset(self.virtual_time_offset)
                logging.info(f"Wczytano ustawienia czasu wirtualnego (offset: {offset_str})")
                messagebox.showinfo("Wczytano", f"Ustawienia czasu zostały wczytane\nOffset: {offset_str}")
            else:
                logging.warning("Nie znaleziono zapisanych ustawień czasu")
                messagebox.showwarning("Brak pliku", "Nie znaleziono zapisanych ustawień czasu")
        except Exception as e:
            logging.error(f"Błąd podczas wczytywania ustawień: {str(e)}")
            messagebox.showerror("Błąd", f"Nie udało się wczytać ustawień: {str(e)}")

    def check_time_service(self):
        """Sprawdza stan usługi Windows Time i wyświetla informacje."""
        if platform.system() != "Windows":
            logging.info("Usługa Windows Time jest dostępna tylko w systemie Windows.")
            messagebox.showinfo("Funkcja niedostępna",
                                "Zarządzanie usługą Windows Time jest dostępne tylko w systemie Windows.")
            return

        if not self.is_admin():
            logging.warning("Sprawdzenie stanu usługi wymaga uprawnień administratora.")
            messagebox.showwarning("Brak uprawnień",
                                   "Sprawdzenie stanu usługi Windows Time wymaga uprawnień administratora.")
            return

        try:
            result = self.run_command(["sc", "query", "w32time"])
            source_result = self.run_command(["w32tm", "/query", "/source"])
            config_result = self.run_command(["w32tm", "/query", "/configuration"])

            status_labels = {"running": "URUCHOMIONA", "stopped": "ZATRZYMANA", "unknown": "NIEZNANY"}
            status = status_labels[self.parse_service_status(result.stdout)]

            # Informacje w logu
            logging.info("Status usługi Windows Time:")
            logging.info(f"- Stan usługi: {status}")

            if source_result.returncode == 0:
                logging.info(f"- Źródło czasu: {source_result.stdout.strip()}")
            else:
                logging.info("- Nie można określić źródła czasu.")

            # Szczegółowa informacja w oknie dialogowym
            info = f"Status usługi Windows Time:\n\nStan usługi: {status}\n"

            if source_result.returncode == 0:
                info += f"Źródło czasu: {source_result.stdout.strip()}\n\n"
            else:
                info += "Nie można określić źródła czasu.\n\n"

            # Wybrane fragmenty konfiguracji
            info += "Fragmenty konfiguracji:\n"
            important_keys = ["Type", "NtpServer", "TimeProviders"]
            for line in config_result.stdout.splitlines():
                for key in important_keys:
                    if key in line:
                        info += f"{line.strip()}\n"

            messagebox.showinfo("Status usługi Windows Time", info)

        except Exception as e:
            logging.error(f"Błąd podczas sprawdzania stanu usługi: {str(e)}")
            messagebox.showerror("Błąd", f"Nie udało się sprawdzić stanu usługi: {str(e)}")

    def manage_time_service(self, action):
        """Zarządza usługą Windows Time (start/stop)."""
        if platform.system() != "Windows":
            logging.info("Usługa Windows Time jest dostępna tylko w systemie Windows.")
            messagebox.showinfo("Funkcja niedostępna",
                                "Zarządzanie usługą Windows Time jest dostępne tylko w systemie Windows.")
            return

        if not self.is_admin():
            logging.warning("Zarządzanie usługą wymaga uprawnień administratora.")
            messagebox.showwarning("Brak uprawnień",
                                   "Zarządzanie usługą Windows Time wymaga uprawnień administratora.")
            return

        try:
            if action == "start":
                # Najpierw włącz usługę, jeśli jest wyłączona
                self.run_command(["sc", "config", "w32time", "start=", "auto"])
                logging.info("Ustawiono automatyczne uruchamianie usługi Windows Time.")
                result = self.run_command(["net", "start", "w32time"])
                action_desc = "uruchomić"
            else:
                result = self.run_command(["net", "stop", "w32time"])
                action_desc = "zatrzymać"

            if result.returncode == 0:
                logging.info(f"Operacja '{action}' na usłudze Windows Time zakończona sukcesem.")
                messagebox.showinfo("Sukces", f"Operacja '{action}' na usłudze Windows Time zakończona sukcesem.")
            else:
                logging.error(f"Nie udało się {action_desc} usługi: {result.stderr.strip()}")
                messagebox.showerror("Błąd",
                                     f"Nie udało się {action_desc} usługi Windows Time:\n{result.stderr.strip()}")

        except Exception as e:
            logging.error(f"Błąd podczas zarządzania usługi: {str(e)}")
            messagebox.showerror("Błąd", f"Wystąpił błąd: {str(e)}")

    def start_sync(self):
        """Rozpoczyna proces synchronizacji w osobnym wątku."""
        # W trybie testowym tylko symulujemy synchronizację (bez uprawnień administratora)
        if self.test_mode.get():
            logging.info("Uruchomiono w trybie testowym - synchronizacja jest symulowana")
            self.simulate_sync()
            return

        if not self.is_admin():
            logging.error("Synchronizacja czasu wymaga uprawnień administratora.")
            messagebox.showerror("Brak uprawnień",
                                 "Synchronizacja czasu systemowego wymaga uprawnień administratora.\n"
                                 "Uruchom aplikację jako administrator (Windows) lub przez sudo (macOS).")
            return

        if self.is_syncing:
            messagebox.showinfo("Synchronizacja w toku", "Proces synchronizacji już trwa.")
            return

        self.is_syncing = True
        self.sync_button.config(state=tk.DISABLED)
        self.progress.start(10)

        # Uruchomienie synchronizacji w osobnym wątku
        self.sync_thread = threading.Thread(target=self.sync_time)
        self.sync_thread.daemon = True
        self.sync_thread.start()

    def simulate_sync(self):
        """Symuluje proces synchronizacji (do celów testowych)."""
        self.is_syncing = True
        self.sync_button.config(state=tk.DISABLED)
        self.progress.start(10)

        def simulate_process():
            try:
                server = self.ntp_server.get()
                logging.info(f"[SYMULACJA] Rozpoczęcie synchronizacji z serwerem: {server}")

                # Symulacja etapów synchronizacji
                logging.info("[SYMULACJA] Etap 1/5: Sprawdzanie stanu usługi czasu...")
                time.sleep(1)

                logging.info("[SYMULACJA] Etap 2/5: Włączanie usługi czasu...")
                time.sleep(1)

                logging.info("[SYMULACJA] Etap 3/5: Konfiguracja serwera czasu...")
                time.sleep(1.5)

                logging.info("[SYMULACJA] Etap 4/5: Uruchamianie usługi czasu...")
                time.sleep(1)

                logging.info("[SYMULACJA] Etap 5/5: Wymuszanie resynchronizacji...")
                time.sleep(2)

                logging.info("[SYMULACJA] Synchronizacja zakończona pomyślnie!")
                logging.info(f"[SYMULACJA] Obecny czas: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")

            except Exception as e:
                logging.error(f"[SYMULACJA] Błąd: {str(e)}")
            finally:
                self.root.after(0, self.finish_sync)

        # Uruchomienie symulacji w osobnym wątku
        sim_thread = threading.Thread(target=simulate_process)
        sim_thread.daemon = True
        sim_thread.start()

    @staticmethod
    def is_valid_ntp_server(server):
        """Sprawdza, czy adres serwera NTP zawiera tylko bezpieczne znaki."""
        return bool(re.fullmatch(r"[A-Za-z0-9.\-]+", server))

    @staticmethod
    def run_command(args):
        """Uruchamia polecenie bez powłoki i zwraca wynik."""
        return subprocess.run(args, capture_output=True, text=True)

    @staticmethod
    def parse_service_status(sc_output):
        """Parsuje wynik 'sc query w32time' do stanu usługi."""
        if "RUNNING" in sc_output:
            return "running"
        if "STOPPED" in sc_output:
            return "stopped"
        return "unknown"

    def sync_time(self):
        """Synchronizuje zegar systemowy z serwerem NTP."""
        try:
            server = self.ntp_server.get().strip()
            if not self.is_valid_ntp_server(server):
                logging.error(f"Nieprawidłowy adres serwera NTP: {server}")
                messagebox.showerror("Błąd", f"Nieprawidłowy adres serwera NTP:\n{server}")
                return

            if platform.system() == "Windows":
                self.sync_time_windows(server)
            else:
                self.sync_time_macos(server)

            logging.info(f"Aktualny czas systemowy: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")

        except Exception as e:
            logging.error(f"Wystąpił błąd podczas synchronizacji: {str(e)}")
            messagebox.showerror("Błąd", f"Wystąpił błąd podczas synchronizacji:\n{str(e)}")
        finally:
            # Zakończenie procesu synchronizacji (w głównym wątku GUI)
            self.root.after(0, self.finish_sync)

    def sync_time_windows(self, server):
        """Synchronizacja czasu przez usługę Windows Time (w32time)."""
        logging.info(f"Rozpoczęcie synchronizacji z serwerem: {server}")

        # Etap 1: Sprawdzenie stanu usługi
        logging.info("Etap 1/4: Sprawdzanie stanu usługi Windows Time...")
        result = self.run_command(["sc", "query", "w32time"])
        logging.info(f"Status usługi Windows Time: {self.parse_service_status(result.stdout)}")

        # Etap 2: Włączenie i uruchomienie usługi
        logging.info("Etap 2/4: Włączanie i uruchamianie usługi Windows Time...")
        self.run_command(["sc", "config", "w32time", "start=", "auto"])
        result = self.run_command(["net", "start", "w32time"])
        if result.returncode == 0:
            logging.info("Usługa Windows Time uruchomiona.")
        else:
            logging.info("Usługa Windows Time już działa lub wymaga ręcznej interwencji.")

        # Etap 3: Konfiguracja serwera czasu
        logging.info("Etap 3/4: Konfiguracja serwera czasu...")
        result = self.run_command(["w32tm", "/config", f'/manualpeerlist:"{server}"',
                                   "/syncfromflags:manual", "/reliable:yes", "/update"])
        if result.returncode != 0:
            logging.error(f"Błąd przy konfiguracji serwera czasu: {result.stderr.strip()}")
        else:
            logging.info("Serwer czasu skonfigurowany pomyślnie.")

        # Etap 4: Wymuszenie resynchronizacji (z jedną ponowną próbą)
        logging.info("Etap 4/4: Wymuszanie resynchronizacji...")
        time.sleep(2)  # Dajemy usłudze czas na stabilizację
        if self.try_resync(server):
            return
        logging.info("Próba ponownej synchronizacji po 5 sekundach...")
        time.sleep(5)
        if not self.try_resync(server, retry=True):
            messagebox.showwarning("Ostrzeżenie",
                                   "Synchronizacja mogła się nie powieść. Sprawdź logi dla szczegółów.")

    def try_resync(self, server, retry=False):
        """Wykonuje 'w32tm /resync /force' i zwraca True przy sukcesie."""
        result = self.run_command(["w32tm", "/resync", "/force"])
        output = result.stdout + result.stderr
        if result.returncode == 0 and ("success" in output.lower() or "pomyślnie" in output.lower()):
            logging.info("Synchronizacja zakończona pomyślnie!")
            suffix = " (druga próba)" if retry else ""
            messagebox.showinfo("Sukces", f"Czas został zsynchronizowany z serwerem {server}{suffix}")
            return True
        logging.warning(f"Synchronizacja nie powiodła się: {output.strip()}")
        return False

    def sync_time_macos(self, server):
        """Synchronizacja czasu na macOS przy użyciu narzędzia sntp (wymaga sudo)."""
        logging.info(f"Rozpoczęcie synchronizacji z serwerem: {server}")
        result = self.run_command(["sntp", "-sS", server])
        output = (result.stdout + result.stderr).strip()
        if result.returncode == 0:
            logging.info(f"Synchronizacja zakończona pomyślnie: {output}")
            messagebox.showinfo("Sukces", f"Czas został zsynchronizowany z serwerem {server}")
        else:
            logging.error(f"Synchronizacja nie powiodła się: {output}")
            messagebox.showerror("Błąd", f"Nie udało się zsynchronizować czasu:\n{output}")

    def finish_sync(self):
        """Kończy proces synchronizacji i aktualizuje UI."""
        self.progress.stop()
        self.sync_button.config(state=tk.NORMAL)
        self.is_syncing = False


def main():
    """Funkcja główna aplikacji."""
    root = tk.Tk()
    app = TimeSyncApp(root)
    root.mainloop()


if __name__ == "__main__":
    main()