click_receiver.py

import datetime as dt
import tkinter as tk
from tkinter import messagebox
import time
import threading
import pyautogui
import sys
import socket
import os
import csv
import json
import statistics
from pathlib import Path
from PIL import Image, ImageTk, ImageDraw
import ctypes
import platform
from datetime import datetime, timedelta
# Integrated logging functionality (replaces shared_logging dependency)
class IntegratedLogger:
    """Integrated logging utility for consistent file management"""

    def __init__(self, app_name):
        self.app_name = app_name
        self._setup_directories()

    def _setup_directories(self):
        """Setup centralized DIC Quality Control directory structure"""
        # Use Documents folder as the base
        documents_path = Path.home() / "Documents"

        # Create main DIC Quality Control directory
        self.main_dic_directory = documents_path / "DIC Quality Control"

        # Create app-specific directory within DIC Quality Control
        self.base_log_directory = self.main_dic_directory / self.app_name
        self.export_directory = self.base_log_directory  # Direct export to app folder

        # Create directories
        self.main_dic_directory.mkdir(parents=True, exist_ok=True)
        self.base_log_directory.mkdir(parents=True, exist_ok=True)

    def get_camera_log_directory(self):
        """Get the camera logs directory path as string"""
        return str(self.export_directory)

    def get_export_directory(self):
        """Get the exports directory path as string"""
        return str(self.export_directory)

    def get_log_file_path(self, directory_type, filename):
        """Get full path for a log file"""
        return str(self.export_directory / filename)

    def create_timestamped_filename(self, prefix, extension, include_microseconds=True):
        """Create a timestamped filename"""
        if include_microseconds:
            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f")[:-3]  # Remove last 3 digits for milliseconds
        else:
            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")

        return f"{prefix}_{timestamp}.{extension}"

    def write_csv_log(self, directory_type, filename, data, fieldnames=None):
        """Write data to a CSV log file"""
        if not data:
            return

        if fieldnames is None and data:
            fieldnames = list(data[0].keys())

        filepath = self.get_log_file_path(directory_type, filename)

        with open(filepath, 'w', newline='', encoding='utf-8') as csvfile:
            writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
            writer.writeheader()
            writer.writerows(data)

        return filepath

    def append_csv_log(self, directory_type, filename, data, fieldnames=None):
        """Append data to a CSV log file"""
        filepath = self.get_log_file_path(directory_type, filename)

        # Convert single dict to list
        if isinstance(data, dict):
            data = [data]

        # Check if file exists
        file_exists = os.path.exists(filepath)

        with open(filepath, 'a', newline='', encoding='utf-8') as csvfile:
            if fieldnames is None and data:
                fieldnames = list(data[0].keys())

            writer = csv.DictWriter(csvfile, fieldnames=fieldnames)

            # Write header if file is new
            if not file_exists:
                writer.writeheader()

            writer.writerows(data)

        return filepath

    def print_directory_structure(self):
        """Print the directory structure for debugging"""
        print(" DIC Quality Control Directory Structure:")
        print(f"    Main DIC Directory: {self.main_dic_directory}")
        print(f"    App Folder ({self.app_name}): {self.base_log_directory}")
        print("    Files are saved directly to the app folder")

# Create logger instance for this app
shared_logger = IntegratedLogger("Receiver")


