"""
PyBusMonitor1553 - Main GUI Window
Tkinter-based interface for MIL-STD-1553 Bus Monitoring
"""
import tkinter as tk
from tkinter import ttk
import threading
import time
from dataclasses import dataclass, field
from typing import Dict, List, Optional, Any
from collections import OrderedDict

from ..lib1553.fields import Field


@dataclass
class MessageStats:
    """Statistics for a single message type"""
    name: str
    cw: str  # Command Word formatted string
    sw: str  # Status Word formatted string
    count: int = 0
    errors: int = 0
    last_update: float = 0.0
    period_ms: float = 0.0
    word_count: int = 0
    is_transmit: bool = False  # True = RT->BC (B-msg), False = BC->RT (A-msg)
    last_data: Optional[Any] = None
    raw_words: List[int] = field(default_factory=list)


class BusMonitorApp:
    """Main application window for PyBusMonitor1553"""
    
    def __init__(self, root: tk.Tk):
        self.root = root
        self.root.title("PyBusMonitor1553 - MIL-STD-1553 Bus Monitor")
        self.root.geometry("1200x800")
        self.root.minsize(800, 600)
        
        # Message statistics storage
        self.message_stats: Dict[str, MessageStats] = OrderedDict()
        self._init_message_stats()
        
        # Selected message for detail view
        self.selected_message: Optional[str] = None
        
        # Connection status
        self.is_connected = False
        self.tx_count = 0
        self.rx_count = 0
        self.last_error = ""
        
        # Build UI
        self._create_menu()
        self._create_main_layout()
        self._create_status_bar()
        
        # Update timer
        self._update_id = None
        
    def _init_message_stats(self):
        """Initialize message statistics for all known message types"""
        # A-messages (BC -> RT, Receive by RT)
        a_messages = [
            ("A1", 1, False, 10),   # Settings
            ("A2", 2, False, 3),    # Operation Command
            ("A3", 3, False, 32),   # Graphics Command
            ("A4", 4, False, 31),   # Navigation Data
            ("A5", 5, False, 23),   # INU/GPS Data
            ("A6", 6, False, 31),   # Weapon Aiming
            ("A7", 7, False, 31),   # Reserved
            ("A8", 8, False, 30),   # Reserved
        ]
        
        # B-messages (RT -> BC, Transmit by RT)
        b_messages = [
            ("B1", 11, True, 29),   # Target Report #1
            ("B2", 12, True, 27),   # Target Report #2
            ("B3", 13, True, 27),   # Target Report #3
            ("B4", 14, True, 27),   # Terrain Avoidance
            ("B5", 15, True, 27),   # Reserved
            ("B6", 16, True, 23),   # Settings Tell-Back
            ("B7", 17, True, 3),    # Status Tell-Back
            ("B8", 18, True, 32),   # Reserved
        ]
        
        for name, sa, is_tx, wc in a_messages + b_messages:
            direction = "T" if is_tx else "R"
            cw_str = f"20-{direction}-{sa}-{wc}"
            self.message_stats[name] = MessageStats(
                name=name,
                cw=cw_str,
                sw="0-0-0",
                word_count=wc,
                is_transmit=is_tx
            )
    
    def _create_menu(self):
        """Create application menu bar"""
        menubar = tk.Menu(self.root)
        self.root.config(menu=menubar)
        
        # File menu
        file_menu = tk.Menu(menubar, tearoff=0)
        menubar.add_cascade(label="File", menu=file_menu)
        file_menu.add_command(label="Connect", command=self._on_connect)
        file_menu.add_command(label="Disconnect", command=self._on_disconnect)
        file_menu.add_separator()
        file_menu.add_command(label="Exit", command=self.root.quit)
        
        # View menu
        view_menu = tk.Menu(menubar, tearoff=0)
        menubar.add_cascade(label="View", menu=view_menu)
        view_menu.add_command(label="Reset Counters", command=self._reset_counters)
        
        # Help menu
        help_menu = tk.Menu(menubar, tearoff=0)
        menubar.add_cascade(label="Help", menu=help_menu)
        help_menu.add_command(label="About", command=self._show_about)
    
    def _create_main_layout(self):
        """Create the main application layout with notebook tabs"""
        # Main container with PanedWindow for resizable split
        self.main_paned = ttk.PanedWindow(self.root, orient=tk.HORIZONTAL)
        self.main_paned.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)
        
        # Left panel - Message list
        left_frame = ttk.Frame(self.main_paned)
        self.main_paned.add(left_frame, weight=1)
        
        # Right panel - Notebook with tabs
        right_frame = ttk.Frame(self.main_paned)
        self.main_paned.add(right_frame, weight=2)
        
        # Create message list (left side)
        self._create_message_list(left_frame)
        
        # Create notebook tabs (right side)
        self._create_notebook(right_frame)
    
    def _create_message_list(self, parent):
        """Create the message list TreeView (like GrifoScope)"""
        # Header
        header = ttk.Label(parent, text="1553 Bus Messages", font=('Helvetica', 11, 'bold'))
        header.pack(pady=(0, 5))
        
        # TreeView with scrollbar
        tree_frame = ttk.Frame(parent)
        tree_frame.pack(fill=tk.BOTH, expand=True)
        
        columns = ('name', 'cw', 'sw', 'count', 'errs', 'period', 'wc')
        self.msg_tree = ttk.Treeview(tree_frame, columns=columns, show='headings', 
                                      selectmode='browse')
        
        # Column headers
        self.msg_tree.heading('name', text='Name')
        self.msg_tree.heading('cw', text='CW')
        self.msg_tree.heading('sw', text='SW')
        self.msg_tree.heading('count', text='Num')
        self.msg_tree.heading('errs', text='Errs')
        self.msg_tree.heading('period', text='Period')
        self.msg_tree.heading('wc', text='WC')
        
        # Column widths
        self.msg_tree.column('name', width=50, anchor='center')
        self.msg_tree.column('cw', width=90, anchor='center')
        self.msg_tree.column('sw', width=70, anchor='center')
        self.msg_tree.column('count', width=60, anchor='center')
        self.msg_tree.column('errs', width=50, anchor='center')
        self.msg_tree.column('period', width=70, anchor='center')
        self.msg_tree.column('wc', width=40, anchor='center')
        
        # Scrollbar
        scrollbar = ttk.Scrollbar(tree_frame, orient=tk.VERTICAL, command=self.msg_tree.yview)
        self.msg_tree.configure(yscrollcommand=scrollbar.set)
        
        self.msg_tree.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
        
        # Bind selection event
        self.msg_tree.bind('<<TreeviewSelect>>', self._on_message_select)
        
        # Configure row tags for coloring
        self.msg_tree.tag_configure('a_msg', background='#E8F4E8')  # Light green for A-msgs
        self.msg_tree.tag_configure('b_msg', background='#E8E8F4')  # Light blue for B-msgs
        self.msg_tree.tag_configure('error', foreground='red')
        
        # Populate initial data
        self._populate_message_list()
    
    def _populate_message_list(self):
        """Populate the message list with initial data"""
        for name, stats in self.message_stats.items():
            tag = 'b_msg' if stats.is_transmit else 'a_msg'
            period_str = f"{stats.period_ms:.1f}" if stats.period_ms > 0 else "-"
            self.msg_tree.insert('', 'end', iid=name, values=(
                name,
                stats.cw,
                stats.sw,
                stats.count,
                stats.errors,
                period_str,
                stats.word_count
            ), tags=(tag,))
    
    def _create_notebook(self, parent):
        """Create the right-side notebook with tabs"""
        self.notebook = ttk.Notebook(parent)
        self.notebook.pack(fill=tk.BOTH, expand=True)
        
        # Tab 1: Message Detail
        self.detail_frame = ttk.Frame(self.notebook)
        self.notebook.add(self.detail_frame, text="Message Detail")
        self._create_detail_tab(self.detail_frame)
        
        # Tab 2: Radar Status Dashboard
        self.dashboard_frame = ttk.Frame(self.notebook)
        self.notebook.add(self.dashboard_frame, text="Radar Status")
        self._create_dashboard_tab(self.dashboard_frame)
        
        # Tab 3: Raw Data
        self.raw_frame = ttk.Frame(self.notebook)
        self.notebook.add(self.raw_frame, text="Raw Data")
        self._create_raw_tab(self.raw_frame)
    
    def _create_detail_tab(self, parent):
        """Create the message detail view tab"""
        # Header with selected message name
        self.detail_header = ttk.Label(parent, text="Select a message to view details", 
                                        font=('Helvetica', 12, 'bold'))
        self.detail_header.pack(pady=10)
        
        # Scrollable frame for fields
        canvas = tk.Canvas(parent)
        scrollbar = ttk.Scrollbar(parent, orient="vertical", command=canvas.yview)
        self.detail_scroll_frame = ttk.Frame(canvas)
        
        self.detail_scroll_frame.bind(
            "<Configure>",
            lambda e: canvas.configure(scrollregion=canvas.bbox("all"))
        )
        
        canvas.create_window((0, 0), window=self.detail_scroll_frame, anchor="nw")
        canvas.configure(yscrollcommand=scrollbar.set)
        
        canvas.pack(side="left", fill="both", expand=True)
        scrollbar.pack(side="right", fill="y")
        
        # Store reference to canvas for updates
        self.detail_canvas = canvas
        
        # Dictionary to hold field labels for updating
        self.detail_field_labels: Dict[str, ttk.Label] = {}
    
    def _create_dashboard_tab(self, parent):
        """Create the radar status dashboard tab"""
        # Title
        title = ttk.Label(parent, text="Radar Status Dashboard", font=('Helvetica', 14, 'bold'))
        title.pack(pady=10)
        
        # Main frame with grid
        dashboard = ttk.Frame(parent)
        dashboard.pack(fill=tk.BOTH, expand=True, padx=20, pady=10)
        
        # Left column - Mode and Status
        left_col = ttk.LabelFrame(dashboard, text="Radar Mode", padding=10)
        left_col.grid(row=0, column=0, padx=10, pady=5, sticky='nsew')
        
        self.dashboard_labels = {}
        
        # Mode indicator
        ttk.Label(left_col, text="Master Mode:").grid(row=0, column=0, sticky='e', padx=5)
        self.dashboard_labels['mode'] = ttk.Label(left_col, text="---", font=('Helvetica', 11, 'bold'))
        self.dashboard_labels['mode'].grid(row=0, column=1, sticky='w', padx=5)
        
        ttk.Label(left_col, text="Standby:").grid(row=1, column=0, sticky='e', padx=5)
        self.dashboard_labels['standby'] = ttk.Label(left_col, text="---")
        self.dashboard_labels['standby'].grid(row=1, column=1, sticky='w', padx=5)
        
        ttk.Label(left_col, text="RF Radiation:").grid(row=2, column=0, sticky='e', padx=5)
        self.dashboard_labels['rf'] = ttk.Label(left_col, text="---")
        self.dashboard_labels['rf'].grid(row=2, column=1, sticky='w', padx=5)
        
        ttk.Label(left_col, text="Transition:").grid(row=3, column=0, sticky='e', padx=5)
        self.dashboard_labels['transition'] = ttk.Label(left_col, text="---")
        self.dashboard_labels['transition'].grid(row=3, column=1, sticky='w', padx=5)
        
        # Right column - Health
        right_col = ttk.LabelFrame(dashboard, text="Health Status", padding=10)
        right_col.grid(row=0, column=1, padx=10, pady=5, sticky='nsew')
        
        health_items = [
            ('radar_failed', 'Radar'),
            ('array_failed', 'Array'),
            ('transmitter_failed', 'Transmitter'),
            ('receiver_failed', 'Receiver'),
            ('processor_failed', 'Processor'),
            ('tx_overtemp', 'TX Overtemp'),
        ]
        
        for i, (key, label) in enumerate(health_items):
            ttk.Label(right_col, text=f"{label}:").grid(row=i, column=0, sticky='e', padx=5)
            self.dashboard_labels[key] = ttk.Label(right_col, text="---", width=8)
            self.dashboard_labels[key].grid(row=i, column=1, sticky='w', padx=5)
        
        # Bottom - Scan Settings
        bottom_col = ttk.LabelFrame(dashboard, text="Scan Parameters", padding=10)
        bottom_col.grid(row=1, column=0, columnspan=2, padx=10, pady=5, sticky='nsew')
        
        scan_items = [
            ('range_scale', 'Range Scale'),
            ('bar_scan', 'Bars'),
            ('azimuth_scan', 'Az Scan'),
        ]
        
        for i, (key, label) in enumerate(scan_items):
            ttk.Label(bottom_col, text=f"{label}:").grid(row=0, column=i*2, sticky='e', padx=5)
            self.dashboard_labels[key] = ttk.Label(bottom_col, text="---", width=10)
            self.dashboard_labels[key].grid(row=0, column=i*2+1, sticky='w', padx=5)
        
        dashboard.columnconfigure(0, weight=1)
        dashboard.columnconfigure(1, weight=1)
    
    def _create_raw_tab(self, parent):
        """Create the raw data view tab"""
        # Text widget for raw hex data
        self.raw_text = tk.Text(parent, font=('Courier', 10), wrap=tk.WORD)
        scrollbar = ttk.Scrollbar(parent, orient=tk.VERTICAL, command=self.raw_text.yview)
        self.raw_text.configure(yscrollcommand=scrollbar.set)
        
        self.raw_text.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
        
        self.raw_text.insert('1.0', "Select a message to view raw data...")
        self.raw_text.configure(state='disabled')
    
    def _create_status_bar(self):
        """Create the status bar at the bottom"""
        status_frame = ttk.Frame(self.root)
        status_frame.pack(side=tk.BOTTOM, fill=tk.X)
        
        # Connection status
        self.status_connection = ttk.Label(status_frame, text="● Disconnected", foreground='red')
        self.status_connection.pack(side=tk.LEFT, padx=10)
        
        # TX/RX counters
        self.status_tx = ttk.Label(status_frame, text="TX: 0")
        self.status_tx.pack(side=tk.LEFT, padx=10)
        
        self.status_rx = ttk.Label(status_frame, text="RX: 0")
        self.status_rx.pack(side=tk.LEFT, padx=10)
        
        # Error display
        self.status_error = ttk.Label(status_frame, text="", foreground='red')
        self.status_error.pack(side=tk.RIGHT, padx=10)
        
        # Separator
        ttk.Separator(self.root, orient=tk.HORIZONTAL).pack(side=tk.BOTTOM, fill=tk.X)
    
    def _on_message_select(self, event):
        """Handle message selection in the tree view"""
        selection = self.msg_tree.selection()
        if selection:
            msg_name = selection[0]
            self.selected_message = msg_name
            self._update_detail_view(msg_name)
            self._update_raw_view(msg_name)
    
    def _update_detail_view(self, msg_name: str):
        """Update the detail view for the selected message"""
        stats = self.message_stats.get(msg_name)
        if not stats:
            return
        
        # Update header
        direction = "RT → BC" if stats.is_transmit else "BC → RT"
        self.detail_header.config(text=f"{msg_name} - {direction}")
        
        # Clear existing fields
        for widget in self.detail_scroll_frame.winfo_children():
            widget.destroy()
        self.detail_field_labels.clear()
        
        # If we have message data, show its fields
        if stats.last_data:
            msg_obj = stats.last_data
            cls = msg_obj.__class__
            
            # Get all Field descriptors
            fields = []
            for name, obj in cls.__dict__.items():
                if isinstance(obj, Field):
                    fields.append((name, obj))
            
            # Sort by word_index then start_bit
            fields.sort(key=lambda x: (x[1].word_index, x[1].start_bit))
            
            # Create field displays
            current_word = -1
            for field_name, field_desc in fields:
                # Add word separator
                if field_desc.word_index != current_word:
                    current_word = field_desc.word_index
                    sep = ttk.Separator(self.detail_scroll_frame, orient=tk.HORIZONTAL)
                    sep.pack(fill=tk.X, pady=2)
                    word_label = ttk.Label(self.detail_scroll_frame, 
                                           text=f"Word {current_word:02d}",
                                           font=('Helvetica', 9, 'bold'))
                    word_label.pack(anchor='w', padx=5)
                
                # Field row
                row_frame = ttk.Frame(self.detail_scroll_frame)
                row_frame.pack(fill=tk.X, padx=10, pady=1)
                
                name_label = ttk.Label(row_frame, text=f"{field_name}:", width=30, anchor='e')
                name_label.pack(side=tk.LEFT)
                
                try:
                    value = getattr(msg_obj, field_name)
                    if isinstance(value, float):
                        val_str = f"{value:.4f}"
                    elif hasattr(value, 'name'):  # Enum
                        val_str = f"{value.name} ({value.value})"
                    else:
                        val_str = str(value)
                except Exception as e:
                    val_str = f"<Error: {e}>"
                
                value_label = ttk.Label(row_frame, text=val_str, width=30, anchor='w')
                value_label.pack(side=tk.LEFT, padx=5)
                
                self.detail_field_labels[field_name] = value_label
        else:
            no_data = ttk.Label(self.detail_scroll_frame, 
                               text="No data received yet for this message",
                               font=('Helvetica', 10, 'italic'))
            no_data.pack(pady=20)
    
    def _update_raw_view(self, msg_name: str):
        """Update the raw data view for the selected message"""
        stats = self.message_stats.get(msg_name)
        if not stats:
            return
        
        self.raw_text.configure(state='normal')
        self.raw_text.delete('1.0', tk.END)
        
        text = f"Message: {msg_name}\n"
        text += f"Command Word: {stats.cw}\n"
        text += f"Status Word: {stats.sw}\n"
        text += f"Word Count: {stats.word_count}\n"
        text += f"Message Count: {stats.count}\n"
        text += f"Errors: {stats.errors}\n\n"
        
        if stats.raw_words:
            text += "Raw Data Words (hex):\n"
            text += "-" * 40 + "\n"
            for i, word in enumerate(stats.raw_words):
                text += f"  Word {i:02d}: 0x{word:04X}  ({word:5d})\n"
        else:
            text += "No raw data available.\n"
        
        self.raw_text.insert('1.0', text)
        self.raw_text.configure(state='disabled')
    
    def _update_dashboard(self, b6_data, b7_data):
        """Update the radar dashboard with B6/B7 data"""
        if b7_data:
            # Mode
            mode = getattr(b7_data, 'master_mode_tb', None)
            if mode:
                self.dashboard_labels['mode'].config(
                    text=mode.name if hasattr(mode, 'name') else str(mode)
                )
            
            # Standby
            stby = getattr(b7_data, 'standby_status', None)
            if stby is not None:
                text = stby.name if hasattr(stby, 'name') else str(stby)
                color = 'orange' if 'ON' in text.upper() else 'green'
                self.dashboard_labels['standby'].config(text=text, foreground=color)
            
            # RF Radiation
            rf = getattr(b7_data, 'rf_radiation_status', None)
            if rf is not None:
                text = rf.name if hasattr(rf, 'name') else str(rf)
                color = 'green' if 'ON' in text.upper() else 'gray'
                self.dashboard_labels['rf'].config(text=text, foreground=color)
            
            # Transition
            trans = getattr(b7_data, 'transition_status', None)
            if trans is not None:
                text = trans.name if hasattr(trans, 'name') else str(trans)
                self.dashboard_labels['transition'].config(text=text)
            
            # Scan parameters
            range_s = getattr(b7_data, 'range_scale_tb', None)
            if range_s:
                self.dashboard_labels['range_scale'].config(
                    text=range_s.name if hasattr(range_s, 'name') else str(range_s)
                )
            
            bar_s = getattr(b7_data, 'bar_scan_tb', None)
            if bar_s:
                self.dashboard_labels['bar_scan'].config(
                    text=bar_s.name if hasattr(bar_s, 'name') else str(bar_s)
                )
            
            az_s = getattr(b7_data, 'azimuth_scan_tb', None)
            if az_s:
                self.dashboard_labels['azimuth_scan'].config(
                    text=az_s.name if hasattr(az_s, 'name') else str(az_s)
                )
        
        if b6_data:
            # Health status from B6
            health_fields = [
                'radar_failed', 'array_failed', 'transmitter_failed',
                'receiver_failed', 'processor_failed', 'tx_overtemp'
            ]
            
            for field in health_fields:
                value = getattr(b6_data, field, None)
                if value is not None:
                    if value == 0:
                        self.dashboard_labels[field].config(text="OK", foreground='green')
                    else:
                        self.dashboard_labels[field].config(text="FAIL", foreground='red')
    
    def update_message_stats(self, msg_name: str, msg_obj, raw_words: List[int] = None):
        """Update statistics for a received message"""
        if msg_name not in self.message_stats:
            return
        
        stats = self.message_stats[msg_name]
        now = time.time()
        
        # Calculate period
        if stats.last_update > 0:
            stats.period_ms = (now - stats.last_update) * 1000
        
        stats.last_update = now
        stats.count += 1
        stats.last_data = msg_obj
        
        if raw_words:
            stats.raw_words = raw_words
        
        # Update tree view
        period_str = f"{stats.period_ms:.1f}" if stats.period_ms > 0 else "-"
        self.msg_tree.item(msg_name, values=(
            msg_name,
            stats.cw,
            stats.sw,
            stats.count,
            stats.errors,
            period_str,
            stats.word_count
        ))
        
        # Update detail view if this message is selected
        if self.selected_message == msg_name:
            self._update_detail_view(msg_name)
            self._update_raw_view(msg_name)
        
        # Update dashboard for B6/B7
        if msg_name == 'B6':
            self._update_dashboard(msg_obj, None)
        elif msg_name == 'B7':
            self._update_dashboard(None, msg_obj)
    
    def update_connection_status(self, connected: bool, tx: int = 0, rx: int = 0, error: str = ""):
        """Update the status bar"""
        self.is_connected = connected
        self.tx_count = tx
        self.rx_count = rx
        self.last_error = error
        
        if connected:
            self.status_connection.config(text="● Connected", foreground='green')
        else:
            self.status_connection.config(text="● Disconnected", foreground='red')
        
        self.status_tx.config(text=f"TX: {tx}")
        self.status_rx.config(text=f"RX: {rx}")
        self.status_error.config(text=error)
    
    def _on_connect(self):
        """Handle connect menu action"""
        # This will be wired up to the actual network handler
        pass
    
    def _on_disconnect(self):
        """Handle disconnect menu action"""
        pass
    
    def _reset_counters(self):
        """Reset all message counters"""
        for name, stats in self.message_stats.items():
            stats.count = 0
            stats.errors = 0
            stats.period_ms = 0.0
            stats.last_update = 0.0
            
            self.msg_tree.item(name, values=(
                name, stats.cw, stats.sw, 0, 0, "-", stats.word_count
            ))
    
    def _show_about(self):
        """Show about dialog"""
        from tkinter import messagebox
        messagebox.showinfo(
            "About PyBusMonitor1553",
            "PyBusMonitor1553\n\n"
            "MIL-STD-1553 Bus Monitor\n"
            "Version 1.0\n\n"
            "Python implementation for GRIFO-F radar interface"
        )


def run_gui():
    """Launch the GUI application"""
    root = tk.Tk()
    app = BusMonitorApp(root)
    return root, app