# target_simulator/gui/ppi_display.py

"""
A reusable Tkinter widget that displays a Plan Position Indicator (PPI)
using Matplotlib, capable of showing both live targets and trajectory previews,
and comparing simulated vs. real-time data.
"""

import tkinter as tk
from tkinter import ttk
import math
import time
import logging
import numpy as np
import collections
from matplotlib.figure import Figure
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
import matplotlib as mpl
from typing import List, Dict, Optional

from target_simulator.core.models import Target, Waypoint, ManeuverType, NM_TO_FT

# Module-level logger
logger = logging.getLogger(__name__)


class PPIDisplay(ttk.Frame):
    """
    A custom widget for the PPI radar display.
    """

    TRAIL_LENGTH = 100

    def __init__(
        self,
        master,
        max_range_nm: int = 100,
        scan_limit_deg: int = 60,
        trail_length: int = None,
    ):
        """
        Inizializza il widget PPI.

        Ingressi: master (Tk parent), max_range_nm (int), scan_limit_deg (int), trail_length (int|None)
        Uscite: nessuna (side-effect: costruisce widgets e canvas)
        Commento: mantiene gli artist Matplotlib per targets, trails e antenna.
        """
        super().__init__(master)
        self.max_range = max_range_nm
        self.scan_limit_deg = scan_limit_deg
        self.sim_target_artists: List[mpl.artist.Artist] = []
        self.real_target_artists: List[mpl.artist.Artist] = []
        self.sim_trail_artists: List[mpl.artist.Artist] = []
        self.real_trail_artists: List[mpl.artist.Artist] = []
        self.sim_label_artists: List[mpl.artist.Artist] = []
        self.real_label_artists: List[mpl.artist.Artist] = []
        self.trail_length = trail_length or self.TRAIL_LENGTH
        self._trails = {
            "simulated": collections.defaultdict(
                lambda: collections.deque(maxlen=self.trail_length)
            ),
            "real": collections.defaultdict(
                lambda: collections.deque(maxlen=self.trail_length)
            ),
        }
        self.preview_artists: List[mpl.artist.Artist] = []
        self.preview_path_artists: Dict[int, List[mpl.artist.Artist]] = {}

        # Display options
        self.show_sim_points_var = tk.BooleanVar(value=True)
        self.show_real_points_var = tk.BooleanVar(value=True)
        self.show_sim_trail_var = tk.BooleanVar(value=False)
        self.show_real_trail_var = tk.BooleanVar(value=False)
        self.animate_antenna_var = tk.BooleanVar(value=True)
        self.display_mode_var = tk.StringVar(value="North-Up")

        self.canvas = None
        self._ownship_artist: Optional[mpl.patches.Polygon] = None
        self.ownship_heading_deg = 0.0
        self._antenna_line_artist: Optional[mpl.lines.Line2D] = None

        self._create_controls()
        self._create_plot()

        self._real_update_timestamps = collections.deque(maxlen=10000)
        self._last_update_summary_time = time.monotonic()
        self._update_summary_interval_s = 1.0

    def _on_display_options_changed(self, *args):
        """Handler invoked when display options (points/trails) change.

        Clears current target artists and triggers a redraw so the new
        display options are applied immediately.
        """
        self.clear_all_targets()
        if self.canvas:
            self.canvas.draw()

    def _on_display_mode_changed(self, *args):
        """Callback when the display mode (North-Up/Heading-Up) changes."""
        self._update_plot_orientation()
        if self.canvas:
            self.canvas.draw_idle()

    def _create_controls(self):
        """Create the top control panel containing radar controls and legend.

        The panel includes 4 logical sections: Radar, Display Mode, Display
        Options and Legend. Widgets are created and wired to the corresponding
        callbacks and Tk variables.
        """
        top_frame = ttk.Frame(self)
        top_frame.pack(side=tk.TOP, fill=tk.X, padx=5, pady=(5, 2))

        # Section 1: Radar Controls
        radar_frame = ttk.LabelFrame(top_frame, text="Radar", padding=5)
        radar_frame.pack(side=tk.LEFT, padx=(0, 5), fill=tk.Y)

        range_subframe = ttk.Frame(radar_frame)
        range_subframe.pack(anchor="w")
        ttk.Label(range_subframe, text="Range (NM):").pack(side=tk.LEFT)
        all_steps = [10, 20, 40, 80, 100, 160, 240, 320]
        valid_steps = sorted(
            [s for s in all_steps if s <= self.max_range]
            + ([self.max_range] if self.max_range not in all_steps else [])
        )
        self.range_var = tk.IntVar(value=self.max_range)
        self.range_selector = ttk.Combobox(
            range_subframe,
            textvariable=self.range_var,
            values=valid_steps,
            state="readonly",
            width=5,
        )
        self.range_selector.pack(side=tk.LEFT, padx=5)

        ttk.Checkbutton(
            radar_frame,
            text="Animate Antenna",
            variable=self.animate_antenna_var,
            command=self._force_redraw,
        ).pack(anchor="w", pady=(4, 0))

        # Section 2: Display Mode
        mode_frame = ttk.LabelFrame(top_frame, text="Display Mode", padding=5)
        mode_frame.pack(side=tk.LEFT, padx=5, fill=tk.Y)
        ttk.Radiobutton(
            mode_frame,
            text="North-Up",
            variable=self.display_mode_var,
            value="North-Up",
            command=self._on_display_mode_changed,
        ).pack(anchor="w")
        ttk.Radiobutton(
            mode_frame,
            text="Heading-Up",
            variable=self.display_mode_var,
            value="Heading-Up",
            command=self._on_display_mode_changed,
        ).pack(anchor="w")

        # Section 3: Display Options
        options_frame = ttk.LabelFrame(top_frame, text="Display Options", padding=5)
        options_frame.pack(side=tk.LEFT, padx=5, fill=tk.Y)
        ttk.Checkbutton(
            options_frame,
            text="Sim Points",
            variable=self.show_sim_points_var,
            command=self._on_display_options_changed,
        ).grid(row=0, column=0, sticky="w", padx=5)
        ttk.Checkbutton(
            options_frame,
            text="Real Points",
            variable=self.show_real_points_var,
            command=self._on_display_options_changed,
        ).grid(row=0, column=1, sticky="w", padx=5)
        ttk.Checkbutton(
            options_frame,
            text="Sim Trail",
            variable=self.show_sim_trail_var,
            command=self._on_display_options_changed,
        ).grid(row=1, column=0, sticky="w", padx=5)
        ttk.Checkbutton(
            options_frame,
            text="Real Trail",
            variable=self.show_real_trail_var,
            command=self._on_display_options_changed,
        ).grid(row=1, column=1, sticky="w", padx=5)

        # Spacer to push the legend to the right
        spacer = ttk.Frame(top_frame)
        spacer.pack(side=tk.LEFT, expand=True, fill=tk.X)

        # Section 4: Legend
        legend_frame = ttk.LabelFrame(top_frame, text="Legend", padding=5)
        legend_frame.pack(side=tk.LEFT, padx=5, fill=tk.Y)

        # Ownship
        own_sw = tk.Canvas(legend_frame, width=16, height=12, highlightthickness=0)
        own_sw.create_rectangle(0, 0, 16, 12, fill="cyan", outline="black")
        own_sw.grid(row=0, column=0, padx=(0, 4), pady=(0, 2))
        ttk.Label(legend_frame, text="Ownship").grid(row=0, column=1, sticky="w")

        # Simulated
        sim_sw = tk.Canvas(legend_frame, width=16, height=12, highlightthickness=0)
        sim_sw.create_rectangle(0, 0, 16, 12, fill="green", outline="black")
        sim_sw.grid(row=1, column=0, padx=(0, 4), pady=(0, 2))
        ttk.Label(legend_frame, text="Simulated").grid(row=1, column=1, sticky="w")

        # Real
        real_sw = tk.Canvas(legend_frame, width=16, height=12, highlightthickness=0)
        real_sw.create_rectangle(0, 0, 16, 12, fill="red", outline="black")
        real_sw.grid(row=2, column=0, padx=(0, 4))
        ttk.Label(legend_frame, text="Real").grid(row=2, column=1, sticky="w")

    def _force_redraw(self):
        """Request an immediate (idle) redraw of the Matplotlib canvas.

        This is used by UI controls that change visual options to avoid
        blocking synchronous draws.
        """
        if self.canvas:
            self.canvas.draw_idle()

    def _create_plot(self):
        """Create the Matplotlib polar Figure and initial plot artists.

        This sets up axes, gridlines, preview artists, ownship marker and
        antenna/scan line artists used by the rest of the widget.
        """
        fig = Figure(figsize=(5, 5), dpi=100, facecolor="#3E3E3E")
        fig.subplots_adjust(left=0.05, right=0.95, top=0.9, bottom=0.05)
        self.ax = fig.add_subplot(111, projection="polar", facecolor="#2E2E2E")
        self.ax.set_theta_zero_location("N")
        self.ax.set_theta_direction(1)  # Set to CCW explicitly
        self.ax.set_rlabel_position(90)
        self.ax.set_ylim(0, self.range_var.get())

        angles_deg = np.arange(0, 360, 30)
        labels = [f"{(a if a <= 180 else a - 360)}°" for a in angles_deg]
        self.ax.set_thetagrids(angles_deg, labels)

        self.ax.tick_params(axis="x", colors="white", labelsize=8)
        self.ax.tick_params(axis="y", colors="white", labelsize=8)
        self.ax.grid(color="white", linestyle="--", linewidth=0.5, alpha=0.5)
        self.ax.spines["polar"].set_color("white")
        self.ax.set_title("PPI Display", color="white")

        # Define ownship as a patch (triangle) that we can rotate
        self._ownship_artist = mpl.patches.Polygon(
            [[-1, -1]],  # Placeholder
            closed=True,
            facecolor="cyan",
            edgecolor="black",
            zorder=10,
        )
        self.ax.add_patch(self._ownship_artist)

        (self._path_plot,) = self.ax.plot([], [], "g--", linewidth=1.5, zorder=3)
        (self._start_plot,) = self.ax.plot([], [], "go", markersize=8, zorder=3)
        (self._waypoints_plot,) = self.ax.plot(
            [], [], "y+", markersize=10, mew=2, zorder=3
        )
        self.preview_artists = [self._path_plot, self._start_plot, self._waypoints_plot]

        (self._scan_line_1,) = self.ax.plot([], [], "y--", linewidth=1, zorder=1)
        (self._scan_line_2,) = self.ax.plot([], [], "y--", linewidth=1, zorder=1)

        (self._antenna_line_artist,) = self.ax.plot(
            [],
            [],
            color="lightgray",
            linestyle="--",
            linewidth=1.2,
            alpha=0.85,
            zorder=2,
        )
        logger.debug(f"Antenna artist created: {self._antenna_line_artist}")

        self.canvas = FigureCanvasTkAgg(fig, master=self)
        self.canvas.draw()
        self.canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=True)
        self.range_selector.bind("<<ComboboxSelected>>", self._on_range_selected)
        self._update_plot_orientation()  # Initial draw

    def update_ownship_state(self, heading_deg: float):
        """Updates the ownship's visual representation on the PPI."""
        if self.ownship_heading_deg != heading_deg:
            self.ownship_heading_deg = heading_deg
            self._update_plot_orientation()

    def _update_plot_orientation(self):
        """Applies rotation to the plot or ownship icon based on display mode."""
        if not self.ax or not self._ownship_artist:
            return

        mode = self.display_mode_var.get()
        # Convention: Azimuth/Heading is 0=N, positive=CCW (Left)
        # Matplotlib theta is 0=East, positive=CCW.
        # With zero_location="N", theta becomes 0=North, positive=CCW.
        heading_rad = np.deg2rad(self.ownship_heading_deg)
        max_r = self.ax.get_ylim()[1]

        # Define ownship triangle shape in polar coordinates (theta, r)
        r_scale = max_r * 0.04
        nose = (0, r_scale)
        wing_angle = np.deg2rad(140)
        left_wing = (wing_angle, r_scale * 0.8)
        right_wing = (-wing_angle, r_scale * 0.8)

        base_verts_polar = np.array([nose, left_wing, right_wing])

        if mode == "Heading-Up":
            # Rotate the entire grid by the heading angle
            self.ax.set_theta_offset(np.pi / 2 - heading_rad)

            # To make ownship and scan lines appear fixed, we must "counter-rotate"
            # them by drawing them at an angle equal to the heading.
            verts_polar = base_verts_polar.copy()
            verts_polar[:, 0] += heading_rad
            self._ownship_artist.set_xy(verts_polar)

            limit_rad = np.deg2rad(self.scan_limit_deg)
            self._scan_line_1.set_data(
                [heading_rad + limit_rad, heading_rad + limit_rad], [0, max_r]
            )
            self._scan_line_2.set_data(
                [heading_rad - limit_rad, heading_rad - limit_rad], [0, max_r]
            )

        else:  # North-Up
            # Keep grid fixed with North up
            self.ax.set_theta_offset(np.pi / 2)
            # Rotate ownship vertices by adding heading to theta
            verts_polar = base_verts_polar.copy()
            verts_polar[:, 0] += heading_rad
            self._ownship_artist.set_xy(verts_polar)
            # Rotate scan lines by adding heading to theta
            limit_rad = np.deg2rad(self.scan_limit_deg)
            self._scan_line_1.set_data(
                [heading_rad + limit_rad, heading_rad + limit_rad], [0, max_r]
            )
            self._scan_line_2.set_data(
                [heading_rad - limit_rad, heading_rad - limit_rad], [0, max_r]
            )

        if self.canvas:
            self.canvas.draw_idle()

    def clear_all_targets(self):
        """Clears all target artists from the display."""
        all_artists = (
            self.sim_target_artists
            + self.real_target_artists
            + self.sim_trail_artists
            + self.real_trail_artists
            + self.sim_label_artists
            + self.real_label_artists
        )
        for artist in all_artists:
            artist.remove()
        self.sim_target_artists.clear()
        self.real_target_artists.clear()
        self.sim_trail_artists.clear()
        self.real_trail_artists.clear()
        self.sim_label_artists.clear()
        self.real_label_artists.clear()

    def update_simulated_targets(self, targets: List[Target]):
        """Updates and redraws only the simulated targets."""
        self._update_target_category(targets, "simulated")
        if self.canvas:
            self.canvas.draw()

    def update_real_targets(self, targets: List[Target]):
        """Updates and redraws only the real targets."""
        try:
            now = time.monotonic()
            self._real_update_timestamps.append(now)
            if (
                now - self._last_update_summary_time
            ) >= self._update_summary_interval_s:
                self._last_update_summary_time = now
        except Exception:
            pass

        self._update_target_category(targets, "real")
        if self.canvas:
            self.canvas.draw()

    def get_real_update_rate(self, window_seconds: float = 1.0) -> float:
        """
        Returns approximate PPI "real targets" update rate (updates/sec).
        """
        try:
            now = time.monotonic()
            cutoff = now - float(window_seconds)
            count = sum(1 for ts in self._real_update_timestamps if ts >= cutoff)
            return count / float(window_seconds) if window_seconds > 0 else float(count)
        except Exception:
            return 0.0

    def _update_target_category(self, new_data: List[Target], category: str):
        """
        Generic helper to update targets for a specific category ('simulated' or 'real').
        """
        if category == "simulated":
            target_artists, trail_artists, label_artists = (
                self.sim_target_artists,
                self.sim_trail_artists,
                self.sim_label_artists,
            )
            trail_data, show_points, show_trail = (
                self._trails["simulated"],
                self.show_sim_points_var.get(),
                self.show_sim_trail_var.get(),
            )
            color, trail_color = "green", "limegreen"
        else:
            target_artists, trail_artists, label_artists = (
                self.real_target_artists,
                self.real_trail_artists,
                self.real_label_artists,
            )
            trail_data, show_points, show_trail = (
                self._trails["real"],
                self.show_real_points_var.get(),
                self.show_real_trail_var.get(),
            )
            color, trail_color = "red", "tomato"

        for artist in target_artists + trail_artists + label_artists:
            artist.remove()
        target_artists.clear()
        trail_artists.clear()
        label_artists.clear()

        if show_points or show_trail:
            for t in new_data:
                if t.active:
                    pos = (np.deg2rad(t.current_azimuth_deg), t.current_range_nm)
                    trail_data[t.target_id].append(pos)

        if show_points:
            active_targets = [t for t in new_data if t.active]
            if active_targets:
                self._draw_target_visuals(
                    active_targets, color, target_artists, label_artists
                )

            inactive_targets = [t for t in new_data if not t.active]
            if inactive_targets and category == "simulated":
                self._draw_inactive_markers(
                    inactive_targets, color, target_artists, label_artists
                )

        if show_trail:
            self._draw_trails(trail_data, trail_color, trail_artists)

    def _draw_inactive_markers(
        self,
        targets: List[Target],
        color: str,
        artist_list: List,
        label_artist_list: List,
    ):
        for target in targets:
            try:
                r_nm = target.current_range_nm
                theta_rad_plot = np.deg2rad(target.current_azimuth_deg)
                (dot,) = self.ax.plot(
                    theta_rad_plot,
                    r_nm,
                    "o",
                    markersize=6,
                    color=color,
                    alpha=0.6,
                    zorder=5,
                )
                artist_list.append(dot)
                (x_mark,) = self.ax.plot(
                    theta_rad_plot,
                    r_nm,
                    marker="x",
                    color="yellow",
                    markersize=8,
                    markeredgewidth=0.9,
                    linestyle="",
                    zorder=6,
                )
                label_artist_list.append(x_mark)
            except Exception:
                pass

    def _draw_target_visuals(
        self,
        targets: List[Target],
        color: str,
        artist_list: List,
        label_artist_list: List,
    ):
        vector_len_nm = self.range_var.get() / 20.0
        marker_size = 8 if color == "green" else 6

        for target in targets:
            r_nm = target.current_range_nm
            theta_rad_plot = np.deg2rad(target.current_azimuth_deg)

            (dot,) = self.ax.plot(
                theta_rad_plot, r_nm, "o", markersize=marker_size, color=color, zorder=5
            )
            artist_list.append(dot)

            heading_relative_to_north_rad = np.deg2rad(target.current_heading_deg)

            x_start_rel_nm = r_nm * math.sin(theta_rad_plot)
            y_start_rel_nm = r_nm * math.cos(theta_rad_plot)

            dx_nm = vector_len_nm * math.sin(heading_relative_to_north_rad)
            dy_nm = vector_len_nm * math.cos(heading_relative_to_north_rad)

            x_end_rel_nm = x_start_rel_nm + dx_nm
            y_end_rel_nm = y_start_rel_nm + dy_nm

            r_end_nm = math.hypot(x_end_rel_nm, y_end_rel_nm)
            theta_end_rad_plot = math.atan2(x_end_rel_nm, y_end_rel_nm)

            (line,) = self.ax.plot(
                [theta_rad_plot, theta_end_rad_plot],
                [r_nm, r_end_nm],
                color=color,
                linewidth=1.2,
                zorder=4,
            )
            artist_list.append(line)

            txt = self.ax.text(
                theta_rad_plot,
                r_nm + (vector_len_nm * 0.5),
                str(target.target_id),
                color="white",
                fontsize=8,
                ha="center",
                va="bottom",
                zorder=7,
            )
            label_artist_list.append(txt)

    def _draw_trails(self, trail_data: Dict, color: str, artist_list: List):
        for trail in trail_data.values():
            if len(trail) > 1:
                thetas, rs = zip(*trail)
                (line,) = self.ax.plot(
                    thetas,
                    rs,
                    color=color,
                    linestyle="-",
                    linewidth=0.8,
                    alpha=0.7,
                    zorder=3,
                )
                artist_list.append(line)

    def clear_trails(self):
        self._trails["simulated"].clear()
        self._trails["real"].clear()
        self.clear_all_targets()
        if self.canvas:
            self.canvas.draw()

    def _update_scan_lines(self):
        """Update scan/sector indicator lines."""
        self._update_plot_orientation()

    def _on_range_selected(self, event=None):
        """Adjust plot limits when the range selector value changes.

        Ensures scan lines and the canvas are updated to match the new range.
        """
        self.ax.set_ylim(0, self.range_var.get())
        self._update_plot_orientation()
        if self.canvas:
            self.canvas.draw()

    def clear_previews(self):
        """Clear any scenario or trajectory preview artists from the plot."""
        for artist in self.preview_artists:
            artist.set_data([], [])
        for arts in self.preview_path_artists.values():
            for a in arts:
                a.remove()
        self.preview_path_artists.clear()
        if self.canvas:
            self.canvas.draw()

    def draw_scenario_preview(self, scenario):
        self.clear_previews()
        if scenario is None:
            return

        for target in scenario.get_all_targets():
            try:
                path, _ = Target.generate_path_from_waypoints(
                    target.trajectory, target.use_spline
                )
                if not path:
                    continue

                path_thetas, path_rs = [], []
                for point in path:
                    x_ft, y_ft = point[1], point[2]
                    r_ft = math.hypot(x_ft, y_ft)
                    az_rad_plot = math.atan2(x_ft, y_ft)
                    path_rs.append(r_ft / NM_TO_FT)
                    path_thetas.append(az_rad_plot)

                (line_art,) = self.ax.plot(
                    path_thetas,
                    path_rs,
                    color="limegreen",
                    linestyle="--",
                    linewidth=1.2,
                    alpha=0.9,
                )
                (start_art,) = self.ax.plot(
                    [path_thetas[0]], [path_rs[0]], "go", markersize=6
                )
                self.preview_path_artists[target.target_id] = [line_art, start_art]
            except Exception:
                logger.exception(
                    "Failed to draw preview for target %s",
                    getattr(target, "target_id", "?"),
                )

        if self.canvas:
            self.canvas.draw()

    def draw_trajectory_preview(self, waypoints: List[Waypoint], use_spline: bool):
        self.clear_previews()
        self.clear_trails()
        if not waypoints or waypoints[0].maneuver_type != ManeuverType.FLY_TO_POINT:
            return

        path, _ = Target.generate_path_from_waypoints(waypoints, use_spline)
        if not path:
            return

        path_thetas, path_rs = [], []
        for point in path:
            x_ft, y_ft = point[1], point[2]
            r_ft = math.hypot(x_ft, y_ft)
            az_rad_plot = math.atan2(x_ft, y_ft)
            path_rs.append(r_ft / NM_TO_FT)
            path_thetas.append(az_rad_plot)

        self._path_plot.set_data(path_thetas, path_rs)

        wp_thetas, wp_rs = [], []
        for wp in waypoints:
            if wp.maneuver_type == ManeuverType.FLY_TO_POINT:
                r_nm = wp.target_range_nm or 0.0
                az_rad_plot = np.deg2rad(wp.target_azimuth_deg or 0.0)
                wp_rs.append(r_nm)
                wp_thetas.append(az_rad_plot)
        self._waypoints_plot.set_data(wp_thetas, wp_rs)

        start_wp = waypoints[0]
        start_r = start_wp.target_range_nm or 0.0
        start_theta = np.deg2rad(start_wp.target_azimuth_deg or 0.0)
        self._start_plot.set_data([start_theta], [start_r])

        if self.canvas:
            self.canvas.draw()

    def reconfigure_radar(self, max_range_nm: int, scan_limit_deg: int):
        self.max_range, self.scan_limit_deg = max_range_nm, scan_limit_deg
        steps = [10, 20, 40, 80, 100, 160, 240, 320]
        valid_steps = sorted(
            [s for s in steps if s <= max_range_nm]
            + ([max_range_nm] if max_range_nm not in steps else [])
        )
        self.range_selector["values"] = valid_steps
        if self.range_var.get() not in valid_steps:
            self.range_var.set(max_range_nm)
        self._on_range_selected()

    def render_antenna_line(self, az_deg: Optional[float]):
        """Directly renders the antenna line at a given absolute azimuth."""
        try:
            if self._antenna_line_artist is None:
                logger.warning("Antenna artist is not initialized. Cannot render.")
                return

            if az_deg is None or not self.animate_antenna_var.get():
                self._antenna_line_artist.set_visible(False)
            else:
                az_float = float(az_deg)

                final_az_for_plot = az_float
                if self.display_mode_var.get() == "Heading-Up":
                    # The incoming az_deg is absolute. To display it relative to the
                    # ownship (which is fixed at 0 deg), we subtract the ownship heading.
                    final_az_for_plot -= self.ownship_heading_deg

                # Convert final angle to theta for Matplotlib (0=N, positive=CCW)
                theta = np.deg2rad(final_az_for_plot)
                max_r = self.ax.get_ylim()[1]

                # logger.debug(
                #    f"Rendering antenna: az_in={az_deg}, mode={self.display_mode_var.get()}, "
                #    f"own_hdg={self.ownship_heading_deg}, final_az={final_az_for_plot}, theta={theta}"
                # )

                self._antenna_line_artist.set_data([theta, theta], [0, max_r])
                self._antenna_line_artist.set_visible(True)

            if self.canvas:
                self.canvas.draw_idle()
        except Exception:
            logger.exception("Error rendering antenna line")