class ClockSyncManager:
    def __init__(self, is_forwarder=False):
        self.is_forwarder = is_forwarder
        self.time_offset = 0.0  # Time difference in seconds (positive means remote is ahead)
        self.sync_accuracy = None  # Standard deviation of measurements
        self.last_sync_time = None
        self.sync_measurements = []

        # Network settings
        self.sync_port = 9998  # Different from main UDP port
        self.sync_socket = None
        self.sync_listening = False

        # Sync statistics
        self.round_trip_times = []
        self.time_differences = []

        # Enhanced sync settings
        self.max_measurements = 50  # Keep more measurements for better accuracy
        self.min_measurements_for_sync = 5  # Require more measurements before updating
        self.outlier_threshold = 2.0  # More aggressive outlier removal
        self.force_sync_samples = 10  # Take multiple samples during force sync

    def start_sync_service(self):
        """Start the clock sync service"""
        try:
            self.sync_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
            self.sync_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
            self.sync_socket.bind(('', self.sync_port))
            self.sync_socket.settimeout(1.0)
            self.sync_listening = True

            sync_thread = threading.Thread(target=self._sync_listener, daemon=True)
            sync_thread.start()

            print(f" Clock sync service started on port {self.sync_port}")
            return True

        except Exception as e:
            print(f" Clock sync service failed to start: {e}")
            return False

    def stop_sync_service(self):
        """Stop the clock sync service"""
        self.sync_listening = False
        if self.sync_socket:
            self.sync_socket.close()
            self.sync_socket = None

    def _sync_listener(self):
        """Listen for sync requests/responses"""
        while self.sync_listening:
            try:
                data, addr = self.sync_socket.recvfrom(1024)
                self._handle_sync_message(data, addr)
            except socket.timeout:
                continue
            except Exception as e:
                if self.sync_listening:
                    print(f" Sync listener error: {e}")
                break

    def _handle_sync_message(self, data, addr):
        """Handle incoming sync messages with improved timing - FIXED VERSION"""
        try:
            # Capture receive timestamp immediately
            receive_time = time.time()

            message = json.loads(data.decode('utf-8'))

            if message['type'] == 'sync_request':
                # Respond with our timestamp immediately
                response_time = time.time()
                response = {
                    'type': 'sync_response',
                    'original_timestamp': message['timestamp'],
                    'response_timestamp': response_time,
                    'receive_timestamp': receive_time,  # When we received the request
                    'responder': 'forwarder' if self.is_forwarder else 'clicker'
                }

                self.sync_socket.sendto(
                    json.dumps(response).encode('utf-8'),
                    addr
                )

            elif message['type'] == 'sync_response':
                # Calculate time difference with improved algorithm
                current_time = time.time()

                # Calculate round trip time
                round_trip = current_time - message['original_timestamp']

                # Use receive timestamp if available for better accuracy
                if 'receive_timestamp' in message:
                    # More accurate: use actual receive time at remote
                    processing_delay = message['response_timestamp'] - message['receive_timestamp']
                    one_way_trip = (round_trip - processing_delay) / 2
                    remote_time_when_received = message['receive_timestamp']
                    our_time_when_remote_received = message['original_timestamp'] + one_way_trip
                    time_diff = remote_time_when_received - our_time_when_remote_received
                else:
                    # Fallback to simple method
                    estimated_one_way = round_trip / 2
                    remote_time_at_response = message['response_timestamp']
                    our_time_at_remote_response = current_time - estimated_one_way
                    time_diff = remote_time_at_response - our_time_at_remote_response

                # Only accept measurements with reasonable round trip times
                if round_trip < 0.1:  # Less than 100ms round trip
                    self.round_trip_times.append(round_trip)
                    self.time_differences.append(time_diff)

                    # Keep only recent measurements
                    if len(self.time_differences) > self.max_measurements:
                        self.time_differences.pop(0)
                        self.round_trip_times.pop(0)

                    # Update offset with improved filtering
                    if len(self.time_differences) >= self.min_measurements_for_sync:
                        self._update_time_offset()

                    # FIX: Use datetime instead of datetime.datetime
                    self.last_sync_time = datetime.now()

                    print(f" Sync measurement: offset={time_diff * 1000:+.1f}ms, rtt={round_trip * 1000:.1f}ms")
                else:
                    print(f" Discarded sync measurement: RTT too high ({round_trip * 1000:.1f}ms)")

        except Exception as e:
            print(f" Sync message handling error: {e}")

    # Fix 3: Replace the format_sync_status method in ClockSyncManager:

    def format_sync_status(self):
        """Format sync status for display - FIXED VERSION"""
        if not self.last_sync_time:
            return " No sync data available"

        # FIX: Use datetime instead of datetime.datetime
        age = (datetime.now() - self.last_sync_time).total_seconds()
        offset_ms = self.time_offset * 1000
        accuracy_ms = self.sync_accuracy * 1000 if self.sync_accuracy else 0

        status_emoji = "" if abs(offset_ms) < 50 and accuracy_ms < 10 else "" if abs(offset_ms) < 100 else ""

        return f"""{status_emoji} Clock Sync Status:
       Offset: {offset_ms:+.1f}ms (remote vs local)
       Accuracy: ±{accuracy_ms:.1f}ms
       Last sync: {age:.0f}s ago
       Measurements: {len(self.time_differences)} ({len(self._advanced_filter_outliers(self.time_differences))} filtered)"""

    def _update_time_offset(self):
        """Update time offset with improved filtering"""
        if len(self.time_differences) < self.min_measurements_for_sync:
            return

        # Use multiple filtering techniques
        filtered_diffs = self._advanced_filter_outliers(self.time_differences)

        if len(filtered_diffs) >= 3:
            # Use median for robustness against outliers
            old_offset = self.time_offset
            self.time_offset = statistics.median(filtered_diffs)
            self.sync_accuracy = statistics.stdev(filtered_diffs) if len(filtered_diffs) > 1 else 0

            offset_change = abs(self.time_offset - old_offset) * 1000
            if offset_change > 10:  # Significant change
                print(
                    f" Clock offset updated: {old_offset * 1000:+.1f}ms → {self.time_offset * 1000:+.1f}ms (change: {offset_change:.1f}ms)")

    def _advanced_filter_outliers(self, values):
        """Advanced outlier filtering using multiple methods"""
        if len(values) < 4:
            return values

        # Method 1: IQR filtering
        sorted_values = sorted(values)
        q1 = sorted_values[len(values) // 4]
        q3 = sorted_values[3 * len(values) // 4]
        iqr = q3 - q1

        lower_bound = q1 - self.outlier_threshold * iqr
        upper_bound = q3 + self.outlier_threshold * iqr

        iqr_filtered = [v for v in values if lower_bound <= v <= upper_bound]

        # Method 2: Standard deviation filtering
        if len(iqr_filtered) > 3:
            mean_val = statistics.mean(iqr_filtered)
            std_val = statistics.stdev(iqr_filtered)

            # Keep values within 2 standard deviations
            std_filtered = [v for v in iqr_filtered if abs(v - mean_val) <= 2 * std_val]

            return std_filtered if len(std_filtered) >= 3 else iqr_filtered

        return iqr_filtered

    def force_sync_with_multiple_samples(self, remote_ip, samples=None):
        """Force sync with multiple rapid samples for better accuracy"""
        if not self.sync_socket:
            return False

        samples = samples or self.force_sync_samples
        print(f" Starting force sync with {samples} samples...")

        successful_samples = 0
        start_time = time.time()

        for i in range(samples):
            try:
                # Send sync request
                request = {
                    'type': 'sync_request',
                    'timestamp': time.time(),
                    'sender': 'forwarder' if self.is_forwarder else 'clicker',
                    'sample_number': i + 1,
                    'total_samples': samples
                }

                self.sync_socket.sendto(
                    json.dumps(request).encode('utf-8'),
                    (remote_ip, self.sync_port)
                )

                successful_samples += 1

                # Small delay between samples to avoid overwhelming
                if i < samples - 1:
                    time.sleep(0.1)

            except Exception as e:
                print(f" Force sync sample {i + 1} failed: {e}")

        # Wait a bit for responses to come back
        time.sleep(1.0)

        elapsed = time.time() - start_time
        print(f" Force sync completed: {successful_samples}/{samples} samples sent in {elapsed:.1f}s")

        return successful_samples > 0

    def sync_with_remote(self, remote_ip):
        """Regular sync with remote computer (single sample)"""
        if not self.sync_socket:
            return False

        try:
            # Send sync request
            request = {
                'type': 'sync_request',
                'timestamp': time.time(),
                'sender': 'forwarder' if self.is_forwarder else 'clicker'
            }

            self.sync_socket.sendto(
                json.dumps(request).encode('utf-8'),
                (remote_ip, self.sync_port)
            )

            return True

        except Exception as e:
            print(f" Sync request failed: {e}")
            return False

    def get_synchronized_timestamp(self):
        """Get timestamp adjusted for remote computer's clock"""
        local_time = time.time()
        return local_time + self.time_offset

    def get_sync_info(self):
        """Get current synchronization information"""
        return {
            'time_offset_ms': self.time_offset * 1000,
            'sync_accuracy_ms': self.sync_accuracy * 1000 if self.sync_accuracy else None,
            'last_sync': self.last_sync_time.isoformat() if self.last_sync_time else None,
            'round_trip_avg_ms': statistics.mean(self.round_trip_times) * 1000 if self.round_trip_times else None,
            'round_trip_min_ms': min(self.round_trip_times) * 1000 if self.round_trip_times else None,
            'round_trip_max_ms': max(self.round_trip_times) * 1000 if self.round_trip_times else None,
            'measurements_count': len(self.time_differences),
            'measurements_filtered': len(
                self._advanced_filter_outliers(self.time_differences)) if self.time_differences else 0
        }

    def reset_sync_data(self):
        """Reset all sync measurements and start fresh"""
        print(" Resetting all sync data...")
        self.time_offset = 0.0
        self.sync_accuracy = None
        self.last_sync_time = None
        self.round_trip_times.clear()
        self.time_differences.clear()
        print(" Sync data reset - ready for fresh measurements")

    def get_detailed_sync_stats(self):
        """Get detailed statistics for troubleshooting"""
        if not self.time_differences:
            return "No sync data available"

        stats = []
        stats.append(f" DETAILED SYNC STATISTICS")
        stats.append(f"{'=' * 40}")
        stats.append(f"Total measurements: {len(self.time_differences)}")
        stats.append(f"Filtered measurements: {len(self._advanced_filter_outliers(self.time_differences))}")
        stats.append(f"Current offset: {self.time_offset * 1000:+.2f}ms")

        if self.sync_accuracy:
            stats.append(f"Accuracy (std dev): ±{self.sync_accuracy * 1000:.2f}ms")

        if self.round_trip_times:
            rtt_ms = [rtt * 1000 for rtt in self.round_trip_times]
            stats.append(f"Round trip times (ms):")
            stats.append(f"  Min: {min(rtt_ms):.2f}")
            stats.append(f"  Max: {max(rtt_ms):.2f}")
            stats.append(f"  Avg: {statistics.mean(rtt_ms):.2f}")
            stats.append(f"  Med: {statistics.median(rtt_ms):.2f}")

        if self.time_differences:
            offset_ms = [diff * 1000 for diff in self.time_differences]
            filtered_ms = [diff * 1000 for diff in self._advanced_filter_outliers(self.time_differences)]

            stats.append(f"Time differences (all, ms):")
            stats.append(f"  Min: {min(offset_ms):+.2f}")
            stats.append(f"  Max: {max(offset_ms):+.2f}")
            stats.append(f"  Avg: {statistics.mean(offset_ms):+.2f}")
            stats.append(f"  Med: {statistics.median(offset_ms):+.2f}")

            if filtered_ms:
                stats.append(f"Time differences (filtered, ms):")
                stats.append(f"  Min: {min(filtered_ms):+.2f}")
                stats.append(f"  Max: {max(filtered_ms):+.2f}")
                stats.append(f"  Avg: {statistics.mean(filtered_ms):+.2f}")
                stats.append(f"  Med: {statistics.median(filtered_ms):+.2f}")

        return "\n".join(stats)


class SystemClockAdjuster:
    """Handle system clock adjustments for both Windows and Linux"""

    @staticmethod
    def can_adjust_clock():
        """Check if we have permission to adjust system clock"""
        try:
            if platform.system() == "Windows":
                return ctypes.windll.shell32.IsUserAnAdmin()
            else:
                return os.geteuid() == 0
        except:
            return False

    @staticmethod
    def adjust_system_clock(offset_seconds):
        """Adjust system clock by offset_seconds"""
        try:
            if platform.system() == "Windows":
                return SystemClockAdjuster._adjust_windows_clock(offset_seconds)
            else:
                return SystemClockAdjuster._adjust_linux_clock(offset_seconds)
        except Exception as e:
            print(f" Clock adjustment failed: {e}")
            return False

    @staticmethod
    def _adjust_windows_clock(offset_seconds):
        """Adjust Windows system clock"""
        try:
            import ctypes
            from ctypes import wintypes

            # Get current system time
            class SYSTEMTIME(ctypes.Structure):
                _fields_ = [
                    ('wYear', wintypes.WORD),
                    ('wMonth', wintypes.WORD),
                    ('wDayOfWeek', wintypes.WORD),
                    ('wDay', wintypes.WORD),
                    ('wHour', wintypes.WORD),
                    ('wMinute', wintypes.WORD),
                    ('wSecond', wintypes.WORD),
                    ('wMilliseconds', wintypes.WORD),
                ]

            # Calculate new time
            current_time = datetime.now()
            new_time = current_time + timedelta(seconds=offset_seconds)

            # Set up SYSTEMTIME structure
            st = SYSTEMTIME()
            st.wYear = new_time.year
            st.wMonth = new_time.month
            st.wDay = new_time.day
            st.wHour = new_time.hour
            st.wMinute = new_time.minute
            st.wSecond = new_time.second
            st.wMilliseconds = new_time.microsecond // 1000
            st.wDayOfWeek = new_time.weekday()

            # Set system time
            result = ctypes.windll.kernel32.SetSystemTime(ctypes.byref(st))

            if result:
                print(f" Windows clock adjusted by {offset_seconds * 1000:+.1f}ms")
                return True
            else:
                print(f" Windows clock adjustment failed")
                return False

        except Exception as e:
            print(f" Windows clock adjustment error: {e}")
            return False

    @staticmethod
    def _adjust_linux_clock(offset_seconds):
        """Adjust Linux system clock"""
        try:
            import subprocess

            # Calculate new time
            current_time = datetime.now()
            new_time = current_time + timedelta(seconds=offset_seconds)

            # Format for date command
            time_string = new_time.strftime("%Y-%m-%d %H:%M:%S")

            # Use date command to set system time
            result = subprocess.run(['sudo', 'date', '-s', time_string],
                                    capture_output=True, text=True)

            if result.returncode == 0:
                print(f" Linux clock adjusted by {offset_seconds * 1000:+.1f}ms")
                return True
            else:
                print(f" Linux clock adjustment failed: {result.stderr}")
                return False

        except Exception as e:
            print(f" Linux clock adjustment error: {e}")
            return False

class ScreenOverlay:
    def __init__(self, parent_app, screenshot, button_type="START"):
        self.parent_app = parent_app
        self.screenshot = screenshot
        self.button_type = button_type
        self.selected_position = None

        # Create fullscreen overlay window
        self.overlay = tk.Toplevel()
        emoji = "" if button_type == "START" else ""
        self.overlay.title(f"Select {emoji} {button_type} Click Position")
        self.overlay.configure(bg="black", cursor="crosshair")

        # Make it fullscreen and topmost
        self.overlay.attributes('-fullscreen', True)
        self.overlay.attributes('-topmost', True)
        self.overlay.focus_force()

        # Convert screenshot to PhotoImage
        self.photo = ImageTk.PhotoImage(screenshot)

        # Create label with screenshot
        self.screen_label = tk.Label(self.overlay, image=self.photo, cursor="crosshair")
        self.screen_label.pack(fill="both", expand=True)

        # Instructions overlay with button type
        instruction_frame = tk.Frame(self.overlay, bg="yellow", relief="raised", bd=3)
        instruction_frame.place(x=20, y=20)

        instructions = tk.Label(instruction_frame,
                                text=f"Click where you want the {emoji} {button_type} button click to happen\nPress ESC to cancel",
                                font=("Arial", 14, "bold"), bg="yellow", fg="black", padx=10, pady=5)
        instructions.pack()

        # Bind events
        self.screen_label.bind("<Button-1>", self.on_click)
        self.overlay.bind("<KeyPress-Escape>", self.cancel)
        self.overlay.bind("<KeyPress>", self.on_key)

        # Focus for keyboard events
        self.overlay.focus_set()

    def on_click(self, event):
        # Get the actual screen coordinates
        self.selected_position = (event.x_root, event.y_root)

        # Visual feedback - draw crosshair on screenshot
        self.draw_crosshair(event.x, event.y)

        # Show confirmation dialog
        self.overlay.after(100, self.confirm_selection)

    def draw_crosshair(self, x, y):
        # Create a copy of screenshot with crosshair
        marked_image = self.screenshot.copy()
        draw = ImageDraw.Draw(marked_image)

        # Choose color based on button type
        color = "green" if self.button_type == "START" else "red"

        # Draw crosshair
        size = 20
        thickness = 3

        # Colored crosshair
        draw.line([x - size, y, x + size, y], fill=color, width=thickness)
        draw.line([x, y - size, x, y + size], fill=color, width=thickness)

        # White outline for visibility
        draw.line([x - size - 1, y - 1, x + size + 1, y - 1], fill="white", width=1)
        draw.line([x - size - 1, y + 1, x + size + 1, y + 1], fill="white", width=1)
        draw.line([x - 1, y - size - 1, x - 1, y + size + 1], fill="white", width=1)
        draw.line([x + 1, y - size - 1, x + 1, y + size + 1], fill="white", width=1)

        # Draw circle around point
        circle_size = 8
        draw.ellipse([x - circle_size, y - circle_size, x + circle_size, y + circle_size],
                     outline=color, width=2)
        draw.ellipse([x - circle_size - 1, y - circle_size - 1, x + circle_size + 1, y + circle_size + 1],
                     outline="white", width=1)

        # Update display
        self.photo = ImageTk.PhotoImage(marked_image)
        self.screen_label.config(image=self.photo)

    def confirm_selection(self):
        emoji = "" if self.button_type == "START" else ""
        result = messagebox.askyesno("Confirm Position",
                                     f"{emoji} {self.button_type} click position selected: {self.selected_position}\n\n"
                                     f"Use this position for {self.button_type} button clicks?",
                                     parent=self.overlay)

        if result:
            self.parent_app.set_click_position(self.selected_position, self.button_type)
            self.close()
        else:
            # Reset and allow new selection
            self.photo = ImageTk.PhotoImage(self.screenshot)
            self.screen_label.config(image=self.photo)
            self.selected_position = None

    def on_key(self, event):
        if event.keysym == "Escape":
            self.cancel(event)

    def cancel(self, event=None):
        self.close()

    def close(self):
        self.overlay.destroy()


class UDPTriggeredClickTimerWithLogging:
    # Replace the __init__ method and create_widgets methods in your click_receiver.py with these compact versions:

    def __init__(self, root):
        self.root = root
        self.root.title("UDP Click Reciever")
        self.root.geometry("350x800")  # More reasonable size
        self.root.configure(bg="#f0f0f0")
        self.root.resizable(True, True)

        # Set minimum size
        self.root.minsize(475, 800)

        # Set window icon
        self.set_window_icon()

        # Initialize variables (keep all existing variables)
        self.start_click_position = None
        self.stop_click_position = None
        self.udp_listening = False
        self.udp_socket = None
        self.udp_thread = None
        self.cancel_event = threading.Event()

        # UDP settings
        self.udp_port = 9999
        self.last_trigger_time = None
        self.events_received = 0

        # CLOCK SYNC
        self.forwarder_ip = "192.168.1.2"
        self.sync_manager = ClockSyncManager(is_forwarder=False)
        self.sync_thread = None

        # SESSION LOGGING
        self.current_session = None
        self.session_logs = []
        self.log_directory = shared_logger.get_camera_log_directory()

        # Auto-click state
        self.auto_click_enabled = False

        # Loop click state
        self.loop_enabled = False
        self.loop_interval = 15.0  # Default interval in seconds
        self.loop_thread = None
        self.loop_stop_event = threading.Event()
        self.loop_click_position = None
        self.loop_click_type = None  # START or STOP
        self.loop_click_count = 0

        # Disable pyautogui failsafe
        pyautogui.FAILSAFE = False

        # Create scrollable interface
        self.create_scrollable_interface()
        self.update_displays()
        self.ensure_log_directory()

        # Start clock sync
        self.start_clock_sync()

        # Add this for window management
        self.diagnostic_windows = []  # Track open diagnostic windows

    def create_scrollable_interface(self):
        """Create a scrollable interface with compact layout"""

        # Create main canvas and scrollbar
        self.main_canvas = tk.Canvas(self.root, bg="#f0f0f0")
        self.scrollbar = tk.Scrollbar(self.root, orient="vertical", command=self.main_canvas.yview)
        self.scrollable_frame = tk.Frame(self.main_canvas, bg="#f0f0f0")

        # Configure scrolling
        self.scrollable_frame.bind(
            "<Configure>",
            lambda e: self.main_canvas.configure(scrollregion=self.main_canvas.bbox("all"))
        )

        self.main_canvas.create_window((0, 0), window=self.scrollable_frame, anchor="nw")
        self.main_canvas.configure(yscrollcommand=self.scrollbar.set)

        # Pack canvas and scrollbar
        self.main_canvas.pack(side="left", fill="both", expand=True)
        self.scrollbar.pack(side="right", fill="y")

        # Enable mouse wheel scrolling
        def _on_mousewheel(event):
            self.main_canvas.yview_scroll(int(-1 * (event.delta / 120)), "units")

        self.root.bind("<MouseWheel>", _on_mousewheel)  # Windows
        self.root.bind("<Button-4>", lambda e: self.main_canvas.yview_scroll(-1, "units"))  # Linux
        self.root.bind("<Button-5>", lambda e: self.main_canvas.yview_scroll(1, "units"))  # Linux

        # Create all widgets in the scrollable frame
        self.create_compact_widgets()

    def create_compact_widgets(self):
        """Create widgets with a more compact layout"""

        # Title - more compact
        title_label = tk.Label(self.scrollable_frame,
                               text=" UDP Click Timer with Logging & Sync",
                               font=("Arial", 12, "bold"), bg="#f0f0f0", fg="#333")
        title_label.pack(pady=(5, 2))

        # Current time display - smaller
        self.current_time_label = tk.Label(self.scrollable_frame, text="",
                                           font=("Arial", 12), bg="#f0f0f0", fg="#666")
        self.current_time_label.pack(pady=1)

        # Create compact sections
        self.create_compact_sync_section()
        self.create_compact_udp_section()
        self.create_compact_position_section()
        self.create_compact_auto_click_section()
        self.create_compact_loop_click_section()
        self.create_compact_session_section()
        self.create_compact_status_section()

    def create_compact_sync_section(self):
        """Clean and intuitive clock sync section"""
        sync_frame = tk.LabelFrame(self.scrollable_frame, text=" Clock Synchronization",
                                   font=("Arial", 12, "bold"), bg="#f0f0f0",
                                   padx=5, pady=3)
        sync_frame.pack(pady=3, padx=10, fill="x")

        # Status display
        self.sync_status_label = tk.Label(sync_frame, text=" Initializing clock sync...",
                                          bg="#f0f0f0", fg="#FF9800",
                                          font=("Arial", 12), wraplength=350)
        self.sync_status_label.pack(pady=2)

        # Main action buttons - clearer labels
        sync_row1 = tk.Frame(sync_frame, bg="#f0f0f0")
        sync_row1.pack(pady=2, fill="x")

        tk.Button(sync_row1, text=" Force Sync", command=self.force_sync_update,
                  bg="#2196F3", fg="white", font=("Arial", 12, "bold"), width=12).pack(side=tk.LEFT, padx=2)

        tk.Button(sync_row1, text=" Statistics", command=self.show_sync_statistics,
                  bg="#4CAF50", fg="white", font=("Arial", 12), width=10).pack(side=tk.LEFT, padx=2)

        tk.Button(sync_row1, text=" Diagnostics", command=self.show_advanced_sync_diagnostics,
                  bg="#FF9800", fg="white", font=("Arial", 12), width=12).pack(side=tk.LEFT, padx=2)

        # Second row for advanced features
        sync_row2 = tk.Frame(sync_frame, bg="#f0f0f0")
        sync_row2.pack(pady=1, fill="x")

        tk.Button(sync_row2, text=" Live Monitor", command=self.show_live_sync_monitor,
                  bg="#9C27B0", fg="white", font=("Arial", 12), width=12).pack(side=tk.LEFT, padx=2)

        tk.Button(sync_row2, text=" Triple Sync", command=self.triple_force_sync,
                  bg="#E91E63", fg="white", font=("Arial", 12), width=12).pack(side=tk.LEFT, padx=2)

        tk.Button(sync_row2, text="️ Reset Data", command=self.reset_sync_data,
                  bg="#795548", fg="white", font=("Arial", 12), width=12).pack(side=tk.LEFT, padx=2)

    def create_compact_udp_section(self):
        """Compact UDP section"""
        udp_frame = tk.LabelFrame(self.scrollable_frame, text=" UDP Trigger",
                                  font=("Arial", 12, "bold"), bg="#f0f0f0",
                                  padx=5, pady=3)
        udp_frame.pack(pady=3, padx=10, fill="x")

        # UDP controls in one row
        udp_controls = tk.Frame(udp_frame, bg="#f0f0f0")
        udp_controls.pack(pady=2, fill="x")

        self.udp_button = tk.Button(udp_controls, text=" Start UDP",
                                    command=self.toggle_udp_listening,
                                    bg="#4CAF50", fg="white", font=("Arial", 12, "bold"),
                                    width=16, cursor="hand2")
        self.udp_button.pack(side=tk.LEFT, padx=2)

        tk.Button(udp_controls, text=" Test", command=self.test_udp_receiver,
                  bg="#FF9800", fg="white", font=("Arial", 12), width=6).pack(side=tk.LEFT, padx=2)

        # Compact status
        self.udp_status_label = tk.Label(udp_frame, text=" Not listening",
                                         bg="#f0f0f0", fg="#f44336", font=("Arial", 12))
        self.udp_status_label.pack(pady=1)

        self.events_label = tk.Label(udp_frame, text="Events: 0",
                                     bg="#f0f0f0", fg="#666", font=("Arial", 12))
        self.events_label.pack()

    def create_compact_position_section(self):
        """Compact position setup section"""
        pos_frame = tk.LabelFrame(self.scrollable_frame, text=" Click Positions",
                                  font=("Arial", 12, "bold"), bg="#f0f0f0",
                                  padx=5, pady=3)
        pos_frame.pack(pady=3, padx=10, fill="x")

        # START section - horizontal layout
        start_section = tk.Frame(pos_frame, bg="#f0f0f0")
        start_section.pack(pady=2, fill="x")

        tk.Label(start_section, text=" START:", bg="#f0f0f0",
                 font=("Arial", 12, "bold"), fg="#4CAF50", width=8).pack(side=tk.LEFT)

        tk.Button(start_section, text=" Screen",
                  command=lambda: self.show_screen_overlay("START"),
                  bg="#4CAF50", fg="white", font=("Arial", 12), width=8).pack(side=tk.LEFT, padx=1)

        tk.Button(start_section, text=" Manual",
                  command=lambda: self.manual_position_entry("START"),
                  bg="#4CAF50", fg="white", font=("Arial", 12), width=6).pack(side=tk.LEFT, padx=1)

        self.start_test_button = tk.Button(start_section, text=" Test",
                                           command=lambda: self.test_click("START"),
                                           bg="#FF9800", fg="white", font=("Arial", 12), width=6,
                                           state="disabled")
        self.start_test_button.pack(side=tk.LEFT, padx=1)

        # START position display - compact
        self.start_position_label = tk.Label(pos_frame, text=" No START position",
                                             bg="#f0f0f0", fg="#f44336", font=("Arial", 12))
        self.start_position_label.pack(pady=(0, 2))

        # STOP section - horizontal layout
        stop_section = tk.Frame(pos_frame, bg="#f0f0f0")
        stop_section.pack(pady=2, fill="x")

        tk.Label(stop_section, text=" STOP:", bg="#f0f0f0",
                 font=("Arial", 12, "bold"), fg="#f44336", width=8).pack(side=tk.LEFT)

        tk.Button(stop_section, text=" Screen",
                  command=lambda: self.show_screen_overlay("STOP"),
                  bg="#f44336", fg="white", font=("Arial", 12), width=8).pack(side=tk.LEFT, padx=1)

        tk.Button(stop_section, text=" Manual",
                  command=lambda: self.manual_position_entry("STOP"),
                  bg="#f44336", fg="white", font=("Arial", 12), width=6).pack(side=tk.LEFT, padx=1)

        self.stop_test_button = tk.Button(stop_section, text=" Test",
                                          command=lambda: self.test_click("STOP"),
                                          bg="#FF9800", fg="white", font=("Arial", 12), width=6,
                                          state="disabled")
        self.stop_test_button.pack(side=tk.LEFT, padx=1)

        # STOP position display - compact
        self.stop_position_label = tk.Label(pos_frame, text=" No STOP position",
                                            bg="#f0f0f0", fg="#f44336", font=("Arial", 12))
        self.stop_position_label.pack(pady=(0, 2))

    def create_compact_auto_click_section(self):
        """Compact auto-click section"""
        auto_frame = tk.LabelFrame(self.scrollable_frame, text=" Auto-Click",
                                   font=("Arial", 12, "bold"), bg="#f0f0f0",
                                   padx=5, pady=3)
        auto_frame.pack(pady=3, padx=10, fill="x")

        # Mode selection - horizontal
        mode_frame = tk.Frame(auto_frame, bg="#f0f0f0")
        mode_frame.pack(pady=2, fill="x")

        tk.Label(mode_frame, text="Mode:", bg="#f0f0f0", font=("Arial", 12, "bold")).pack(side=tk.LEFT)

        self.auto_mode_var = tk.StringVar(value="BOTH")

        tk.Radiobutton(mode_frame, text="START", variable=self.auto_mode_var, value="START",
                       bg="#f0f0f0", font=("Arial", 12)).pack(side=tk.LEFT, padx=5)
        tk.Radiobutton(mode_frame, text="STOP", variable=self.auto_mode_var, value="STOP",
                       bg="#f0f0f0", font=("Arial", 12)).pack(side=tk.LEFT, padx=5)
        tk.Radiobutton(mode_frame, text="BOTH", variable=self.auto_mode_var, value="BOTH",
                       bg="#f0f0f0", font=("Arial", 12)).pack(side=tk.LEFT, padx=5)

        # Enable button and status
        self.auto_click_button = tk.Button(auto_frame, text=" Enable Auto-Click",
                                           command=self.toggle_auto_click,
                                           bg="#4CAF50", fg="white", font=("Arial", 12, "bold"),
                                           state="disabled")
        self.auto_click_button.pack(pady=2, fill="x")

        self.auto_status_label = tk.Label(auto_frame, text="Auto-click disabled",
                                          bg="#f0f0f0", fg="#666", font=("Arial", 12))
        self.auto_status_label.pack(pady=1)

    def create_compact_loop_click_section(self):
        """Loop click section for repeated automated clicks"""
        loop_frame = tk.LabelFrame(self.scrollable_frame, text=" Loop Click",
                                   font=("Arial", 12, "bold"), bg="#f0f0f0",
                                   padx=5, pady=3)
        loop_frame.pack(pady=3, padx=10, fill="x")

        # Click type selection
        type_frame = tk.Frame(loop_frame, bg="#f0f0f0")
        type_frame.pack(pady=2, fill="x")

        tk.Label(type_frame, text="Click Type:", bg="#f0f0f0", font=("Arial", 12, "bold")).pack(side=tk.LEFT)

        self.loop_click_type_var = tk.StringVar(value="START")

        tk.Radiobutton(type_frame, text="START", variable=self.loop_click_type_var, value="START",
                       bg="#f0f0f0", font=("Arial", 12)).pack(side=tk.LEFT, padx=5)
        tk.Radiobutton(type_frame, text="STOP", variable=self.loop_click_type_var, value="STOP",
                       bg="#f0f0f0", font=("Arial", 12)).pack(side=tk.LEFT, padx=5)

        # Interval input
        interval_frame = tk.Frame(loop_frame, bg="#f0f0f0")
        interval_frame.pack(pady=2, fill="x")

        tk.Label(interval_frame, text="Interval (s):", bg="#f0f0f0", font=("Arial", 12)).pack(side=tk.LEFT)

        self.loop_interval_var = tk.StringVar(value="15.0")
        self.loop_interval_entry = tk.Entry(interval_frame, textvariable=self.loop_interval_var,
                                            font=("Arial", 12), width=10)
        self.loop_interval_entry.pack(side=tk.LEFT, padx=5)

        # Control buttons
        button_frame = tk.Frame(loop_frame, bg="#f0f0f0")
        button_frame.pack(pady=2, fill="x")

        self.loop_start_button = tk.Button(button_frame, text=" Start Loop",
                                           command=self.start_loop_click,
                                           bg="#2196F3", fg="white", font=("Arial", 11, "bold"),
                                           state="disabled")
        self.loop_start_button.pack(side=tk.LEFT, padx=2, fill="x", expand=True)

        self.loop_stop_button = tk.Button(button_frame, text=" Stop Loop",
                                          command=self.stop_loop_click,
                                          bg="#f44336", fg="white", font=("Arial", 11, "bold"),
                                          state="disabled")
        self.loop_stop_button.pack(side=tk.LEFT, padx=2, fill="x", expand=True)

        # Status label
        self.loop_status_label = tk.Label(loop_frame, text="Loop disabled",
                                          bg="#f0f0f0", fg="#666", font=("Arial", 11))
        self.loop_status_label.pack(pady=2)

    def create_compact_session_section(self):
        """Compact session logging section"""
        log_frame = tk.LabelFrame(self.scrollable_frame, text=" Session Logging",
                                  font=("Arial", 12, "bold"), bg="#f0f0f0",
                                  padx=5, pady=3)
        log_frame.pack(pady=3, padx=10, fill="both", expand=True)

        # Current session status - compact
        session_status = tk.Frame(log_frame, bg="#f0f0f0")
        session_status.pack(pady=2, fill="x")

        tk.Label(session_status, text="Current:", bg="#f0f0f0",
                 font=("Arial", 12, "bold")).pack(side=tk.LEFT)

        self.current_session_label = tk.Label(session_status, text="No session",
                                              bg="#f0f0f0", fg="#666", font=("Arial", 12))
        self.current_session_label.pack(side=tk.LEFT, padx=5)

        # Export buttons - 2 rows for better fit
        export_row1 = tk.Frame(log_frame, bg="#f0f0f0")
        export_row1.pack(pady=2, fill="x")

        tk.Button(export_row1, text=" CSV", command=self.export_session_logs_csv,
                  bg="#2196F3", fg="white", font=("Arial", 12), width=8).pack(side=tk.LEFT, padx=1)

        tk.Button(export_row1, text=" TXT", command=self.export_session_logs_txt,
                  bg="#4CAF50", fg="white", font=("Arial", 12), width=8).pack(side=tk.LEFT, padx=1)

        tk.Button(export_row1, text=" Clear", command=self.clear_session_logs,
                  bg="#f44336", fg="white", font=("Arial", 12), width=8).pack(side=tk.LEFT, padx=1)

        tk.Button(export_row1, text=" View", command=self.show_session_details,
                  bg="#FF9800", fg="white", font=("Arial", 12), width=8).pack(side=tk.LEFT, padx=1)

        self.session_count_label = tk.Label(export_row1, text="Sessions: 0",
                                            bg="#f0f0f0", fg="#666", font=("Arial", 12))
        self.session_count_label.pack(side=tk.RIGHT)

        # Recent sessions - more compact
        tk.Label(log_frame, text="Recent Sessions:", bg="#f0f0f0",
                 font=("Arial", 12, "bold")).pack(anchor="w", pady=(5, 1))

        # Compact session list
        list_frame = tk.Frame(log_frame, bg="#f0f0f0")
        list_frame.pack(fill="both", expand=True, pady=2)

        list_scroll = tk.Scrollbar(list_frame)
        list_scroll.pack(side=tk.RIGHT, fill=tk.Y)

        self.session_listbox = tk.Listbox(list_frame, yscrollcommand=list_scroll.set,
                                          font=("Courier", 12), height=4)  # Smaller height
        self.session_listbox.pack(side=tk.LEFT, fill="both", expand=True)
        list_scroll.config(command=self.session_listbox.yview)

    def create_compact_status_section(self):
        """Compact status and controls section"""

        # Status display - compact
        self.status_label = tk.Label(self.scrollable_frame,
                                     text="Ready - Set positions and start UDP",
                                     fg="#FF9800", font=("Arial", 12, "bold"),
                                     bg="#f0f0f0", wraplength=400)
        self.status_label.pack(pady=2, padx=10)

        # Last event display - compact
        self.last_event_label = tk.Label(self.scrollable_frame, text="",
                                         font=("Arial", 12, "bold"),
                                         bg="#f0f0f0", fg="#4CAF50")
        self.last_event_label.pack(pady=1)

        # Manual controls - compact
        manual_frame = tk.Frame(self.scrollable_frame, bg="#f0f0f0")
        manual_frame.pack(pady=5, padx=10)

        self.manual_start_button = tk.Button(manual_frame, text=" Manual START",
                                             command=lambda: self.manual_click("START"),
                                             bg="#4CAF50", fg="white", font=("Arial", 12, "bold"),
                                             width=16, state="disabled", cursor="hand2")
        self.manual_start_button.pack(side=tk.LEFT, padx=2)

        self.manual_stop_button = tk.Button(manual_frame, text=" Manual STOP",
                                            command=lambda: self.manual_click("STOP"),
                                            bg="#f44336", fg="white", font=("Arial", 12, "bold"),
                                            width=16, state="disabled", cursor="hand2")
        self.manual_stop_button.pack(side=tk.LEFT, padx=2)

        # Add some bottom padding
        tk.Label(self.scrollable_frame, text="", bg="#f0f0f0", height=2).pack()

    def on_window_resize(self, event=None):
        """Handle window resize events"""
        # Update canvas scroll region
        self.main_canvas.configure(scrollregion=self.main_canvas.bbox("all"))

        # Update canvas width to match window
        canvas_width = self.root.winfo_width() - self.scrollbar.winfo_width()
        self.main_canvas.itemconfig(self.main_canvas.find_all()[0], width=canvas_width)

    def start_clock_sync(self):
        """Start clock synchronization with forwarder"""
        if self.sync_manager.start_sync_service():
            # Start continuous sync
            self.sync_thread = threading.Thread(target=self.continuous_sync, daemon=True)
            self.sync_thread.start()
            print(f" Clock sync initialized with forwarder at {self.forwarder_ip}")
        else:
            print(" Clock sync failed to start - continuing without sync")

    def continuous_sync(self):
        """Continuously sync with forwarder - improved version"""
        sync_interval = 30  # Start with 30 seconds

        while True:
            try:
                # Adjust sync interval based on current accuracy
                if hasattr(self.sync_manager, 'sync_accuracy') and self.sync_manager.sync_accuracy:
                    accuracy_ms = self.sync_manager.sync_accuracy * 1000
                    if accuracy_ms > 50:  # Poor accuracy
                        sync_interval = 15  # Sync more frequently
                    elif accuracy_ms < 10:  # Good accuracy
                        sync_interval = 60  # Sync less frequently
                    else:
                        sync_interval = 30  # Default

                self.sync_manager.sync_with_remote(self.forwarder_ip)
                time.sleep(sync_interval)

            except Exception as e:
                print(f" Continuous sync error: {e}")
                time.sleep(60)  # Wait longer on error

    def ensure_log_directory(self):
        """Create log directory if it doesn't exist"""
        try:
            # Directory is already created by shared_logger, just print info
            print(f" Camera log directory: {self.log_directory}")
            shared_logger.print_directory_structure()
        except Exception as e:
            print(f" Error with log directory: {e}")

    def set_window_icon(self):
        """Set window icon for both local and PyInstaller environments"""
        try:
            # Check if running as PyInstaller executable
            if getattr(sys, 'frozen', False):
                try:
                    icon_path = os.path.join(sys._MEIPASS, "mouse.ico")
                    if os.path.exists(icon_path):
                        self.root.iconbitmap(icon_path)
                        print(f" Icon loaded from PyInstaller bundle: {icon_path}")
                        return
                except:
                    pass

                try:
                    self.root.iconbitmap(default=sys.executable)
                    print(" Icon loaded from executable")
                    return
                except:
                    pass
            else:
                if os.path.exists("mouse.ico"):
                    self.root.iconbitmap("mouse.ico")
                    print(" Icon: mouse.ico loaded from local file")
                    return

            print(" Icon not found - using default")

        except Exception as e:
            print(f" Icon loading error: {e}")

    def create_widgets(self):
        # Title with clock sync reference
        title_label = tk.Label(self.root, text=" UDP Click Timer with Session Logging & Clock Sync",
                               font=("Arial", 14, "bold"), bg="#f0f0f0", fg="#333")
        title_label.pack(pady=8)

        # Current time display
        self.current_time_label = tk.Label(self.root, text="", font=("Arial", 10),
                                           bg="#f0f0f0", fg="#666")
        self.current_time_label.pack(pady=2)

        # UDP Status Section
        self.create_udp_status()

        # Click position setup
        self.create_position_setup()

        # Auto-click controls
        self.create_auto_click_controls()

        # SESSION LOGGING SECTION
        self.create_session_logging_section()

        # Status and manual controls
        self.create_status_controls()

        self.create_clock_sync_section()

    def create_clock_sync_section(self):
        """Clean clock synchronization status section"""
        sync_frame = tk.LabelFrame(self.root, text=" Clock Synchronization",
                                   font=("Arial", 10, "bold"), bg="#f0f0f0",
                                   padx=8, pady=8)
        sync_frame.pack(pady=8, padx=15, fill="x")

        # Sync status display
        self.sync_status_label = tk.Label(sync_frame, text=" Initializing clock sync...",
                                          bg="#f0f0f0", fg="#FF9800",
                                          font=("Arial", 12), wraplength=400)
        self.sync_status_label.pack(pady=3)

        # Main sync controls
        sync_controls = tk.Frame(sync_frame, bg="#f0f0f0")
        sync_controls.pack(pady=5, fill="x")

        tk.Button(sync_controls, text=" Force Sync",
                  command=self.force_sync_update,
                  bg="#2196F3", fg="white",
                  font=("Arial", 12, "bold"), width=14).pack(side=tk.LEFT, padx=2)

        tk.Button(sync_controls, text=" Statistics",
                  command=self.show_sync_statistics,
                  bg="#4CAF50", fg="white",
                  font=("Arial", 12), width=12).pack(side=tk.LEFT, padx=2)

        tk.Button(sync_controls, text=" Live Monitor",
                  command=self.show_live_sync_monitor,
                  bg="#FF9800", fg="white",
                  font=("Arial", 12), width=12).pack(side=tk.LEFT, padx=2)

        # Advanced controls row
        sync_controls2 = tk.Frame(sync_frame, bg="#f0f0f0")
        sync_controls2.pack(pady=2, fill="x")

        tk.Button(sync_controls2, text=" Triple Sync",
                  command=self.triple_force_sync,
                  bg="#E91E63", fg="white",
                  font=("Arial", 12), width=12).pack(side=tk.LEFT, padx=2)

        tk.Button(sync_controls2, text=" Diagnostics",
                  command=self.show_advanced_sync_diagnostics,
                  bg="#9C27B0", fg="white",
                  font=("Arial", 12), width=12).pack(side=tk.LEFT, padx=2)

        tk.Button(sync_controls2, text="️ Reset Data",
                  command=self.reset_sync_data,
                  bg="#795548", fg="white",
                  font=("Arial", 12), width=12).pack(side=tk.LEFT, padx=2)

    def create_udp_status(self):
        # UDP Status frame
        udp_frame = tk.LabelFrame(self.root, text="Instron UDP Trigger",
                                  font=("Arial", 10, "bold"), bg="#f0f0f0",
                                  padx=8, pady=8)
        udp_frame.pack(pady=8, padx=15, fill="x")

        # UDP listening controls
        udp_controls = tk.Frame(udp_frame, bg="#f0f0f0")
        udp_controls.pack(pady=5, fill="x")

        self.udp_button = tk.Button(udp_controls,
                                    text=" Start UDP Listening",
                                    command=self.toggle_udp_listening,
                                    bg="#4CAF50", fg="white",
                                    font=("Arial", 10, "bold"),
                                    height=1, cursor="hand2", width=20)
        self.udp_button.pack(side=tk.LEFT, padx=5)

        tk.Button(udp_controls, text=" Test",
                  command=self.test_udp_receiver,
                  bg="#FF9800", fg="white",
                  font=("Arial", 12), width=8).pack(side=tk.RIGHT, padx=5)

        # UDP status display
        self.udp_status_label = tk.Label(udp_frame, text=" Not listening for UDP triggers",
                                         bg="#f0f0f0", fg="#f44336",
                                         font=("Arial", 12), wraplength=400)
        self.udp_status_label.pack(pady=3)

        # Event statistics
        self.events_label = tk.Label(udp_frame, text="Events received: 0",
                                     bg="#f0f0f0", fg="#666",
                                     font=("Arial", 12))
        self.events_label.pack(pady=2)

    def create_position_setup(self):
        # Dual position setup frame
        pos_frame = tk.LabelFrame(self.root, text="Click Positions (START & STOP)",
                                  font=("Arial", 10, "bold"), bg="#f0f0f0",
                                  padx=8, pady=8)
        pos_frame.pack(pady=8, padx=15, fill="x")

        # START position setup
        start_frame = tk.LabelFrame(pos_frame, text=" START Button Position",
                                    font=("Arial", 9, "bold"), bg="#f0f0f0", fg="#4CAF50",
                                    padx=5, pady=5)
        start_frame.pack(pady=5, fill="x")

        # START position buttons
        start_buttons = tk.Frame(start_frame, bg="#f0f0f0")
        start_buttons.pack(pady=3, fill="x")

        tk.Button(start_buttons, text=" Screen Overlay",
                  command=lambda: self.show_screen_overlay("START"),
                  bg="#4CAF50", fg="white", font=("Arial", 12), width=15).pack(side=tk.LEFT, padx=2)

        tk.Button(start_buttons, text="Manual",
                  command=lambda: self.manual_position_entry("START"),
                  bg="#4CAF50", fg="white", font=("Arial", 12), width=8).pack(side=tk.LEFT, padx=2)

        self.start_test_button = tk.Button(start_buttons, text=" Test",
                                           command=lambda: self.test_click("START"),
                                           bg="#FF9800", fg="white", font=("Arial", 12), width=8,
                                           state="disabled")
        self.start_test_button.pack(side=tk.RIGHT, padx=2)

        # START position display
        self.start_position_label = tk.Label(start_frame, text=" No START position set",
                                             bg="#f0f0f0", fg="#f44336",
                                             font=("Arial", 12), wraplength=400)
        self.start_position_label.pack(pady=2)

        # STOP position setup
        stop_frame = tk.LabelFrame(pos_frame, text=" STOP Button Position",
                                   font=("Arial", 9, "bold"), bg="#f0f0f0", fg="#f44336",
                                   padx=5, pady=5)
        stop_frame.pack(pady=5, fill="x")

        # STOP position buttons
        stop_buttons = tk.Frame(stop_frame, bg="#f0f0f0")
        stop_buttons.pack(pady=3, fill="x")

        tk.Button(stop_buttons, text=" Screen Overlay",
                  command=lambda: self.show_screen_overlay("STOP"),
                  bg="#f44336", fg="white", font=("Arial", 12), width=15).pack(side=tk.LEFT, padx=2)

        tk.Button(stop_buttons, text="Manual",
                  command=lambda: self.manual_position_entry("STOP"),
                  bg="#f44336", fg="white", font=("Arial", 12), width=8).pack(side=tk.LEFT, padx=2)

        self.stop_test_button = tk.Button(stop_buttons, text=" Test",
                                          command=lambda: self.test_click("STOP"),
                                          bg="#FF9800", fg="white", font=("Arial", 12), width=8,
                                          state="disabled")
        self.stop_test_button.pack(side=tk.RIGHT, padx=2)

        # STOP position display
        self.stop_position_label = tk.Label(stop_frame, text=" No STOP position set",
                                            bg="#f0f0f0", fg="#f44336",
                                            font=("Arial", 9), wraplength=400)
        self.stop_position_label.pack(pady=2)

    def create_auto_click_controls(self):
        # Auto-click configuration
        auto_frame = tk.LabelFrame(self.root, text="Auto-Click Configuration",
                                   font=("Arial", 10, "bold"), bg="#f0f0f0",
                                   padx=8, pady=8)
        auto_frame.pack(pady=8, padx=15, fill="x")

        # Auto-click options
        options_frame = tk.Frame(auto_frame, bg="#f0f0f0")
        options_frame.pack(pady=5, fill="x")

        tk.Label(options_frame, text="Auto-click mode:",
                 bg="#f0f0f0", font=("Arial", 9, "bold")).pack(anchor="w")

        self.auto_mode_var = tk.StringVar(value="BOTH")

        tk.Radiobutton(options_frame, text=" START events only",
                       variable=self.auto_mode_var, value="START",
                       bg="#f0f0f0", font=("Arial", 9)).pack(anchor="w", padx=20)

        tk.Radiobutton(options_frame, text=" STOP events only",
                       variable=self.auto_mode_var, value="STOP",
                       bg="#f0f0f0", font=("Arial", 9)).pack(anchor="w", padx=20)

        tk.Radiobutton(options_frame, text=" Both START and STOP",
                       variable=self.auto_mode_var, value="BOTH",
                       bg="#f0f0f0", font=("Arial", 9)).pack(anchor="w", padx=20)

        # Enable/disable auto-click
        self.auto_click_button = tk.Button(auto_frame,
                                           text=" Enable Auto-Click",
                                           command=self.toggle_auto_click,
                                           bg="#4CAF50", fg="white",
                                           font=("Arial", 10, "bold"),
                                           height=1, cursor="hand2",
                                           state="disabled")
        self.auto_click_button.pack(pady=5, fill="x")

        # Auto-click status
        self.auto_status_label = tk.Label(auto_frame, text="Auto-click disabled",
                                          bg="#f0f0f0", fg="#666",
                                          font=("Arial", 9))
        self.auto_status_label.pack(pady=2)

    def create_session_logging_section(self):
        """Session logging functionality"""
        # Session logging frame
        log_frame = tk.LabelFrame(self.root, text=" Session Logging",
                                  font=("Arial", 10, "bold"), bg="#f0f0f0",
                                  padx=8, pady=8)
        log_frame.pack(pady=8, padx=15, fill="both", expand=True)

        # Current session status
        session_status_frame = tk.Frame(log_frame, bg="#f0f0f0")
        session_status_frame.pack(pady=5, fill="x")

        tk.Label(session_status_frame, text="Current Session:",
                 bg="#f0f0f0", font=("Arial", 9, "bold")).pack(side=tk.LEFT)

        self.current_session_label = tk.Label(session_status_frame, text="No active session",
                                              bg="#f0f0f0", fg="#666", font=("Arial", 9))
        self.current_session_label.pack(side=tk.LEFT, padx=10)

        # Session controls
        controls_frame = tk.Frame(log_frame, bg="#f0f0f0")
        controls_frame.pack(pady=5, fill="x")

        tk.Button(controls_frame, text=" Export CSV",
                  command=self.export_session_logs_csv,
                  bg="#2196F3", fg="white", font=("Arial", 9), width=10).pack(side=tk.LEFT, padx=2)

        tk.Button(controls_frame, text=" Export TXT",
                  command=self.export_session_logs_txt,
                  bg="#4CAF50", fg="white", font=("Arial", 9), width=10).pack(side=tk.LEFT, padx=2)

        tk.Button(controls_frame, text="️ Clear Logs",
                  command=self.clear_session_logs,
                  bg="#f44336", fg="white", font=("Arial", 9), width=10).pack(side=tk.LEFT, padx=2)

        tk.Button(controls_frame, text=" View Details",
                  command=self.show_session_details,
                  bg="#FF9800", fg="white", font=("Arial", 9), width=10).pack(side=tk.LEFT, padx=2)

        self.session_count_label = tk.Label(controls_frame, text="Sessions: 0",
                                            bg="#f0f0f0", fg="#666", font=("Arial", 9))
        self.session_count_label.pack(side=tk.RIGHT, padx=5)

        # Recent sessions list
        sessions_frame = tk.Frame(log_frame, bg="#f0f0f0")
        sessions_frame.pack(pady=5, fill="both", expand=True)

        tk.Label(sessions_frame, text="Recent Sessions:",
                 bg="#f0f0f0", font=("Arial", 9, "bold")).pack(anchor="w")

        # Scrollable session list
        list_container = tk.Frame(sessions_frame, bg="#f0f0f0")
        list_container.pack(fill="both", expand=True)

        scrollbar = tk.Scrollbar(list_container)
        scrollbar.pack(side=tk.RIGHT, fill=tk.Y)

        self.session_listbox = tk.Listbox(list_container, yscrollcommand=scrollbar.set,
                                          font=("Courier", 9), height=6)
        self.session_listbox.pack(side=tk.LEFT, fill="both", expand=True)
        scrollbar.config(command=self.session_listbox.yview)

    def create_status_controls(self):
        # Status display
        self.status_label = tk.Label(self.root, text="Ready - Set START/STOP positions and start UDP listening",
                                     fg="#FF9800", font=("Arial", 9, "bold"),
                                     bg="#f0f0f0", wraplength=450)
        self.status_label.pack(pady=2)

        # Last event display
        self.last_event_label = tk.Label(self.root, text="",
                                         font=("Arial", 12, "bold"),
                                         bg="#f0f0f0", fg="#4CAF50", height=1)
        self.last_event_label.pack(pady=2)

        # Manual click buttons
        manual_frame = tk.Frame(self.root, bg="#f0f0f0")
        manual_frame.pack(pady=5)

        self.manual_start_button = tk.Button(manual_frame, text=" Manual START Click",
                                             command=lambda: self.manual_click("START"),
                                             bg="#4CAF50", fg="white",
                                             font=("Arial", 9, "bold"),
                                             width=18, height=2,
                                             state="disabled", cursor="hand2")
        self.manual_start_button.pack(side=tk.LEFT, padx=5)

        self.manual_stop_button = tk.Button(manual_frame, text=" Manual STOP Click",
                                            command=lambda: self.manual_click("STOP"),
                                            bg="#f44336", fg="white",
                                            font=("Arial", 9, "bold"),
                                            width=18, height=2,
                                            state="disabled", cursor="hand2")
        self.manual_stop_button.pack(side=tk.LEFT, padx=5)

    # ==================== CLOCK SYNC METHODS - NEW ====================

    def force_sync_update(self):
        """Force an immediate sync update with multiple samples for accuracy"""
        def do_force_sync():
            print(" Starting force sync with multiple samples...")
            success = self.sync_manager.force_sync_with_multiple_samples(self.forwarder_ip, samples=10)
            if success:
                self.root.after(100, lambda: self.status_label.config(text=" Force sync completed", fg="#4CAF50"))
                print(" Force sync completed successfully")
            else:
                self.root.after(100, lambda: self.status_label.config(text=" Force sync failed", fg="#f44336"))
                print(" Force sync failed")

        # Update UI immediately
        self.status_label.config(text=" Force syncing...", fg="#FF9800")

        # Run sync in background thread
        threading.Thread(target=do_force_sync, daemon=True).start()

    def triple_force_sync(self):
        """Perform triple force sync for maximum accuracy"""
        def do_triple_sync():
            print(" Starting triple force sync for maximum accuracy...")
            self.root.after(100, lambda: self.status_label.config(text=" Triple syncing (1/3)...", fg="#FF9800"))

            for i in range(3):
                print(f" Force sync attempt {i + 1}/3")
                self.sync_manager.force_sync_with_multiple_samples(self.forwarder_ip, samples=10)
                if i < 2:  # Don't sleep after last attempt
                    self.root.after(100, lambda j=i: self.status_label.config(text=f" Triple syncing ({j+2}/3)...", fg="#FF9800"))
                    time.sleep(2)

            self.root.after(100, lambda: self.status_label.config(text=" Triple sync completed!", fg="#4CAF50"))
            print(" Triple force sync completed!")

        # Update UI immediately
        self.status_label.config(text=" Starting triple sync...", fg="#FF9800")

        # Run in background thread
        threading.Thread(target=do_triple_sync, daemon=True).start()

    def reset_sync_data(self):
        """Reset all sync data and start fresh"""
        # Confirm with user
        result = messagebox.askyesno("Reset Sync Data",
                                   "This will clear all sync measurements and start fresh.\n\n"
                                   "Are you sure you want to continue?")
        if result:
            self.sync_manager.reset_sync_data()
            self.status_label.config(text="️ Sync data reset - ready for fresh sync", fg="#FF9800")
            print("️ Sync data has been reset")

    def show_sync_statistics(self):
        """Show detailed sync statistics - FIXED VERSION"""
        sync_info = self.sync_manager.get_sync_info()

        stats_window = tk.Toplevel(self.root)
        stats_window.title("Clock Sync Statistics")
        stats_window.geometry("500x400")
        stats_window.configure(bg="#f0f0f0")

        # Title
        tk.Label(stats_window, text=" Clock Synchronization Statistics",
                 font=("Arial", 14, "bold"), bg="#f0f0f0").pack(pady=10)

        # Stats display
        stats_frame = tk.Frame(stats_window, bg="#f0f0f0")
        stats_frame.pack(pady=10, padx=20, fill="both", expand=True)

        stats_text = tk.Text(stats_frame, font=("Courier", 10), wrap=tk.WORD, height=15)
        stats_text.pack(fill="both", expand=True)

        # Build stats content with proper None handling
        stats_content = "CLOCK SYNCHRONIZATION STATISTICS\n"
        stats_content += "=" * 50 + "\n\n"
        stats_content += f"Current Status: {self.sync_manager.format_sync_status()}\n\n"
        stats_content += "Detailed Information:\n"
        stats_content += f"  Time Offset: {sync_info['time_offset_ms']:+.2f} ms\n"

        # Handle sync accuracy with None check
        if sync_info['sync_accuracy_ms'] is not None:
            stats_content += f"  Sync Accuracy: ±{sync_info['sync_accuracy_ms']:.2f} ms\n"
        else:
            stats_content += "  Sync Accuracy: Not available\n"

        stats_content += f"  Last Sync: {sync_info['last_sync'] or 'Never'}\n"
        stats_content += f"  Measurements: {sync_info['measurements_count']}\n"

        # Handle round trip time with None check
        if sync_info['round_trip_avg_ms'] is not None:
            stats_content += f"  Avg Round Trip: {sync_info['round_trip_avg_ms']:.2f} ms\n"
        else:
            stats_content += "  Avg Round Trip: Not available\n"

        stats_content += f"\nForwarder IP: {self.forwarder_ip}\n"
        stats_content += f"Sync Port: {self.sync_manager.sync_port}\n\n"

        # Recent measurements with safe handling
        stats_content += "Recent Time Differences (ms):\n"
        if self.sync_manager.time_differences:
            recent_diffs = [f"{diff * 1000:+.2f}" for diff in self.sync_manager.time_differences[-10:]]
            stats_content += f"  {recent_diffs}\n"
        else:
            stats_content += "  No measurements yet\n"

        stats_content += "\nRecent Round Trip Times (ms):\n"
        if self.sync_manager.round_trip_times:
            recent_rtts = [f"{rtt * 1000:.2f}" for rtt in self.sync_manager.round_trip_times[-10:]]
            stats_content += f"  {recent_rtts}\n"
        else:
            stats_content += "  No measurements yet\n"

        stats_content += "\nNetwork Quality Assessment:\n"
        if sync_info['time_offset_ms'] is not None:
            offset_abs = abs(sync_info['time_offset_ms'])
            if offset_abs < 10:
                stats_content += "    Excellent (<10ms offset)\n"
            elif offset_abs < 50:
                stats_content += "    Good (<50ms offset)\n"
            else:
                stats_content += "    Poor (>50ms offset)\n"
        else:
            stats_content += "    No sync data available\n"

        stats_text.insert(tk.END, stats_content)
        stats_text.config(state=tk.DISABLED)

    def show_live_sync_monitor(self):
        """Show live sync monitoring window"""
        monitor_window = tk.Toplevel(self.root)
        monitor_window.title("Live Clock Sync Monitor")
        monitor_window.geometry("600x400")
        monitor_window.configure(bg="#000")

        # Title
        title_label = tk.Label(monitor_window, text=" LIVE CLOCK SYNC MONITOR",
                               font=("Courier", 16, "bold"), bg="#000", fg="#00FF00")
        title_label.pack(pady=10)

        # Time displays
        time_frame = tk.Frame(monitor_window, bg="#000")
        time_frame.pack(pady=20, fill="x")

        self.local_time_label = tk.Label(time_frame, text="Local Time:  --:--:--.---",
                                         font=("Courier", 14), bg="#000", fg="#FFFFFF")
        self.local_time_label.pack()

        self.remote_time_label = tk.Label(time_frame, text="Remote Time: --:--:--.--- (estimated)",
                                          font=("Courier", 14), bg="#000", fg="#FFFF00")
        self.remote_time_label.pack()

        # Sync status
        self.live_sync_status = tk.Label(monitor_window, text="Initializing...",
                                         font=("Courier", 12), bg="#000", fg="#00FFFF",
                                         wraplength=500, justify="left")
        self.live_sync_status.pack(pady=20)

        # Control buttons
        control_frame = tk.Frame(monitor_window, bg="#000")
        control_frame.pack(pady=10)

        tk.Button(control_frame, text=" Force Sync", command=self.force_sync_update,
                  bg="#4CAF50", fg="white", font=("Arial", 10)).pack(side=tk.LEFT, padx=10)

        def close_monitor():
            monitor_window.destroy()

        tk.Button(control_frame, text=" Close", command=close_monitor,
                  bg="#f44336", fg="white", font=("Arial", 10)).pack(side=tk.LEFT, padx=10)

        # Start live updates
        def update_live_display():
            try:
                if monitor_window.winfo_exists():
                    # Update times
                    local_time = datetime.now()
                    remote_time = datetime.fromtimestamp(time.time() + self.sync_manager.time_offset)

                    self.local_time_label.config(text=f"Local Time:  {local_time.strftime('%H:%M:%S.%f')[:-3]}")
                    self.remote_time_label.config(
                        text=f"Remote Time: {remote_time.strftime('%H:%M:%S.%f')[:-3]} (estimated)")

                    # Update sync status
                    status_text = self.sync_manager.format_sync_status()
                    self.live_sync_status.config(text=status_text)

                    # Schedule next update
                    monitor_window.after(100, update_live_display)
            except tk.TclError:
                pass  # Window was closed

        update_live_display()

    # ==================== ENHANCED SESSION LOGGING WITH SYNC ====================

    def start_new_session(self, trigger_type="UDP"):
        """Start a new session when START click happens - Enhanced with sync"""
        if self.current_session:
            print(" Warning: Starting new session while previous was active")
            self.end_current_session(trigger_type="FORCE_END")

        # Capture timestamp as close to click time as possible - FIXED
        precise_timestamp = datetime.now()
        local_time = time.time()

        self.current_session = {
            'session_id': len(self.session_logs) + 1,
            'start_time': precise_timestamp,
            'start_timestamp_str': precise_timestamp.strftime('%Y-%m-%d %H:%M:%S.%f')[:-3],
            'start_trigger_type': trigger_type,
            'udp_events_received': self.events_received,
            # Enhanced with sync data
            'start_local_timestamp': local_time,
            'start_sync_timestamp': local_time + self.sync_manager.time_offset,
            'sync_offset_at_start_ms': self.sync_manager.time_offset * 1000,
            'sync_accuracy_at_start_ms': self.sync_manager.sync_accuracy * 1000 if self.sync_manager.sync_accuracy else None
        }

        # Update UI with millisecond precision
        start_time_str = precise_timestamp.strftime('%H:%M:%S.%f')[:-3]
        self.current_session_label.config(
            text=f"Session #{self.current_session['session_id']} - Started: {start_time_str} (sync: {self.current_session['sync_offset_at_start_ms']:+.1f}ms)",
            fg="#4CAF50")

        print(
            f" Session #{self.current_session['session_id']} STARTED at {start_time_str} (trigger: {trigger_type}) (sync offset: {self.current_session['sync_offset_at_start_ms']:+.1f}ms)")

    # 3. Fix end_current_session method:
    def end_current_session(self, trigger_type="UDP"):
        """End current session when STOP click happens - Enhanced with sync"""
        if not self.current_session:
            print(" Warning: No active session to end")
            return

        # Capture timestamp as close to click time as possible - FIXED
        precise_timestamp = datetime.now()
        local_time = time.time()

        # Complete session data
        self.current_session['end_time'] = precise_timestamp
        self.current_session['end_timestamp_str'] = precise_timestamp.strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]
        self.current_session['end_trigger_type'] = trigger_type

        # Enhanced with sync data
        self.current_session['end_local_timestamp'] = local_time
        self.current_session['end_sync_timestamp'] = local_time + self.sync_manager.time_offset
        self.current_session['sync_offset_at_end_ms'] = self.sync_manager.time_offset * 1000
        self.current_session[
            'sync_accuracy_at_end_ms'] = self.sync_manager.sync_accuracy * 1000 if self.sync_manager.sync_accuracy else None

        # Calculate duration with high precision (both local and sync)
        duration = precise_timestamp - self.current_session['start_time']
        self.current_session['duration_seconds'] = duration.total_seconds()
        self.current_session['duration_formatted'] = self.format_duration(duration.total_seconds())

        # Sync-based duration
        sync_duration = self.current_session['end_sync_timestamp'] - self.current_session['start_sync_timestamp']
        self.current_session['sync_duration_seconds'] = sync_duration
        self.current_session['sync_duration_formatted'] = self.format_duration(sync_duration)

        # Add metadata
        self.current_session['total_udp_events'] = self.events_received
        self.current_session['click_positions'] = {
            'start_position': self.start_click_position,
            'stop_position': self.stop_click_position
        }

        # Add to session logs
        self.session_logs.append(self.current_session.copy())

        # Update UI with millisecond precision
        end_time_str = precise_timestamp.strftime('%H:%M:%S.%f')[:-3]
        self.current_session_label.config(text="No active session", fg="#666")

        print(
            f" Session #{self.current_session['session_id']} ENDED at {end_time_str} - Duration: {self.current_session['duration_formatted']} (sync: {self.current_session['sync_duration_formatted']})")

        # Auto-save session log
        self.auto_save_session_log()

        # Update displays
        self.update_session_list()

        # Clear current session
        self.current_session = None

    def format_duration(self, seconds):
        """Format duration in seconds to readable format"""
        if seconds < 60:
            return f"{seconds:.2f}s"
        elif seconds < 3600:
            minutes = int(seconds // 60)
            remaining_seconds = seconds % 60
            return f"{minutes}m {remaining_seconds:.1f}s"
        else:
            hours = int(seconds // 3600)
            minutes = int((seconds % 3600) // 60)
            remaining_seconds = seconds % 60
            return f"{hours}h {minutes}m {remaining_seconds:.0f}s"

    def update_session_list(self):
        """Update the session list display with sync info"""
        self.session_listbox.delete(0, tk.END)

        # Show most recent sessions first
        for session in reversed(self.session_logs[-10:]):
            start_time_ms = session['start_time'].strftime('%H:%M:%S.%f')[:-3]
            duration = session.get('duration_formatted', 'Active')
            sync_offset = session.get('sync_offset_at_start_ms', 0)
            session_id = session['session_id']

            list_text = f"#{session_id:2d} | {start_time_ms} | {duration:>10} | {sync_offset:+.1f}ms"
            self.session_listbox.insert(0, list_text)

        self.session_count_label.config(text=f"Sessions: {len(self.session_logs)}")

    def auto_save_session_log(self):
        """Automatically save session log with sync data"""
        try:
            timestamp = datetime.now().strftime('%Y%m%d')

            # Save CSV file
            csv_filename = f"spinview_click_sessions_{timestamp}.csv"
            csv_filepath = os.path.join(self.log_directory, csv_filename)

            # Save TXT file
            txt_filename = f"spinview_click_sessions_{timestamp}.txt"
            txt_filepath = os.path.join(self.log_directory, txt_filename)

            # Auto-save CSV
            self._auto_save_csv(csv_filepath)

            # Auto-save TXT
            self._auto_save_txt(txt_filepath)

            print(f" Session auto-saved with sync data to CSV: {csv_filepath}")
            print(f" Session auto-saved with sync data to TXT: {txt_filepath}")

        except Exception as e:
            print(f" Auto-save failed: {e}")

    def _auto_save_csv(self, filepath):
        """Auto-save CSV with sync data"""
        file_exists = os.path.exists(filepath)

        with open(filepath, 'a', newline='', encoding='utf-8') as csvfile:
            fieldnames = ['session_id', 'start_timestamp_local', 'start_timestamp_sync', 'end_timestamp_local',
                          'end_timestamp_sync',
                          'duration_seconds_local', 'duration_seconds_sync', 'duration_formatted', 'start_trigger',
                          'end_trigger',
                          'start_position_x', 'start_position_y', 'stop_position_x', 'stop_position_y',
                          'total_udp_events',
                          'sync_offset_start_ms', 'sync_offset_end_ms', 'sync_accuracy_start_ms',
                          'sync_accuracy_end_ms']
            writer = csv.DictWriter(csvfile, fieldnames=fieldnames)

            if not file_exists:
                writer.writeheader()

            if self.session_logs:
                latest_session = self.session_logs[-1]
                start_pos = latest_session['click_positions']['start_position'] or (0, 0)
                stop_pos = latest_session['click_positions']['stop_position'] or (0, 0)

                # Enhanced timestamps with sync
                start_local = datetime.fromtimestamp(latest_session['start_local_timestamp']).strftime(
                    '%Y-%m-%d %H:%M:%S.%f')[:-3]
                start_sync = datetime.fromtimestamp(latest_session['start_sync_timestamp']).strftime(
                    '%Y-%m-%d %H:%M:%S.%f')[:-3]
                end_local = datetime.fromtimestamp(latest_session['end_local_timestamp']).strftime(
                    '%Y-%m-%d %H:%M:%S.%f')[:-3]
                end_sync = datetime.fromtimestamp(latest_session['end_sync_timestamp']).strftime(
                    '%Y-%m-%d %H:%M:%S.%f')[:-3]

                writer.writerow({
                    'session_id': latest_session['session_id'],
                    'start_timestamp_local': start_local,
                    'start_timestamp_sync': start_sync,
                    'end_timestamp_local': end_local,
                    'end_timestamp_sync': end_sync,
                    'duration_seconds_local': latest_session.get('duration_seconds', 0),
                    'duration_seconds_sync': latest_session.get('sync_duration_seconds', 0),
                    'duration_formatted': latest_session.get('duration_formatted', ''),
                    'start_trigger': latest_session['start_trigger_type'],
                    'end_trigger': latest_session.get('end_trigger_type', ''),
                    'start_position_x': start_pos[0],
                    'start_position_y': start_pos[1],
                    'stop_position_x': stop_pos[0],
                    'stop_position_y': stop_pos[1],
                    'total_udp_events': latest_session['total_udp_events'],
                    'sync_offset_start_ms': latest_session.get('sync_offset_at_start_ms', 0),
                    'sync_offset_end_ms': latest_session.get('sync_offset_at_end_ms', 0),
                    'sync_accuracy_start_ms': latest_session.get('sync_accuracy_at_start_ms', 0),
                    'sync_accuracy_end_ms': latest_session.get('sync_accuracy_at_end_ms', 0)
                })

    def _auto_save_txt(self, filepath):
        """Auto-save TXT with sync data"""
        file_exists = os.path.exists(filepath)

        with open(filepath, 'a', encoding='utf-8') as txtfile:
            if not file_exists:
                txtfile.write("SPINVIEW CLICK TIMER DAILY SESSION LOG WITH CLOCK SYNC\n")
                txtfile.write("=" * 60 + "\n")
                txtfile.write(f"Log Date: {datetime.now().strftime('%Y-%m-%d')}\n")  # FIXED
                txtfile.write(f"Log Directory: {self.log_directory}\n")
                txtfile.write(f"Forwarder IP: {self.forwarder_ip}\n\n")

            if self.session_logs:
                latest_session = self.session_logs[-1]
                start_pos = latest_session['click_positions']['start_position'] or (0, 0)
                stop_pos = latest_session['click_positions']['stop_position'] or (0, 0)

                # Enhanced timestamps with sync
                start_local = datetime.fromtimestamp(latest_session['start_local_timestamp']).strftime(
                    '%Y-%m-%d %H:%M:%S.%f')[:-3]
                start_sync = datetime.fromtimestamp(latest_session['start_sync_timestamp']).strftime(
                    '%Y-%m-%d %H:%M:%S.%f')[:-3]
                end_local = datetime.fromtimestamp(latest_session['end_local_timestamp']).strftime(
                    '%Y-%m-%d %H:%M:%S.%f')[:-3]
                end_sync = datetime.fromtimestamp(latest_session['end_sync_timestamp']).strftime(
                    '%Y-%m-%d %H:%M:%S.%f')[:-3]

                txtfile.write(
                    f"Session #{latest_session['session_id']} - {datetime.now().strftime('%H:%M:%S.%f')[:-3]}:\n")  # FIXED
                txtfile.write(
                    f"   START (Local): {start_local} ({latest_session['start_trigger_type']}) at {start_pos}\n")
                txtfile.write(
                    f"   START (Sync):  {start_sync} (offset: {latest_session.get('sync_offset_at_start_ms', 0):+.1f}ms)\n")
                txtfile.write(
                    f"   END (Local):   {end_local} ({latest_session.get('end_trigger_type', 'N/A')}) at {stop_pos}\n")
                txtfile.write(
                    f"   END (Sync):    {end_sync} (offset: {latest_session.get('sync_offset_at_end_ms', 0):+.1f}ms)\n")
                txtfile.write(
                    f"    Duration (Local): {latest_session.get('duration_formatted', 'N/A')} ({latest_session.get('duration_seconds', 0):.3f}s)\n")
                txtfile.write(
                    f"    Duration (Sync):  {latest_session.get('sync_duration_formatted', 'N/A')} ({latest_session.get('sync_duration_seconds', 0):.3f}s)\n")
                txtfile.write(f"   UDP Events: {latest_session['total_udp_events']}\n")
                txtfile.write(f"   Sync Accuracy: ±{latest_session.get('sync_accuracy_at_start_ms', 0):.1f}ms\n")
                txtfile.write("-" * 60 + "\n")

    # ==================== ENHANCED UDP PROCESSING WITH SYNC ====================

    def process_udp_trigger(self, message, addr):
        """Process received UDP trigger with enhanced sync data"""
        try:
            receive_timestamp = time.time()  # Capture immediately

            # Try to parse enhanced message format first
            try:
                data = json.loads(message)
                event_type = data['event']
                sent_local_time = data.get('local_ts', receive_timestamp)
                sent_sync_time = data.get('sync_ts', receive_timestamp)
                remote_offset_ms = data.get('offset_ms', 0)

                # Calculate transmission time using sync
                received_sync_time = receive_timestamp + self.sync_manager.time_offset
                transmission_time_ms = (received_sync_time - sent_sync_time) * 1000

                timestamp_str = datetime.fromtimestamp(receive_timestamp).strftime('%H:%M:%S.%f')[:-3]

            except (json.JSONDecodeError, KeyError):
                # Fallback to original format
                if ':' in message:
                    event_type, timestamp_str = message.split(':', 1)
                else:
                    event_type = message
                    timestamp_str = datetime.fromtimestamp(receive_timestamp).strftime('%H:%M:%S.%f')[:-3]

                transmission_time_ms = None
                remote_offset_ms = None

            self.events_received += 1
            self.last_trigger_time = datetime.fromtimestamp(receive_timestamp)

            # Update UI
            self.events_label.config(text=f"Events received: {self.events_received}")

            emoji = "" if event_type == "START" else ""

            # Enhanced display with sync info
            if transmission_time_ms is not None:
                self.last_event_label.config(
                    text=f"{emoji} {event_type} at {timestamp_str} (tx: {transmission_time_ms:+.1f}ms)")
                print(f" Enhanced UDP received: {event_type} from {addr[0]} at {timestamp_str}")
                print(f"   Transmission time: {transmission_time_ms:+.1f}ms")
                print(f"   Remote clock offset: {remote_offset_ms:+.1f}ms")
                print(f"   Local clock offset: {self.sync_manager.time_offset * 1000:+.1f}ms")
            else:
                self.last_event_label.config(text=f"{emoji} {event_type} at {timestamp_str}")
                print(f" UDP received: {event_type} from {addr[0]} at {timestamp_str}")

            # Auto-click if enabled and event matches selected mode
            if self.auto_click_enabled:
                auto_mode = self.auto_mode_var.get()
                if auto_mode == "BOTH" or auto_mode == event_type:
                    self.perform_auto_click(event_type)

        except Exception as e:
            print(f" Error processing UDP trigger: {e}")

    # 5. Fix perform_auto_click method:
    def perform_auto_click(self, event_type):
        """Perform automatic click based on UDP trigger WITH ENHANCED SYNC LOGGING"""
        position = None

        if event_type == "START":
            position = self.start_click_position
        elif event_type == "STOP":
            position = self.stop_click_position

        if not position:
            print(f" Auto-click failed: No {event_type} position set")
            return

        try:
            # CAPTURE TIMESTAMP BEFORE CLICK FOR MAXIMUM ACCURACY - FIXED
            pre_click_timestamp = datetime.now()
            pre_click_time = time.time()

            # Perform the click
            pyautogui.click(position[0], position[1])

            # CAPTURE TIMESTAMP AFTER CLICK - FIXED
            post_click_timestamp = datetime.now()
            post_click_time = time.time()

            # Calculate click execution time
            click_duration = (post_click_timestamp - pre_click_timestamp).total_seconds() * 1000

            click_time = pre_click_timestamp.strftime('%H:%M:%S.%f')[:-3]
            emoji = "" if event_type == "START" else ""

            # Enhanced logging with sync data
            sync_offset_ms = self.sync_manager.time_offset * 1000
            sync_accuracy_ms = self.sync_manager.sync_accuracy * 1000 if self.sync_manager.sync_accuracy else 0

            print(f" Enhanced auto-click performed: {emoji} {event_type} at {click_time}")
            print(f"   Click execution: {click_duration:.1f}ms")
            print(f"   Clock sync offset: {sync_offset_ms:+.1f}ms (±{sync_accuracy_ms:.1f}ms)")

            self.status_label.config(text=f"Auto-clicked {event_type} at {click_time} (sync: {sync_offset_ms:+.1f}ms)",
                                     fg="#4CAF50")

            # SESSION LOGGING INTEGRATION WITH SYNC
            if event_type == "START":
                self.start_new_session(trigger_type="UDP_AUTO")
            elif event_type == "STOP":
                self.end_current_session(trigger_type="UDP_AUTO")

        except Exception as e:
            print(f" Auto-click failed: {e}")

    # ==================== ENHANCED MANUAL METHODS ====================

    def manual_click(self, button_type="START"):
        """Perform manual click for START or STOP buttons WITH ENHANCED SYNC LOGGING"""
        position = self.start_click_position if button_type == "START" else self.stop_click_position

        if not position:
            messagebox.showerror("No Position", f"Please set a {button_type} click position first!")
            return

        try:
            # CAPTURE TIMESTAMP BEFORE CLICK FOR MAXIMUM ACCURACY - FIXED
            pre_click_timestamp = datetime.now()
            pre_click_time = time.time()

            # Perform the click
            pyautogui.click(position[0], position[1])

            # CAPTURE TIMESTAMP AFTER CLICK - FIXED
            post_click_timestamp = datetime.now()

            # Calculate click execution time
            click_duration = (post_click_timestamp - pre_click_timestamp).total_seconds() * 1000

            click_time = pre_click_timestamp.strftime('%H:%M:%S.%f')[:-3]
            emoji = "" if button_type == "START" else ""

            # Enhanced status with sync data
            sync_offset_ms = self.sync_manager.time_offset * 1000
            self.status_label.config(text=f"Manual {button_type} click at {click_time} (sync: {sync_offset_ms:+.1f}ms)",
                                     fg="#4CAF50")

            print(f" Enhanced manual {button_type} click at {position} at {click_time}")
            print(f"   Click execution: {click_duration:.1f}ms")
            print(f"   Clock sync offset: {sync_offset_ms:+.1f}ms")

            # SESSION LOGGING INTEGRATION WITH SYNC
            if button_type == "START":
                self.start_new_session(trigger_type="MANUAL")
            elif button_type == "STOP":
                self.end_current_session(trigger_type="MANUAL")

        except Exception as e:
            messagebox.showerror("Click Failed", f"Manual {button_type} click failed: {str(e)}")

    # ==================== REMAINING ORIGINAL METHODS WITH ENHANCED UPDATES ====================

    def toggle_udp_listening(self):
        """Start/stop UDP listening"""
        if self.udp_listening:
            self.stop_udp_listening()
        else:
            self.start_udp_listening()

    def start_udp_listening(self):
        """Start listening for UDP triggers"""
        try:
            # Create UDP socket
            self.udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
            self.udp_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
            self.udp_socket.bind(('', self.udp_port))

            self.udp_listening = True
            self.events_received = 0

            # Start listening thread
            self.udp_thread = threading.Thread(target=self.udp_listener, daemon=True)
            self.udp_thread.start()

            # Update UI
            self.udp_button.config(text=" Stop UDP Listening", bg="#f44336")
            self.udp_status_label.config(text=f" Listening on port {self.udp_port}", fg="#4CAF50")
            self.status_label.config(text="UDP listening - waiting for Instron events", fg="#4CAF50")

            print(f" UDP listening started on port {self.udp_port}")

        except Exception as e:
            messagebox.showerror("UDP Error", f"Failed to start UDP listening: {str(e)}")

    def stop_udp_listening(self):
        """Stop UDP listening"""
        self.udp_listening = False

        if self.udp_socket:
            self.udp_socket.close()
            self.udp_socket = None

        # Update UI
        self.udp_button.config(text=" Start UDP Listening", bg="#4CAF50")
        self.udp_status_label.config(text=" Not listening for UDP triggers", fg="#f44336")
        self.status_label.config(text="Ready - Start UDP listening for Instron events", fg="#FF9800")

        print(" UDP listening stopped")

    def udp_listener(self):
        """UDP listener thread"""
        while self.udp_listening:
            try:
                # Receive UDP data with timeout
                self.udp_socket.settimeout(1.0)
                data, addr = self.udp_socket.recvfrom(1024)

                # Parse trigger data
                message = data.decode('utf-8')
                self.process_udp_trigger(message, addr)

            except socket.timeout:
                continue
            except Exception as e:
                if self.udp_listening:  # Only log if we're supposed to be listening
                    print(f" UDP error: {e}")
                break

    def toggle_auto_click(self):
        """Enable/disable auto-click"""
        if self.auto_click_enabled:
            self.auto_click_enabled = False
            self.auto_click_button.config(text=" Enable Auto-Click", bg="#4CAF50")
            self.auto_status_label.config(text="Auto-click disabled", fg="#666")
        else:
            # Check requirements based on selected mode
            auto_mode = self.auto_mode_var.get()
            missing_positions = []

            if auto_mode == "START" and not self.start_click_position:
                missing_positions.append("START")
            elif auto_mode == "STOP" and not self.stop_click_position:
                missing_positions.append("STOP")
            elif auto_mode == "BOTH":
                if not self.start_click_position:
                    missing_positions.append("START")
                if not self.stop_click_position:
                    missing_positions.append("STOP")

            if missing_positions:
                messagebox.showerror("Missing Positions",
                                     f"Please set {' and '.join(missing_positions)} position(s) first!")
                return

            if not self.udp_listening:
                messagebox.showerror("UDP Not Listening", "Please start UDP listening first!")
                return

            self.auto_click_enabled = True
            self.auto_click_button.config(text=" Disable Auto-Click", bg="#f44336")
            self.auto_status_label.config(text=f"Auto-click ON for {auto_mode} events", fg="#4CAF50")

    def test_udp_receiver(self):
        """Test UDP receiver functionality"""
        if not self.udp_listening:
            messagebox.showwarning("Not Listening", "Start UDP listening first!")
            return

        # Simulate UDP events for testing
        test_events = [
            ("START", datetime.now().strftime('%H:%M:%S.%f')[:-3]),
            ("STOP", datetime.now().strftime('%H:%M:%S.%f')[:-3])
        ]

        for event_type, timestamp in test_events:
            message = f"{event_type}:{timestamp}"
            self.process_udp_trigger(message, ("127.0.0.1", 0))
            time.sleep(0.5)

        messagebox.showinfo("Test Complete", "UDP receiver test completed!")

    def show_screen_overlay(self, button_type="START"):
        """Show screen overlay for START or STOP button selection with fixed window positioning"""
        try:
            # Store current window position and state before hiding
            current_geometry = self.root.geometry()
            current_state = self.root.state()

            # Take screenshot
            self.root.withdraw()  # Hide main window
            time.sleep(0.3)  # Give time for window to hide

            screenshot = pyautogui.screenshot()

            # Show overlay with button type context
            overlay = ScreenOverlay(self, screenshot, button_type)

            # Store geometry for restoration
            self.stored_geometry = current_geometry
            self.stored_state = current_state

            # Show main window again after delay with proper restoration
            self.root.after(1000, self.check_overlay_closed)

        except Exception as e:
            self.root.deiconify()  # Make sure window comes back
            messagebox.showerror("Screenshot Error", f"Failed to create overlay: {str(e)}")

    def check_overlay_closed(self):
        # Bring main window back to front with proper positioning
        self.root.deiconify()

        # Force restore the exact previous position and state
        if hasattr(self, 'stored_geometry') and hasattr(self, 'stored_state'):
            # First restore geometry
            self.root.geometry(self.stored_geometry)

            # Handle different window states properly
            if self.stored_state == 'zoomed':  # Maximized
                self.root.state('zoomed')
            elif self.stored_state == 'normal':
                self.root.state('normal')
                # Re-apply geometry after state change to ensure position sticks
                self.root.after(50, lambda: self.root.geometry(self.stored_geometry))

        # Force window to front and focus
        self.root.lift()
        self.root.focus_force()
        self.root.attributes('-topmost', True)
        self.root.after(100, lambda: self.root.attributes('-topmost', False))

    def set_click_position(self, position, button_type="START"):
        """Set click position for START or STOP buttons"""
        if button_type == "START":
            self.start_click_position = position
            self.start_position_label.config(text=f" START position: ({position[0]}, {position[1]})",
                                             fg="#4CAF50")
            self.start_test_button.config(state="normal")
            self.manual_start_button.config(state="normal")
        else:  # STOP
            self.stop_click_position = position
            self.stop_position_label.config(text=f" STOP position: ({position[0]}, {position[1]})",
                                            fg="#4CAF50")
            self.stop_test_button.config(state="normal")
            self.manual_stop_button.config(state="normal")

        # Enable auto-click button if UDP is listening and we have required positions
        if self.udp_listening:
            self.auto_click_button.config(state="normal")
            self.update_status_message()

    def manual_position_entry(self, button_type="START"):
        """Manual position entry for START or STOP buttons"""
        dialog = tk.Toplevel(self.root)
        dialog.title(f"Manual {button_type} Position Entry")
        dialog.geometry("350x200")
        dialog.configure(bg="#f0f0f0")
        dialog.grab_set()  # Make dialog modal
        dialog.resizable(False, False)

        # Center the dialog
        dialog.transient(self.root)

        emoji = "" if button_type == "START" else ""
        tk.Label(dialog, text=f"Enter {emoji} {button_type} click coordinates:",
                 bg="#f0f0f0", font=("Arial", 12, "bold")).pack(pady=15)

        coord_frame = tk.Frame(dialog, bg="#f0f0f0")
        coord_frame.pack(pady=10)

        tk.Label(coord_frame, text="X:", bg="#f0f0f0", font=("Arial", 11)).pack(side=tk.LEFT)
        x_entry = tk.Entry(coord_frame, width=10, font=("Arial", 11))
        x_entry.pack(side=tk.LEFT, padx=10)

        tk.Label(coord_frame, text="Y:", bg="#f0f0f0", font=("Arial", 11)).pack(side=tk.LEFT)
        y_entry = tk.Entry(coord_frame, width=10, font=("Arial", 11))
        y_entry.pack(side=tk.LEFT, padx=10)

        def set_position():
            try:
                x = int(x_entry.get())
                y = int(y_entry.get())
                self.set_click_position((x, y), button_type)
                dialog.destroy()
            except ValueError:
                messagebox.showerror("Invalid Input",
                                     "Please enter valid integer coordinates",
                                     parent=dialog)

        button_frame = tk.Frame(dialog, bg="#f0f0f0")
        button_frame.pack(pady=20)

        color = "#4CAF50" if button_type == "START" else "#f44336"
        tk.Button(button_frame, text=f"Set {button_type} Position", command=set_position,
                  bg=color, fg="white", font=("Arial", 11, "bold")).pack(side=tk.LEFT, padx=10)
        tk.Button(button_frame, text="Cancel", command=dialog.destroy,
                  bg="#666", fg="white", font=("Arial", 11)).pack(side=tk.LEFT, padx=10)

        # Focus on first entry
        x_entry.focus()

    def test_click(self, button_type="START"):
        """Test click for START or STOP buttons"""
        position = self.start_click_position if button_type == "START" else self.stop_click_position

        if not position:
            messagebox.showerror("No Position", f"Please set a {button_type} click position first!")
            return

        emoji = "" if button_type == "START" else ""
        result = messagebox.askyesno("Test Click",
                                     f"Perform test {emoji} {button_type} click at position {position}?\n\n"
                                     f"This will immediately click at that location.")

        if result:
            try:
                pyautogui.click(position[0], position[1])
                messagebox.showinfo("Test Complete",
                                    f"Test {button_type} click performed at {position}")
            except Exception as e:
                messagebox.showerror("Test Failed", f"Test {button_type} click failed: {str(e)}")

    def update_status_message(self):
        """Update the main status message based on current state"""
        if self.udp_listening and (self.start_click_position or self.stop_click_position):
            if self.start_click_position and self.stop_click_position:
                self.status_label.config(text=" Ready for auto-click - both START and STOP positions set",
                                         fg="#4CAF50")
            elif self.start_click_position:
                self.status_label.config(text=" START position set - consider setting STOP position too",
                                         fg="#FF9800")
            else:
                self.status_label.config(text=" STOP position set - consider setting START position too",
                                         fg="#FF9800")
        elif self.udp_listening:
            self.status_label.config(text="UDP listening - set START/STOP positions for auto-click", fg="#FF9800")
        else:
            self.status_label.config(text="Ready - Set positions and start UDP listening", fg="#FF9800")

    def update_displays(self):
        # Update current time - FIXED
        current = datetime.now().strftime("%H:%M:%S.%f")[:-3]
        self.current_time_label.config(text=f"Current Time: {current}")

        # Update sync status
        if hasattr(self, 'sync_manager'):
            self.sync_status_label.config(text=self.sync_manager.format_sync_status())

        # Update auto-click button state
        has_required_positions = False
        auto_mode = self.auto_mode_var.get()

        if auto_mode == "START" and self.start_click_position:
            has_required_positions = True
        elif auto_mode == "STOP" and self.stop_click_position:
            has_required_positions = True
        elif auto_mode == "BOTH" and self.start_click_position and self.stop_click_position:
            has_required_positions = True

        if has_required_positions and self.udp_listening and not self.auto_click_enabled:
            self.auto_click_button.config(state="normal")
        elif not has_required_positions or not self.udp_listening:
            self.auto_click_button.config(state="disabled")

        # Update loop-click button state
        loop_mode = self.loop_click_type_var.get()
        loop_has_position = False
        
        if loop_mode == "START" and self.start_click_position:
            loop_has_position = True
        elif loop_mode == "STOP" and self.stop_click_position:
            loop_has_position = True
        
        if loop_has_position and not self.loop_enabled:
            self.loop_start_button.config(state="normal")
        elif not loop_has_position or self.loop_enabled:
            self.loop_start_button.config(state="disabled")

        self.root.after(100, self.update_displays)

    # ==================== ENHANCED EXPORT METHODS WITH SYNC ====================

    def export_session_logs_csv(self):
        """Export all session logs to CSV with sync data"""
        if not self.session_logs:
            messagebox.showinfo("No Data", "No sessions to export!")
            return

        try:
            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
            filename = f"spinview_click_sessions_with_sync_export_{timestamp}.csv"
            filepath = shared_logger.get_log_file_path('export', filename)

            with open(filepath, 'w', newline='', encoding='utf-8') as csvfile:
                fieldnames = ['session_id', 'start_timestamp_local', 'start_timestamp_sync', 'end_timestamp_local',
                              'end_timestamp_sync',
                              'duration_seconds_local', 'duration_seconds_sync', 'duration_formatted', 'start_trigger',
                              'end_trigger',
                              'start_position_x', 'start_position_y', 'stop_position_x', 'stop_position_y',
                              'total_udp_events',
                              'sync_offset_start_ms', 'sync_offset_end_ms', 'sync_accuracy_start_ms',
                              'sync_accuracy_end_ms']
                writer = csv.DictWriter(csvfile, fieldnames=fieldnames)

                writer.writeheader()
                for session in self.session_logs:
                    start_pos = session['click_positions']['start_position'] or (0, 0)
                    stop_pos = session['click_positions']['stop_position'] or (0, 0)

                    # Enhanced timestamps with sync
                    start_local = datetime.fromtimestamp(session['start_local_timestamp']).strftime(
                        '%Y-%m-%d %H:%M:%S.%f')[:-3]
                    start_sync = datetime.fromtimestamp(session['start_sync_timestamp']).strftime(
                        '%Y-%m-%d %H:%M:%S.%f')[:-3]
                    end_local = datetime.fromtimestamp(session['end_local_timestamp']).strftime(
                        '%Y-%m-%d %H:%M:%S.%f')[:-3]
                    end_sync = datetime.fromtimestamp(session['end_sync_timestamp']).strftime(
                        '%Y-%m-%d %H:%M:%S.%f')[:-3]

                    writer.writerow({
                        'session_id': session['session_id'],
                        'start_timestamp_local': start_local,
                        'start_timestamp_sync': start_sync,
                        'end_timestamp_local': end_local,
                        'end_timestamp_sync': end_sync,
                        'duration_seconds_local': session.get('duration_seconds', 0),
                        'duration_seconds_sync': session.get('sync_duration_seconds', 0),
                        'duration_formatted': session.get('duration_formatted', ''),
                        'start_trigger': session['start_trigger_type'],
                        'end_trigger': session.get('end_trigger_type', ''),
                        'start_position_x': start_pos[0],
                        'start_position_y': start_pos[1],
                        'stop_position_x': stop_pos[0],
                        'stop_position_y': stop_pos[1],
                        'total_udp_events': session['total_udp_events'],
                        'sync_offset_start_ms': session.get('sync_offset_at_start_ms', 0),
                        'sync_offset_end_ms': session.get('sync_offset_at_end_ms', 0),
                        'sync_accuracy_start_ms': session.get('sync_accuracy_at_start_ms', 0),
                        'sync_accuracy_end_ms': session.get('sync_accuracy_at_end_ms', 0)
                    })

            messagebox.showinfo("Export Complete", f"Enhanced CSV with sync data exported to:\n{filepath}")
            print(f" Enhanced CSV export completed: {filepath}")

        except Exception as e:
            messagebox.showerror("Export Error", f"Failed to export CSV sessions: {str(e)}")

    def export_session_logs_txt(self):
        """Export all session logs to TXT format with sync data"""
        if not self.session_logs:
            messagebox.showinfo("No Data", "No sessions to export!")
            return

        try:
            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')  # FIXED
            filename = f"spinview_click_sessions_with_sync_export_{timestamp}.txt"
            filepath = shared_logger.get_log_file_path('export', filename)

            with open(filepath, 'w', encoding='utf-8') as txtfile:
                txtfile.write("SPINVIEW CLICK TIMER SESSION SUMMARY WITH CLOCK SYNC\n")
                txtfile.write("=" * 60 + "\n")
                txtfile.write(f"Export Date: {datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]}\n")
                txtfile.write(f"Total Sessions: {len(self.session_logs)}\n")
                txtfile.write(f"UDP Events Received: {self.events_received}\n")
                txtfile.write(f"Forwarder IP: {self.forwarder_ip}\n")
                txtfile.write(f"Clock Sync Status: {self.sync_manager.format_sync_status()}\n\n")

                # Calculate summary statistics
                total_duration_local = sum(s.get('duration_seconds', 0) for s in self.session_logs)
                total_duration_sync = sum(s.get('sync_duration_seconds', 0) for s in self.session_logs)
                avg_duration_local = total_duration_local / len(self.session_logs) if self.session_logs else 0
                avg_duration_sync = total_duration_sync / len(self.session_logs) if self.session_logs else 0

                txtfile.write(f"Summary Statistics:\n")
                txtfile.write(f"  Total Recording Time (Local): {self.format_duration(total_duration_local)}\n")
                txtfile.write(f"  Total Recording Time (Sync):  {self.format_duration(total_duration_sync)}\n")
                txtfile.write(f"  Average Session Duration (Local): {self.format_duration(avg_duration_local)}\n")
                txtfile.write(f"  Average Session Duration (Sync):  {self.format_duration(avg_duration_sync)}\n")
                txtfile.write(f"  Log Directory: {self.log_directory}\n\n")

                txtfile.write("DETAILED SESSION LIST WITH CLOCK SYNC:\n")
                txtfile.write("=" * 60 + "\n")

                for session in self.session_logs:
                    start_pos = session['click_positions']['start_position'] or (0, 0)
                    stop_pos = session['click_positions']['stop_position'] or (0, 0)

                    # Enhanced timestamps with sync
                    start_local = datetime.fromtimestamp(session['start_local_timestamp']).strftime(
                        '%Y-%m-%d %H:%M:%S.%f')[:-3]
                    start_sync = datetime.fromtimestamp(session['start_sync_timestamp']).strftime(
                        '%Y-%m-%d %H:%M:%S.%f')[:-3]
                    end_local = datetime.fromtimestamp(session['end_local_timestamp']).strftime(
                        '%Y-%m-%d %H:%M:%S.%f')[:-3]
                    end_sync = datetime.fromtimestamp(session['end_sync_timestamp']).strftime(
                        '%Y-%m-%d %H:%M:%S.%f')[:-3]

                    txtfile.write(f"Session #{session['session_id']}:\n")
                    txtfile.write(f"   START (Local): {start_local} ({session['start_trigger_type']})\n")
                    txtfile.write(
                        f"   START (Sync):  {start_sync} (offset: {session.get('sync_offset_at_start_ms', 0):+.1f}ms)\n")
                    txtfile.write(f"   END (Local):   {end_local} ({session.get('end_trigger_type', 'N/A')})\n")
                    txtfile.write(
                        f"   END (Sync):    {end_sync} (offset: {session.get('sync_offset_at_end_ms', 0):+.1f}ms)\n")
                    txtfile.write(
                        f"    Duration (Local): {session.get('duration_formatted', 'N/A')} ({session.get('duration_seconds', 0):.3f} seconds)\n")
                    txtfile.write(
                        f"    Duration (Sync):  {session.get('sync_duration_formatted', 'N/A')} ({session.get('sync_duration_seconds', 0):.3f} seconds)\n")
                    txtfile.write(f"    Click Positions: START{start_pos} STOP{stop_pos}\n")
                    txtfile.write(f"   UDP Events: {session['total_udp_events']}\n")
                    txtfile.write(f"   Sync Accuracy: ±{session.get('sync_accuracy_at_start_ms', 0):.1f}ms\n")
                    txtfile.write("-" * 60 + "\n")

            messagebox.showinfo("Export Complete", f"Enhanced TXT with sync data exported to:\n{filepath}")
            print(f" Enhanced TXT export completed: {filepath}")

        except Exception as e:
            messagebox.showerror("Export Error", f"Failed to export TXT sessions: {str(e)}")

    def clear_session_logs(self):
        """Clear all session logs"""
        if not self.session_logs:
            messagebox.showinfo("No Data", "No sessions to clear!")
            return

        result = messagebox.askyesno("Clear Logs",
                                     f"Are you sure you want to clear all {len(self.session_logs)} sessions?\n\n"
                                     "This action cannot be undone. Consider exporting first.")
        if result:
            self.session_logs.clear()
            self.current_session = None
            self.update_session_list()
            self.current_session_label.config(text="No active session", fg="#666")
            messagebox.showinfo("Cleared", "All session logs have been cleared.")

    def show_session_details(self):
        """Show detailed session information with sync data"""
        if not self.session_logs:
            messagebox.showinfo("No Data", "No sessions recorded yet!")
            return

        # Create details window
        details_window = tk.Toplevel(self.root)
        details_window.title("Session Details with Clock Sync")
        details_window.geometry("800x600")
        details_window.configure(bg="#f0f0f0")

        # Session summary
        summary_frame = tk.Frame(details_window, bg="#f0f0f0")
        summary_frame.pack(pady=10, padx=10, fill="x")

        total_sessions = len(self.session_logs)
        total_duration_local = sum(s.get('duration_seconds', 0) for s in self.session_logs)
        total_duration_sync = sum(s.get('sync_duration_seconds', 0) for s in self.session_logs)
        avg_duration_local = total_duration_local / total_sessions if total_sessions > 0 else 0
        avg_duration_sync = total_duration_sync / total_sessions if total_sessions > 0 else 0

        tk.Label(summary_frame, text=" Enhanced Session Summary with Clock Sync",
                 font=("Arial", 14, "bold"), bg="#f0f0f0").pack()

        summary_text = f"""
Total Sessions: {total_sessions}
Total Recording Time (Local): {self.format_duration(total_duration_local)}
Total Recording Time (Sync):  {self.format_duration(total_duration_sync)}
Average Session Duration (Local): {self.format_duration(avg_duration_local)}
Average Session Duration (Sync):  {self.format_duration(avg_duration_sync)}
UDP Events Received: {self.events_received}
Current Clock Sync Status: {self.sync_manager.format_sync_status()}
        """

        tk.Label(summary_frame, text=summary_text,
                 font=("Arial", 10), bg="#f0f0f0", justify="left").pack()

        # Detailed session list
        tk.Label(details_window, text=" Detailed Session List with Sync Data",
                 font=("Arial", 12, "bold"), bg="#f0f0f0").pack(pady=(10, 5))

        # Create text widget with scrollbar for detailed view
        text_frame = tk.Frame(details_window)
        text_frame.pack(pady=5, padx=10, fill="both", expand=True)

        scrollbar = tk.Scrollbar(text_frame)
        scrollbar.pack(side=tk.RIGHT, fill=tk.Y)

        text_widget = tk.Text(text_frame, yscrollcommand=scrollbar.set,
                              font=("Courier", 9), wrap=tk.WORD)
        text_widget.pack(side=tk.LEFT, fill="both", expand=True)
        scrollbar.config(command=text_widget.yview)

        # Populate with enhanced session details
        for session in self.session_logs:
            # Enhanced timestamps with sync
            start_local = datetime.fromtimestamp(session['start_local_timestamp']).strftime(
                '%Y-%m-%d %H:%M:%S.%f')[:-3]
            start_sync = datetime.fromtimestamp(session['start_sync_timestamp']).strftime(
                '%Y-%m-%d %H:%M:%S.%f')[:-3]
            end_local = datetime.fromtimestamp(session['end_local_timestamp']).strftime(
                '%Y-%m-%d %H:%M:%S.%f')[:-3]
            end_sync = datetime.fromtimestamp(session['end_sync_timestamp']).strftime('%Y-%m-%d %H:%M:%S.%f')[
                       :-3]

            session_text = f"""
Session #{session['session_id']} (Enhanced with Clock Sync):
   START (Local): {start_local} ({session['start_trigger_type']})
   START (Sync):  {start_sync} (offset: {session.get('sync_offset_at_start_ms', 0):+.1f}ms)
   END (Local):   {end_local} ({session.get('end_trigger_type', 'N/A')})
   END (Sync):    {end_sync} (offset: {session.get('sync_offset_at_end_ms', 0):+.1f}ms)
    Duration (Local): {session.get('duration_formatted', 'N/A')} ({session.get('duration_seconds', 0):.3f}s)
    Duration (Sync):  {session.get('sync_duration_formatted', 'N/A')} ({session.get('sync_duration_seconds', 0):.3f}s)
    Click Positions: START{session['click_positions']['start_position']} STOP{session['click_positions']['stop_position']}
   UDP Events: {session['total_udp_events']}
   Sync Accuracy: ±{session.get('sync_accuracy_at_start_ms', 0):.1f}ms
{'=' * 80}
"""
            text_widget.insert(tk.END, session_text)

        text_widget.config(state=tk.DISABLED)  # Make read-only

    def start_loop_click(self):
        """Start loop clicking at specified interval"""
        try:
            # Get the selected click type
            click_type = self.loop_click_type_var.get()
            
            # Determine the position to use
            if click_type == "START":
                self.loop_click_position = self.start_click_position
            else:  # STOP
                self.loop_click_position = self.stop_click_position
            
            # Check if position is set
            if not self.loop_click_position:
                messagebox.showerror("Loop Click", f"Please set {click_type} position first!")
                return
            
            # Get and validate interval
            try:
                interval = float(self.loop_interval_var.get())
                if interval <= 0:
                    raise ValueError("Interval must be positive")
            except ValueError as e:
                messagebox.showerror("Loop Click", f"Invalid interval: {str(e)}")
                return
            
            # Store interval and click type
            self.loop_interval = interval
            self.loop_click_type = click_type
            self.loop_click_count = 0
            
            # Reset stop event
            self.loop_stop_event.clear()
            self.loop_enabled = True
            
            # Start worker thread
            self.loop_thread = threading.Thread(target=self._loop_click_worker, daemon=True)
            self.loop_thread.start()
            
            # Update UI
            self.loop_start_button.config(state="disabled")
            self.loop_stop_button.config(state="normal")
            self.loop_status_label.config(text=f"Loop active: {click_type} @ {interval}s interval", fg="#4CAF50")
            
            print(f" Loop click started: {click_type} position every {interval} seconds")
            
        except Exception as e:
            messagebox.showerror("Loop Click Error", str(e))
            print(f" Loop click error: {e}")

    def stop_loop_click(self):
        """Stop the loop clicking"""
        self.loop_enabled = False
        self.loop_stop_event.set()
        
        # Update UI
        self.loop_start_button.config(state="normal")
        self.loop_stop_button.config(state="disabled")
        
        if self.loop_click_count > 0:
            self.loop_status_label.config(text=f"Loop stopped - {self.loop_click_count} clicks executed", fg="#FF9800")
        else:
            self.loop_status_label.config(text="Loop disabled", fg="#666")
        
        print(f" Loop click stopped after {self.loop_click_count} clicks")

    def _loop_click_worker(self):
        """Background worker for loop clicking"""
        try:
            while self.loop_enabled and not self.loop_stop_event.is_set():
                try:
                    # Wait for interval or until stop is requested
                    if self.loop_stop_event.wait(timeout=self.loop_interval):
                        # Stop event was set, exit
                        break
                    
                    # Perform the click
                    if self.loop_click_position:
                        pre_click_time = time.time()
                        
                        # Execute click
                        pyautogui.click(self.loop_click_position[0], self.loop_click_position[1])
                        
                        post_click_time = time.time()
                        click_duration = (post_click_time - pre_click_time) * 1000  # ms
                        
                        self.loop_click_count += 1
                        
                        # Log click with sync information
                        sync_offset = self.sync_manager.time_offset * 1000 if hasattr(self, 'sync_manager') else 0
                        
                        # Update status label with current count
                        self.root.after(0, lambda: self.loop_status_label.config(
                            text=f"Loop running: {self.loop_click_count} clicks | {click_duration:.2f}ms | sync: {sync_offset:+.1f}ms",
                            fg="#4CAF50"
                        ))
                        
                        print(f" Loop click #{self.loop_click_count}: {self.loop_click_type} @ {self.loop_click_position} ({click_duration:.2f}ms, sync offset: {sync_offset:+.1f}ms)")
                    
                except Exception as e:
                    print(f" Loop click error on iteration {self.loop_click_count + 1}: {e}")
                    # Continue looping despite errors
                    continue
                    
        except Exception as e:
            print(f" Loop worker error: {e}")
        finally:
            # Cleanup
            self.loop_enabled = False
            if self.loop_stop_event:
                self.loop_stop_event.set()

    def cleanup(self):
        """Cleanup when closing application"""
        # Stop loop if running
        if self.loop_enabled:
            self.stop_loop_click()
        
        # End any active session before closing
        if self.current_session:
            self.end_current_session(trigger_type="APP_CLOSE")

        # Stop clock sync
        if hasattr(self, 'sync_manager'):
            self.sync_manager.stop_sync_service()

        if self.udp_listening:
            self.stop_udp_listening()

    # Add these improved methods to your click_receiver.py file:

    def _update_sync_status_after_force(self):
        """Update status after force sync completes"""
        offset_ms = self.sync_manager.time_offset * 1000
        accuracy_ms = self.sync_manager.sync_accuracy * 1000 if self.sync_manager.sync_accuracy else 0
        measurements = len(self.sync_manager.time_differences)

        if measurements >= 5:
            self.status_label.config(
                text=f" Sync updated: {offset_ms:+.1f}ms offset, ±{accuracy_ms:.1f}ms accuracy ({measurements} measurements)",
                fg="#4CAF50"
            )
            print(f" Force sync completed: {offset_ms:+.1f}ms offset with ±{accuracy_ms:.1f}ms accuracy")

            if abs(offset_ms) > 500:
                print(" Offset still high - check network connection or try multiple force syncs")
        else:
            self.status_label.config(text=" Force sync completed but insufficient measurements", fg="#FF9800")

    def show_advanced_sync_diagnostics(self):
        """Show advanced sync diagnostics window with proper window management"""

        # Check if a diagnostic window is already open
        for window in self.diagnostic_windows[:]:  # Use slice to avoid modification during iteration
            try:
                if window.winfo_exists():
                    # Window exists, bring it to front
                    window.lift()
                    window.focus_force()
                    return
            except tk.TclError:
                # Window was destroyed, remove from list
                self.diagnostic_windows.remove(window)

        # Create new diagnostic window
        diag_window = tk.Toplevel(self.root)
        diag_window.title("Advanced Sync Diagnostics")
        diag_window.geometry("700x500")
        diag_window.configure(bg="#f0f0f0")

        # Add to tracking list
        self.diagnostic_windows.append(diag_window)

        # Handle window closing
        def on_diag_close():
            if diag_window in self.diagnostic_windows:
                self.diagnostic_windows.remove(diag_window)
            diag_window.destroy()

        diag_window.protocol("WM_DELETE_WINDOW", on_diag_close)

        # Title
        tk.Label(diag_window, text=" Advanced Sync Diagnostics",
                 font=("Arial", 14, "bold"), bg="#f0f0f0").pack(pady=10)

        # Diagnostics display
        diag_frame = tk.Frame(diag_window, bg="#f0f0f0")
        diag_frame.pack(pady=10, padx=20, fill="both", expand=True)

        diag_text = tk.Text(diag_frame, font=("Courier", 9), wrap=tk.WORD, height=20)
        scrollbar = tk.Scrollbar(diag_frame, command=diag_text.yview)
        diag_text.config(yscrollcommand=scrollbar.set)

        diag_text.pack(side=tk.LEFT, fill="both", expand=True)
        scrollbar.pack(side=tk.RIGHT, fill=tk.Y)

        # Get detailed diagnostics
        detailed_stats = self.sync_manager.get_detailed_sync_stats()

        # Add network diagnostics
        network_diag = self._get_network_diagnostics()

        # Combine all diagnostics
        full_diagnostics = f"""{detailed_stats}

    {network_diag}

     TROUBLESHOOTING TIPS:
    {'=' * 40}
    If offset is > 1000ms:
      • Check if both computers are on same network
      • Verify IP addresses are correct
      • Try 'Reset Sync Data' and multiple force syncs
      • Check Windows time sync settings

    If offset is 100-1000ms:
      • Network latency may be high
      • Try force sync multiple times
      • Check for network congestion

    If offset is < 100ms:
      • This is good! Normal network jitter

    If sync keeps failing:
      • Check firewall settings (port {self.sync_manager.sync_port})
      • Verify forwarder is running and sync service started
      • Check network connectivity between computers

    RECOMMENDED ACTIONS:
      • For offsets > 500ms: Reset sync data and force sync 3+ times
      • For unstable sync: Check network stability
      • For consistent offset: May be actual clock difference
    """

        diag_text.insert(tk.END, full_diagnostics)
        diag_text.config(state=tk.DISABLED)

        # Action buttons
        button_frame = tk.Frame(diag_window, bg="#f0f0f0")
        button_frame.pack(pady=10, fill="x")

        tk.Button(button_frame, text="️ Reset Sync Data",
                  command=lambda: self._reset_sync_data_with_refresh(diag_text, detailed_stats, network_diag),
                  bg="#FF9800", fg="white", font=("Arial", 10)).pack(side=tk.LEFT, padx=5)

        tk.Button(button_frame, text=" Force Sync x3",
                  command=lambda: self._triple_force_sync_with_refresh(diag_text, detailed_stats, network_diag),
                  bg="#4CAF50", fg="white", font=("Arial", 10)).pack(side=tk.LEFT, padx=5)

        tk.Button(button_frame, text=" Refresh",
                  command=lambda: self._refresh_diagnostics(diag_text),
                  bg="#2196F3", fg="white", font=("Arial", 10)).pack(side=tk.LEFT, padx=5)

        tk.Button(button_frame, text=" Close",
                  command=on_diag_close,
                  bg="#666", fg="white", font=("Arial", 10)).pack(side=tk.RIGHT, padx=5)

    def _get_network_diagnostics(self):
        """Get network-related diagnostics"""
        diag = []
        diag.append(" NETWORK DIAGNOSTICS")
        diag.append("=" * 40)

        # Test network connectivity
        try:
            import socket
            sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
            sock.settimeout(1)

            # Test if we can reach the forwarder
            start_time = time.time()
            result = sock.connect_ex((self.forwarder_ip, self.sync_manager.sync_port))
            ping_time = (time.time() - start_time) * 1000

            if result == 0:
                diag.append(f" Network connectivity: OK ({ping_time:.1f}ms)")
            else:
                diag.append(f" Network connectivity: Failed (error {result})")

            sock.close()
        except Exception as e:
            diag.append(f" Network test failed: {e}")

        # Check sync port status
        diag.append(f"Forwarder IP: {self.forwarder_ip}")
        diag.append(f"Sync Port: {self.sync_manager.sync_port}")
        diag.append(f"Sync Service Running: {'Yes' if self.sync_manager.sync_listening else 'No'}")

        return "\n".join(diag)

    def _reset_sync_data(self):
        """Reset sync data and restart"""
        self.sync_manager.reset_sync_data()
        messagebox.showinfo("Sync Reset", "Sync data has been reset. Try force sync now.")

    def _reset_sync_data_with_refresh(self, text_widget=None, *args):
        """Reset sync data and refresh all displays"""
        self.sync_manager.reset_sync_data()

        # Update all relevant UI elements
        if hasattr(self, 'sync_status_label'):
            self.sync_status_label.config(text=" Sync data reset - ready for fresh measurements")

        # Refresh diagnostic window if provided
        if text_widget:
            self._refresh_diagnostics(text_widget)

        # Show confirmation
        print(" Sync data reset completed")

    def _triple_force_sync_with_refresh(self, text_widget=None, *args):
        """Perform triple force sync and refresh displays"""

        def do_triple_sync():
            for i in range(3):
                print(f" Force sync attempt {i + 1}/3")
                self.sync_manager.force_sync_with_multiple_samples(self.forwarder_ip, samples=10)
                if i < 2:  # Don't sleep after last attempt
                    time.sleep(2)

            # Update UI after completion
            if text_widget:
                self.root.after(1000, lambda: self._refresh_diagnostics(text_widget))

            self.root.after(1000, lambda: print(" Triple force sync completed!"))

        # Run in separate thread to avoid blocking UI
        threading.Thread(target=do_triple_sync, daemon=True).start()

    def _refresh_diagnostics(self, text_widget):
        """Refresh the diagnostics display"""
        text_widget.config(state=tk.NORMAL)
        text_widget.delete(1.0, tk.END)

        # Get fresh diagnostics
        detailed_stats = self.sync_manager.get_detailed_sync_stats()
        network_diag = self._get_network_diagnostics()

        # Update display
        full_diagnostics = f"{detailed_stats}\n\n{network_diag}"
        text_widget.insert(tk.END, full_diagnostics)
        text_widget.config(state=tk.DISABLED)



def main():
    print(" ENHANCED UDP TRIGGERED CLICK TIMER WITH CLOCK SYNC")
    print("=" * 65)
    print("Enhanced version with comprehensive session logging")
    print(" NEW: Clock synchronization with forwarder computer")
    print(" Logs click timing with microsecond precision")
    print(" Measures network transmission delays")
    print(" Auto-saves daily logs with sync data")
    print()

    # Check if mouse.ico exists
    if os.path.exists("mouse.ico"):
        print(" Icon: mouse.ico found")
    else:
        print(" mouse.ico not found - using default icon")

    # Check if required packages are available
    try:
        import pyautogui
        from PIL import Image, ImageTk, ImageDraw
    except ImportError as e:
        print(f"Missing package: {e}")
        print("Installing required packages...")
        import subprocess

        if "pyautogui" in str(e):
            subprocess.check_call([sys.executable, "-m", "pip", "install", "pyautogui"])
        if "PIL" in str(e):
            subprocess.check_call([sys.executable, "-m", "pip", "install", "Pillow"])

        # Try imports again
        import pyautogui
        from PIL import Image, ImageTk, ImageDraw

    root = tk.Tk()
    app = UDPTriggeredClickTimerWithLogging(root)

    # Handle window closing
    def on_closing():
        app.cleanup()
        root.destroy()

    root.protocol("WM_DELETE_WINDOW", on_closing)
    root.mainloop()

if __name__ == "__main__":
    main()