egui_charts/ui/dialogs/alert_dialog/

dialog.rs

//! Typed alert editing. Hosts supply output identifiers, watchlists and optional preset storage.

use crate::localization as l10n;
use std::collections::BTreeMap;
use std::sync::Arc;

use chrono::{DateTime, Months, NaiveDate, NaiveTime, Offset, TimeZone, Timelike, Utc, Weekday};
use egui::{Context, Ui};

use super::{AlertDialogAction, AlertDialogConfig};
use crate::data::{FeedError, inbox::Inbox};
use crate::model::{
    Alert, AlertChannelComparison, AlertComparison, AlertCondition, AlertFrequency, AlertRule,
    AlertSource, NotificationSchedule, NotificationWindow, TimezoneId,
};
use crate::services::{Storage, StoreKind};
use crate::ui_kit::FormGrid;
use crate::ui_kit::dialog::{DialogFooter, dialog_header};
use crate::ui_kit::modal::Modal;
use crate::ui_kit::status_message::{MessageKind, status_message};

/// A dialog that creates or edits the same alert type the host stores and evaluates.
pub struct AlertDialog {
    /// Layout dimensions.
    pub config: AlertDialogConfig,
    /// Whether the modal is visible.
    pub is_open: bool,
    /// Staged edits. Cancel never submits them.
    pub alert: Alert,
    /// Host-provided study outputs and drawings, as stable identifiers and display names.
    pub sources: Vec<(AlertSource, String)>,
    /// Host-provided watchlist identifiers and display names.
    pub watchlists: Vec<(String, String)>,
    /// The zone the expiry date and time are entered in, UTC by default. Set it before
    /// [`open`](Self::open) or [`edit`](Self::edit), usually to the chart's time zone.
    pub timezone: TimezoneId,
    /// Whether the staged alert expires; without an expiry it stays active until removed.
    expires: bool,
    /// The expiry date as `YYYY-MM-DD` in [`timezone`](Self::timezone).
    expiry_date: String,
    /// The expiry time as `HH:MM` in [`timezone`](Self::timezone).
    expiry_time: String,
    /// Whether the staged alert limits when notifications are delivered.
    scheduled: bool,
    /// The schedule's zone name.
    schedule_zone: String,
    /// The selected weekdays, Monday first.
    schedule_days: [bool; 7],
    /// The windows as `HH:MM` start and end texts.
    schedule_windows: Vec<[String; 2]>,
    preset_name: String,
    presets: BTreeMap<String, Alert>,
    storage: Option<Arc<dyn Storage>>,
    inbox: Arc<Inbox>,
    pending: bool,
    loaded: bool,
    error: Option<String>,
}

impl Default for AlertDialog {
    fn default() -> Self {
        Self::new()
    }
}

impl AlertDialog {
    /// An initially closed dialog, without host catalogs or storage.
    pub fn new() -> Self {
        Self {
            config: AlertDialogConfig::default(),
            is_open: false,
            alert: Alert::new("", AlertCondition::Crossing(0.0)),
            sources: Vec::new(),
            watchlists: Vec::new(),
            timezone: TimezoneId::utc(),
            expires: false,
            expiry_date: String::new(),
            expiry_time: String::new(),
            scheduled: false,
            schedule_zone: String::new(),
            schedule_days: [false; 7],
            schedule_windows: Vec::new(),
            preset_name: String::new(),
            presets: BTreeMap::new(),
            storage: None,
            inbox: Arc::default(),
            pending: false,
            loaded: false,
            error: None,
        }
    }

    /// Load presets from the host storage service. A failed load never permits overwriting it.
    pub fn set_storage(&mut self, storage: Arc<dyn Storage>) {
        self.inbox = Arc::default();
        self.presets.clear();
        self.error = None;
        self.loaded = false;
        self.pending = true;
        storage.load(StoreKind::AlertPresets, "presets", self.inbox.reply(1));
        self.storage = Some(storage);
    }

    /// Open a fresh price alert at the last or hovered price, discarding earlier cancelled edits.
    pub fn open(&mut self, symbol: String, price: f64) {
        self.edit(Alert::new(symbol, AlertCondition::Crossing(price)));
    }

    /// Stage an existing alert, retaining its host identifier and status when saved.
    pub fn edit(&mut self, alert: Alert) {
        if let Some(inputs) = &alert.inputs {
            self.sources = inputs.sources.clone();
        }

        self.expires = alert.expires.is_some();
        self.set_expiry_fields(alert.expires);
        self.set_schedule_fields(alert.schedule.as_deref());
        self.alert = alert;
        self.is_open = true;
    }

    /// Fill the expiry date and time fields with `expiry` in the entry zone, or clear them.
    fn set_expiry_fields(&mut self, expiry: Option<DateTime<Utc>>) {
        let local = expiry.map(|t| t.with_timezone(&self.timezone));
        let format = |pattern| {
            local
                .as_ref()
                .map_or_else(String::new, |t| t.format(pattern).to_string())
        };
        self.expiry_date = format("%Y-%m-%d");
        self.expiry_time = format("%H:%M");
    }

    /// The staged expiry: none without one, otherwise the entered date and time in the entry
    /// zone, which must exist there and lie after `now`.
    fn expiry(&self, now: DateTime<Utc>) -> Result<Option<DateTime<Utc>>, &'static str> {
        if !self.expires {
            return Ok(None);
        }
        let date = NaiveDate::parse_from_str(self.expiry_date.trim(), "%Y-%m-%d")
            .map_err(|_| "Enter the expiry date as YYYY-MM-DD")?;
        let time = NaiveTime::parse_from_str(self.expiry_time.trim(), "%H:%M")
            .map_err(|_| "Enter the expiry time as HH:MM")?;
        // Unchanged fields retain the saved seconds and repeated-hour occurrence. A saved
        // expiry whose local time is past the representable range matches no entry.
        let saved = self.alert.expires.filter(|saved| {
            let offset = saved.with_timezone(&self.timezone).offset().fix();
            saved
                .naive_utc()
                .checked_add_offset(offset)
                .is_some_and(|local| {
                    local.date() == date
                        && local.hour() == time.hour()
                        && local.minute() == time.minute()
                })
        });
        let expiry = if let Some(saved) = saved {
            saved
        } else {
            // A newly entered time repeated when clocks go back uses its first occurrence.
            self.timezone
                .from_local_datetime(&date.and_time(time))
                .earliest()
                .ok_or("The expiry time is skipped when clocks go forward")?
                .with_timezone(&Utc)
        };
        if expiry <= now {
            return Err("Choose an expiry after the current time");
        }
        Ok(Some(expiry))
    }

    /// Fill the schedule fields with `schedule`, or clear them.
    fn set_schedule_fields(&mut self, schedule: Option<&NotificationSchedule>) {
        self.scheduled = schedule.is_some();
        self.schedule_zone =
            schedule.map_or_else(|| self.timezone.name().into(), |s| s.timezone.name().into());
        self.schedule_days = std::array::from_fn(|i| {
            schedule.is_some_and(|s| s.days.contains(&Weekday::try_from(i as u8).unwrap()))
        });
        self.schedule_windows = schedule.map_or_else(Vec::new, |s| {
            let text = |t: NaiveTime| t.format("%H:%M").to_string();
            s.windows
                .iter()
                .map(|w| [text(w.start), text(w.end)])
                .collect()
        });
    }

    /// The staged schedule: none when notifications go out at any time, otherwise the entered
    /// zone, weekdays and windows.
    fn schedule(&self) -> Result<Option<NotificationSchedule>, &'static str> {
        if !self.scheduled {
            return Ok(None);
        }
        let timezone = TimezoneId::named(self.schedule_zone.trim())
            .ok_or("Enter a known time zone, such as UTC or America/New_York")?;
        let days: Vec<Weekday> = (0..7u8)
            .filter(|&i| self.schedule_days[usize::from(i)])
            .map(|i| Weekday::try_from(i).unwrap())
            .collect();
        let time = |text: &str| NaiveTime::parse_from_str(text.trim(), "%H:%M");
        let windows = self
            .schedule_windows
            .iter()
            .map(|[start, end]| match (time(start), time(end)) {
                (Ok(start), Ok(end)) => Ok(NotificationWindow { start, end }),
                _ => Err("Enter the window times as HH:MM"),
            })
            .collect::<Result<Vec<_>, _>>()?;
        let schedule = NotificationSchedule {
            timezone,
            days,
            windows,
        };
        if schedule.days.is_empty() {
            Err("Select at least one weekday")
        } else if schedule.windows.is_empty() {
            Err("Add a notification window")
        } else if !schedule.is_valid() {
            Err("A window needs different start and end times")
        } else {
            Ok(Some(schedule))
        }
    }

    /// Dismiss without saving.
    pub fn close(&mut self) {
        self.is_open = false;
    }

    /// Follow an external close flag.
    pub fn sync_open_state(&mut self, should_be_open: bool) {
        if !should_be_open {
            self.close();
        }
    }

    fn poll(&mut self, ctx: &Context) {
        let repaint = ctx.clone();
        self.inbox.set_waker(move || repaint.request_repaint());
        for (key, answer) in self.inbox.drain().answers {
            self.pending = false;
            if key == 1 {
                let result = *answer
                    .downcast::<Result<Option<String>, FeedError>>()
                    .expect("preset load");
                match result {
                    Ok(document) => {
                        let result = document
                            .map(|doc| serde_json::from_str::<PresetDocument>(&doc))
                            .transpose();
                        match result {
                            Ok(doc) if doc.as_ref().is_none_or(|doc| doc.version == 1) => {
                                self.presets = doc.map(|doc| doc.presets).unwrap_or_default();
                                self.loaded = true;
                            }
                            Ok(_) => self.error = Some("Unsupported alert preset version".into()),
                            Err(error) => self.error = Some(error.to_string()),
                        }
                    }
                    Err(error) => self.error = Some(error.to_string()),
                }
            } else if let Err(error) = *answer
                .downcast::<Result<(), FeedError>>()
                .expect("preset save")
            {
                self.error = Some(error.to_string());
            }
        }
    }

    fn save_preset(&mut self) {
        self.presets
            .insert(self.preset_name.trim().into(), self.alert.clone());
        let document = PresetDocument {
            version: 1,
            presets: self.presets.clone(),
        };
        match serde_json::to_string(&document) {
            Ok(document) => {
                if let Some(storage) = &self.storage {
                    self.pending = true;
                    self.error = None;
                    storage.save(
                        StoreKind::AlertPresets,
                        "presets",
                        document,
                        self.inbox.reply(2),
                    );
                }
            }
            Err(error) => self.error = Some(error.to_string()),
        }
    }

    /// Poll preset replies and render the modal. Submit `Create` through the host alerts service.
    pub fn show(&mut self, ctx: &Context) -> AlertDialogAction {
        self.poll(ctx);
        if !self.is_open {
            return AlertDialogAction::None;
        }
        let mut action = AlertDialogAction::None;
        let title = if self.alert.id.is_some() {
            "Edit Alert"
        } else {
            "Create Alert"
        };
        let mut open = true;
        Modal::new("create_alert", "")
            .width(self.config.width + 32.0)
            .height(self.config.height + 130.0)
            .show(ctx, &mut open, |ui| {
                let translated_label = l10n::text(ui.ctx(), title);
                ui.response().widget_info(|| {
                    egui::WidgetInfo::labeled(egui::Role::Dialog, true, &translated_label)
                });
                ui.ctx()
                    .accesskit_node_builder(ui.response().id, |node| node.set_modal());
                if dialog_header(ui, title) {
                    self.close();
                    action = AlertDialogAction::Cancel;
                }
                ui.separator();
                let mut expiry = Ok(None);
                let mut schedule = Ok(None);
                let mut valid = false;
                egui::ScrollArea::vertical()
                    .max_height(
                        (ui.available_height() - 65.0)
                            .min(self.config.height)
                            .max(0.0),
                    )
                    .show(ui, |ui| {
                        self.form(ui);
                        expiry = self.expiry(Utc::now());
                        schedule = self.schedule();
                        valid = self.alert.is_valid() && expiry.is_ok() && schedule.is_ok();
                        if !self.alert.is_valid() {
                            status_message(
                                ui,
                                MessageKind::Error,
                                "Check the subject, levels and lookback",
                            );
                        }
                        if let Err(error) = expiry {
                            status_message(ui, MessageKind::Error, error);
                        }
                        if let Err(error) = schedule {
                            status_message(ui, MessageKind::Error, error);
                        }
                        if let Some(error) = &self.error {
                            status_message(ui, MessageKind::Error, error);
                        }
                    });
                let (save, cancel) = DialogFooter::new("Save alert")
                    .secondary("Cancel")
                    .primary_enabled(valid)
                    .show(ui);
                if cancel {
                    self.close();
                    action = AlertDialogAction::Cancel;
                }
                if save {
                    self.alert.expires = expiry.unwrap();
                    self.alert.schedule = schedule.unwrap().map(Box::new);
                    action = AlertDialogAction::Create(Box::new(self.alert.clone()));
                    self.close();
                }
            });
        if !open {
            self.close();
            action = AlertDialogAction::Cancel;
        }
        action
    }

    fn form(&mut self, ui: &mut Ui) {
        let time_label = l10n::format_text(
            ui.ctx(),
            "Expiry time ({0})",
            &[("0", self.timezone.name().to_owned())],
        );
        let label_width = [l10n::text(ui.ctx(), "Expiry date"), time_label.clone()]
            .into_iter()
            .map(|label| {
                ui.painter()
                    .layout_no_wrap(
                        label,
                        egui::TextStyle::Body.resolve(ui.style()),
                        ui.visuals().text_color(),
                    )
                    .size()
                    .x
            })
            .fold(0.0, f32::max);
        ui.spacing_mut().text_edit_width =
            (ui.available_width() - label_width - ui.spacing().item_spacing.x).max(0.0);
        FormGrid::new("alert_details").show(ui, |ui| {
            ui.label(l10n::text(ui.ctx(), "Name"));
            ui.text_edit_singleline(&mut self.alert.name)
                .accessible_name(l10n::text(ui.ctx(), "Name"));
            ui.end_row();
            ui.label(l10n::text(ui.ctx(), "Symbol"));
            ui.text_edit_singleline(&mut self.alert.symbol)
                .accessible_name(l10n::text(ui.ctx(), "Symbol"));
            ui.end_row();
            ui.label(l10n::text(ui.ctx(), "Watchlist"));
            egui::ComboBox::from_id_salt("alert_watchlist")
                .width(ui.spacing().text_edit_width)
                .truncate()
                .selected_text(l10n::text(
                    ui.ctx(),
                    self.alert
                        .watchlist
                        .as_ref()
                        .and_then(|id| {
                            self.watchlists
                                .iter()
                                .find(|(key, _)| key == id)
                                .map(|(_, name)| name.as_str())
                        })
                        .unwrap_or(self.alert.watchlist.as_deref().unwrap_or("One symbol")),
                ))
                .show_ui(ui, |ui| {
                    ui.selectable_value(
                        &mut self.alert.watchlist,
                        None,
                        l10n::text(ui.ctx(), "One symbol"),
                    );
                    for (id, name) in &self.watchlists {
                        ui.selectable_value(
                            &mut self.alert.watchlist,
                            Some(id.clone()),
                            l10n::text(ui.ctx(), name),
                        );
                    }
                })
                .response
                .accessible_name(l10n::text(ui.ctx(), "Watchlist"));
            ui.end_row();
            ui.label(l10n::text(ui.ctx(), "Frequency"));
            egui::ComboBox::from_id_salt("alert_frequency")
                .selected_text(l10n::text(ui.ctx(), self.alert.frequency.to_string()))
                .show_ui(ui, |ui| {
                    for (value, label) in [
                        (AlertFrequency::Once, "Only once"),
                        (AlertFrequency::EveryTime, "Every time"),
                        (AlertFrequency::OncePerBar, "Once per bar"),
                        (AlertFrequency::OncePerBarClose, "Once per bar close"),
                        (AlertFrequency::OncePerMinute, "Once per minute"),
                    ] {
                        if matches!(self.alert.condition, AlertCondition::StrategyFills(_))
                            && !matches!(value, AlertFrequency::Once | AlertFrequency::EveryTime)
                        {
                            continue;
                        }
                        ui.selectable_value(
                            &mut self.alert.frequency,
                            value,
                            l10n::text(ui.ctx(), label),
                        );
                    }
                })
                .response
                .accessible_name(l10n::text(ui.ctx(), "Frequency"));
            ui.end_row();
            // The widest expiry label's width keeps the fields in place when No expiry toggles.
            ui.scope(|ui| {
                ui.set_min_width(label_width);
                ui.label(l10n::text(ui.ctx(), "Expiry"));
            });
            let mut no_expiry = !self.expires;
            if ui
                .checkbox(&mut no_expiry, l10n::text(ui.ctx(), "No expiry"))
                .changed()
            {
                self.expires = !no_expiry;
                if self.expires && self.expiry_date.is_empty() {
                    // Start a month ahead, to the minute, so an expiry needs no typing.
                    let now = Utc::now();
                    self.set_expiry_fields(now.checked_add_months(Months::new(1)).or(Some(now)));
                }
            }
            ui.end_row();
            if self.expires {
                ui.label(l10n::text(ui.ctx(), "Expiry date"));
                ui.add(
                    egui::TextEdit::singleline(&mut self.expiry_date)
                        .hint_text(l10n::text(ui.ctx(), "YYYY-MM-DD")),
                )
                .accessible_name(l10n::text(ui.ctx(), "Expiry date"));
                ui.end_row();
                ui.label(&time_label);
                ui.add(
                    egui::TextEdit::singleline(&mut self.expiry_time)
                        .hint_text(l10n::text(ui.ctx(), "HH:MM")),
                )
                .accessible_name(time_label);
                ui.end_row();
            }
            ui.label(l10n::text(ui.ctx(), "Notifications"));
            let mut any_time = !self.scheduled;
            if ui
                .checkbox(&mut any_time, l10n::text(ui.ctx(), "Any time"))
                .changed()
            {
                self.scheduled = !any_time;
            }
            ui.end_row();
            if self.scheduled {
                ui.label(l10n::text(ui.ctx(), "Time zone"));
                ui.text_edit_singleline(&mut self.schedule_zone)
                    .accessible_name(l10n::text(ui.ctx(), "Time zone"));
                ui.end_row();
                ui.label(l10n::text(ui.ctx(), "Days"));
                ui.horizontal_wrapped(|ui| {
                    for (selected, day) in self.schedule_days.iter_mut().zip(DAYS) {
                        ui.toggle_value(selected, l10n::text(ui.ctx(), day));
                    }
                });
                ui.end_row();
                ui.label(l10n::text(ui.ctx(), "Windows"));
                ui.vertical(|ui| {
                    let mut remove = None;
                    for (index, [start, end]) in self.schedule_windows.iter_mut().enumerate() {
                        ui.horizontal(|ui| {
                            ui.add(egui::TextEdit::singleline(start).desired_width(48.0))
                                .accessible_name(l10n::text(ui.ctx(), "Window start"));
                            ui.label("-");
                            ui.add(egui::TextEdit::singleline(end).desired_width(48.0))
                                .accessible_name(l10n::text(ui.ctx(), "Window end"));
                            if ui.button(l10n::text(ui.ctx(), "Remove")).clicked() {
                                remove = Some(index);
                            }
                        });
                    }
                    if let Some(index) = remove {
                        self.schedule_windows.remove(index);
                    }
                    if ui.button(l10n::text(ui.ctx(), "Add window")).clicked() {
                        self.schedule_windows.push(["09:00".into(), "17:00".into()]);
                    }
                });
                ui.end_row();
            }
            ui.label(l10n::text(ui.ctx(), "Message"));
            ui.text_edit_multiline(&mut self.alert.message)
                .accessible_name(l10n::text(ui.ctx(), "Message"));
            ui.end_row();
        });
        ui.separator();
        if !matches!(self.alert.condition, AlertCondition::StrategyFills(_)) {
            ui.label(l10n::text(
                ui.ctx(),
                "All conditions must hold on the same bar",
            ));
        }
        ui.push_id("first", |ui| {
            rule_form(
                ui,
                &mut self.alert.source,
                &mut self.alert.condition,
                &self.sources,
            )
        });
        let mut remove = None;
        for (index, rule) in self.alert.additional_conditions.iter_mut().enumerate() {
            ui.push_id(index, |ui| {
                ui.separator();
                rule_form(ui, &mut rule.source, &mut rule.condition, &self.sources);
                if ui
                    .button(l10n::text(ui.ctx(), "Remove condition"))
                    .clicked()
                {
                    remove = Some(index);
                }
            });
        }
        if let Some(index) = remove {
            self.alert.additional_conditions.remove(index);
        }
        if !matches!(self.alert.condition, AlertCondition::StrategyFills(_))
            && ui.button(l10n::text(ui.ctx(), "Add condition")).clicked()
        {
            self.alert.additional_conditions.push(AlertRule {
                source: self.alert.source.clone(),
                condition: self.alert.condition.clone(),
            });
        }
        if self.storage.is_some() {
            ui.separator();
            ui.horizontal_wrapped(|ui| {
                ui.label(l10n::text(ui.ctx(), "Preset"));
                ui.text_edit_singleline(&mut self.preset_name)
                    .accessible_name(l10n::text(ui.ctx(), "Preset"));
                if ui
                    .add_enabled(
                        self.loaded
                            && !self.pending
                            && self.alert.is_valid()
                            && !self.preset_name.trim().is_empty(),
                        egui::Button::new(l10n::text(ui.ctx(), "Save preset")),
                    )
                    .clicked()
                    && let (Ok(expiry), Ok(schedule)) = (self.expiry(Utc::now()), self.schedule())
                {
                    self.alert.expires = expiry;
                    self.alert.schedule = schedule.map(Box::new);
                    self.save_preset();
                }
            });
            let mut apply = None;
            egui::ComboBox::from_id_salt("alert_presets")
                .selected_text(l10n::text(ui.ctx(), "Apply preset"))
                .show_ui(ui, |ui| {
                    for (name, alert) in &self.presets {
                        if ui
                            .selectable_label(false, l10n::text(ui.ctx(), name))
                            .clicked()
                        {
                            apply = Some(alert.clone());
                        }
                    }
                })
                .response
                .accessible_name(l10n::text(ui.ctx(), "Apply preset"));
            if let Some(mut preset) = apply {
                preset.id.clone_from(&self.alert.id);
                preset.status = self.alert.status;
                self.edit(preset);
            }
        }
    }
}

const DAYS: [&str; 7] = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"];

#[derive(serde::Serialize, serde::Deserialize)]
struct PresetDocument {
    version: u32,
    presets: BTreeMap<String, Alert>,
}

fn source_picker(
    ui: &mut Ui,
    id: &str,
    source: &mut AlertSource,
    sources: &[(AlertSource, String)],
) {
    let label = sources
        .iter()
        .find(|(value, _)| value == source)
        .map(|(_, name)| name.clone())
        .unwrap_or_else(|| format!("{source:?}"));
    egui::ComboBox::from_id_salt(id)
        .width(ui.available_width().min(200.0))
        .truncate()
        .selected_text(l10n::text(ui.ctx(), label))
        .show_ui(ui, |ui| {
            if !id.starts_with("boundary_") {
                ui.selectable_value(source, AlertSource::Price, l10n::text(ui.ctx(), "Price"));
                ui.selectable_value(source, AlertSource::Volume, l10n::text(ui.ctx(), "Volume"));
            }
            for (value, name) in sources {
                ui.selectable_value(source, value.clone(), l10n::text(ui.ctx(), name));
            }
        })
        .response
        .accessible_name(l10n::text(
            ui.ctx(),
            match id {
                "other" => "Comparison source",
                "boundary_a" => "First boundary",
                "boundary_b" => "Second boundary",
                _ => "Source",
            },
        ));
}

fn drawing_id(source: &AlertSource) -> Option<&str> {
    match source {
        AlertSource::Drawing(id) => Some(id.split('#').next().unwrap_or(id)),
        _ => None,
    }
}

/// Seed a channel from the selected drawing, retaining an existing pair verbatim.
fn drawing_channel(
    source: &AlertSource,
    condition: &AlertCondition,
    sources: &[(AlertSource, String)],
) -> Option<AlertCondition> {
    if let AlertCondition::Channel { .. } = condition {
        return Some(condition.clone());
    }
    let selected = match condition {
        AlertCondition::Compare { other, .. } if drawing_id(other).is_some() => Some(other),
        _ if drawing_id(source).is_some() => Some(source),
        _ => sources
            .iter()
            .find(|(s, _)| {
                drawing_id(s).is_some()
                    && sources
                        .iter()
                        .filter(|(other, _)| drawing_id(other) == drawing_id(s))
                        .count()
                        >= 2
            })
            .map(|(s, _)| s),
    }?;
    let mut levels = sources
        .iter()
        .filter(|(s, _)| drawing_id(s) == drawing_id(selected))
        .rev();
    let b = levels.next()?.0.clone();
    let a = levels.next()?.0.clone();
    Some(AlertCondition::Channel {
        boundaries: [a, b],
        comparison: AlertChannelComparison::Entering,
    })
}

pub(crate) fn rule_form(
    ui: &mut Ui,
    source: &mut AlertSource,
    condition: &mut AlertCondition,
    sources: &[(AlertSource, String)],
) {
    ui.add_enabled_ui(
        !matches!(
            condition,
            AlertCondition::VolumeAboveAverage { .. } | AlertCondition::StrategyFills(_)
        ),
        |ui| source_picker(ui, "source", source, sources),
    );
    let level = condition.level().unwrap_or(0.0);
    let channel = drawing_channel(source, condition, sources);
    let choices = [
        (AlertCondition::Crossing(level), "Crossing"),
        (AlertCondition::CrossingUp(level), "Crossing up"),
        (AlertCondition::CrossingDown(level), "Crossing down"),
        (AlertCondition::Above(level), "Greater than"),
        (AlertCondition::Below(level), "Less than"),
        (
            AlertCondition::EnteringChannel {
                lower: level,
                upper: level + 1.0,
            },
            "Entering channel",
        ),
        (
            AlertCondition::ExitingChannel {
                lower: level,
                upper: level + 1.0,
            },
            "Exiting channel",
        ),
        (
            AlertCondition::InsideChannel {
                lower: level,
                upper: level + 1.0,
            },
            "Inside channel",
        ),
        (
            AlertCondition::OutsideChannel {
                lower: level,
                upper: level + 1.0,
            },
            "Outside channel",
        ),
        (
            AlertCondition::MovingBy {
                value: 1.0,
                bars: 1,
            },
            "Moving by value",
        ),
        (
            AlertCondition::MovingByPercent {
                percent: 1.0,
                bars: 1,
            },
            "Moving by percent",
        ),
        (
            AlertCondition::Compare {
                other: AlertSource::Price,
                comparison: AlertComparison::Crossing,
            },
            "Compare outputs",
        ),
        (
            AlertCondition::VolumeAboveAverage {
                multiplier: 2.0,
                bars: 20,
            },
            "Volume above average",
        ),
    ]
    .into_iter()
    .chain(channel.map(|c| (c, "Drawing channel")))
    .collect::<Vec<_>>();
    let selected = choices
        .iter()
        .find(|(c, _)| std::mem::discriminant(c) == std::mem::discriminant(condition))
        .map(|(_, name)| *name)
        .unwrap_or(if matches!(condition, AlertCondition::StrategyFills(_)) {
            "Strategy fills"
        } else {
            "Condition"
        });
    egui::ComboBox::from_id_salt("condition")
        .selected_text(l10n::text(ui.ctx(), selected))
        .show_ui(ui, |ui| {
            for (value, label) in choices {
                if ui
                    .selectable_label(label == selected, l10n::text(ui.ctx(), label))
                    .clicked()
                    && label != selected
                {
                    if matches!(value, AlertCondition::VolumeAboveAverage { .. }) {
                        *source = AlertSource::Volume;
                    }
                    *condition = value;
                }
            }
        })
        .response
        .accessible_name(l10n::text(ui.ctx(), "Condition"));
    ui.horizontal_wrapped(|ui| match condition {
        AlertCondition::StrategyFills(run) => {
            ui.text_edit_singleline(run)
                .accessible_name(l10n::text(ui.ctx(), "Strategy run"));
        }
        AlertCondition::Crossing(v)
        | AlertCondition::CrossingUp(v)
        | AlertCondition::CrossingDown(v)
        | AlertCondition::Above(v)
        | AlertCondition::Below(v) => {
            ui.label(l10n::text(ui.ctx(), "Level"));
            ui.add(egui::DragValue::new(v).speed(0.01))
                .accessible_name(l10n::text(ui.ctx(), "Level"));
        }
        AlertCondition::EnteringChannel { lower, upper }
        | AlertCondition::ExitingChannel { lower, upper }
        | AlertCondition::InsideChannel { lower, upper }
        | AlertCondition::OutsideChannel { lower, upper } => {
            ui.label(l10n::text(ui.ctx(), "Lower / upper"));
            ui.add(egui::DragValue::new(lower))
                .accessible_name(l10n::text(ui.ctx(), "Lower"));
            ui.add(egui::DragValue::new(upper))
                .accessible_name(l10n::text(ui.ctx(), "Upper"));
        }
        AlertCondition::MovingBy { value, bars }
        | AlertCondition::MovingByPercent {
            percent: value,
            bars,
        } => {
            ui.label(l10n::text(ui.ctx(), "Change / bars"));
            ui.add(egui::DragValue::new(value))
                .accessible_name(l10n::text(ui.ctx(), "Change"));
            ui.add(egui::DragValue::new(bars).range(1..=u32::MAX))
                .accessible_name(l10n::text(ui.ctx(), "Bars"));
        }
        AlertCondition::VolumeAboveAverage { multiplier, bars } => {
            ui.label(l10n::text(ui.ctx(), "Multiplier / preceding bars"));
            ui.add(egui::DragValue::new(multiplier).speed(0.1))
                .accessible_name(l10n::text(ui.ctx(), "Multiplier"));
            ui.add(egui::DragValue::new(bars).range(1..=u32::MAX))
                .accessible_name(l10n::text(ui.ctx(), "Bars"));
        }
        AlertCondition::Channel {
            boundaries,
            comparison,
        } => {
            let drawings: Vec<_> = sources
                .iter()
                .filter(|(s, _)| drawing_id(s).is_some())
                .cloned()
                .collect();
            ui.label(l10n::text(ui.ctx(), "Drawing boundaries"));
            source_picker(ui, "boundary_a", &mut boundaries[0], &drawings);
            source_picker(ui, "boundary_b", &mut boundaries[1], &drawings);
            egui::ComboBox::from_id_salt("channel_comparison")
                .selected_text(l10n::text(ui.ctx(), comparison.to_string()))
                .show_ui(ui, |ui| {
                    for value in [
                        AlertChannelComparison::Entering,
                        AlertChannelComparison::Exiting,
                        AlertChannelComparison::Inside,
                        AlertChannelComparison::Outside,
                    ] {
                        ui.selectable_value(
                            comparison,
                            value,
                            l10n::text(ui.ctx(), value.to_string()),
                        );
                    }
                })
                .response
                .accessible_name(l10n::text(ui.ctx(), "Channel condition"));
        }
        AlertCondition::Compare { other, comparison } => {
            source_picker(ui, "other", other, sources);
            egui::ComboBox::from_id_salt("comparison")
                .selected_text(l10n::text(ui.ctx(), comparison.to_string()))
                .show_ui(ui, |ui| {
                    for value in [
                        AlertComparison::Crossing,
                        AlertComparison::CrossingUp,
                        AlertComparison::CrossingDown,
                        AlertComparison::Above,
                        AlertComparison::Below,
                    ] {
                        ui.selectable_value(
                            comparison,
                            value,
                            l10n::text(ui.ctx(), value.to_string()),
                        );
                    }
                })
                .response
                .accessible_name(l10n::text(ui.ctx(), "Comparison"));
        }
    });
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::data::Reply;
    use std::sync::Mutex;

    #[derive(Default)]
    struct Store(Mutex<Option<String>>);
    impl Storage for Store {
        fn list(&self, _: StoreKind, reply: Reply<Vec<String>>) {
            reply.send(Ok(Vec::new()));
        }
        fn load(&self, _: StoreKind, _: &str, reply: Reply<Option<String>>) {
            reply.send(Ok(self.0.lock().unwrap().clone()));
        }
        fn save(&self, _: StoreKind, _: &str, doc: String, reply: Reply<()>) {
            *self.0.lock().unwrap() = Some(doc);
            reply.send(Ok(()));
        }
        fn delete(&self, _: StoreKind, _: &str, reply: Reply<()>) {
            reply.send(Ok(()));
        }
    }

    #[test]
    fn drawing_channel_keeps_selected_boundaries_through_edits() {
        use egui_kittest::{Harness, kittest::Queryable};
        for dark in [false, true] {
            for width in [320.0, 960.0] {
                let drawing = |id: &str| AlertSource::Drawing(id.into());
                let sources = vec![
                    (drawing("a"), "Other line".into()),
                    (drawing("a#1"), "Other boundary".into()),
                    (drawing("b%23saved"), "Median".into()),
                    (drawing("b%23saved#1"), "Upper".into()),
                    (drawing("b%23saved#2"), "Lower".into()),
                ];
                let single = AlertCondition::Compare {
                    other: drawing("b%23saved"),
                    comparison: AlertComparison::Crossing,
                };
                let mut dialog = AlertDialog::new();
                dialog.sources = sources;
                dialog.edit(Alert::new("SAMPLE", single));
                let mut h = Harness::builder()
                    .with_size(egui::vec2(width, 900.0))
                    .build_ui_state(
                        |ui, dialog: &mut AlertDialog| {
                            ui.ctx().set_visuals(if dark {
                                egui::Visuals::dark()
                            } else {
                                egui::Visuals::light()
                            });
                            dialog.form(ui)
                        },
                        dialog,
                    );
                h.run();
                h.get_by_label("Condition").click();
                h.run();
                h.get_by_label("Drawing channel").scroll_to_me();
                h.run();
                h.get_by_label("Drawing channel").click();
                h.run();
                let expected: AlertCondition = serde_json::from_value(serde_json::json!({"Channel": {
                    "boundaries": [{"Drawing":"b%23saved#1"},{"Drawing":"b%23saved#2"}], "comparison":"Entering"
                }})).unwrap();
                assert_eq!(h.state().alert.condition, expected);
                let saved = serde_json::to_string(&h.state().alert).unwrap();
                h.state_mut().edit(serde_json::from_str(&saved).unwrap());
                h.run();
                assert_eq!(h.state().alert.condition, expected);
                for label in ["First boundary", "Second boundary", "Channel condition"] {
                    let rect = h.get_by_label(label).rect();
                    assert!(
                        rect.left() >= 0.0 && rect.right() <= width,
                        "{label}: {rect:?} at {width}"
                    );
                }
            }
        }
    }

    #[test]
    fn form_controls_fill_the_dialog_width_for_each_source() {
        for (source, condition) in [
            (AlertSource::Price, AlertCondition::Above(100.0)),
            (
                AlertSource::Study {
                    id: "study".into(),
                    output: 0,
                },
                AlertCondition::Above(100.0),
            ),
            (AlertSource::Volume, AlertCondition::Above(100.0)),
            (
                AlertSource::Price,
                AlertCondition::StrategyFills("run".into()),
            ),
        ] {
            for width in [360.0, 560.0] {
                let ctx = Context::default();
                let mut dialog = AlertDialog::new();
                dialog.alert = Alert::new("SAMPLE", condition.clone());
                dialog.alert.source = source.clone();
                let mut form_width = 0.0;
                for _ in 0..3 {
                    let output = ctx.run_ui(Default::default(), |ui| {
                        ui.set_width(width);
                        let form = ui.vertical(|ui| dialog.form(ui));
                        form_width = form.response.rect.width();
                    });
                    if matches!(condition, AlertCondition::StrategyFills(_)) {
                        assert!(
                            !output.shapes.iter().any(|shape| matches!(
                                &shape.shape, egui::Shape::Text(text)
                                    if text.galley.text() == "Add condition"
                            )),
                            "fill alerts cannot add bar conditions"
                        );
                    }
                    output.drop_without_applying_deltas();
                }
                assert!(
                    (form_width - width).abs() < 16.0,
                    "{source:?}: {form_width} at {width}"
                );
            }
        }
    }

    #[test]
    fn alert_form_and_actions_fit_narrow_windows_in_both_themes() {
        for (dark, fills) in [(false, false), (true, false), (false, true), (true, true)] {
            let ctx = Context::default();
            ctx.set_visuals(if dark {
                egui::Visuals::dark()
            } else {
                egui::Visuals::light()
            });
            let mut dialog = AlertDialog::new();
            dialog.set_storage(Arc::new(Store::default()));
            dialog.open("SAMPLE".into(), 100.0);
            dialog
                .watchlists
                .push(("list".into(), "A long host watchlist name".repeat(4)));
            dialog.alert.watchlist = Some("list".into());
            dialog.alert.frequency = AlertFrequency::OncePerBarClose;
            dialog.sources.push((
                AlertSource::Drawing("7".into()),
                "A long drawing name".repeat(4),
            ));
            dialog.alert.additional_conditions.push(AlertRule {
                source: AlertSource::Volume,
                condition: AlertCondition::VolumeAboveAverage {
                    multiplier: 2.0,
                    bars: 20,
                },
            });
            dialog.alert.additional_conditions.push(AlertRule {
                source: AlertSource::Price,
                condition: AlertCondition::Compare {
                    other: AlertSource::Drawing("7".into()),
                    comparison: AlertComparison::Crossing,
                },
            });
            dialog.sources.push((
                AlertSource::Drawing("7#1".into()),
                "A long second boundary name".repeat(4),
            ));
            dialog.alert.additional_conditions.push(AlertRule {
                source: AlertSource::Price,
                condition: AlertCondition::Channel {
                    boundaries: [
                        AlertSource::Drawing("7".into()),
                        AlertSource::Drawing("7#1".into()),
                    ],
                    comparison: AlertChannelComparison::Entering,
                },
            });
            if fills {
                dialog.alert = Alert::new("SAMPLE", AlertCondition::StrategyFills("run".into()));
            }
            for size in [
                egui::vec2(1440.0, 900.0),
                egui::vec2(600.0, 360.0),
                egui::vec2(320.0, 450.0),
            ] {
                for invalid in [false, true] {
                    dialog.expires = invalid;
                    dialog.expiry_date = if invalid { "invalid" } else { "" }.into();
                    for frame in 0..3 {
                        let output = ctx.run_ui(
                            egui::RawInput {
                                screen_rect: Some(egui::Rect::from_min_size(
                                    egui::Pos2::ZERO,
                                    size,
                                )),
                                ..Default::default()
                            },
                            |ui| {
                                dialog.show(ui.ctx());
                            },
                        );
                        let save = output.shapes.iter().find_map(|shape| match &shape.shape {
                            egui::Shape::Text(text) if text.galley.text() == "Save alert" => {
                                Some((
                                    shape.clip_rect,
                                    egui::Rect::from_min_size(text.pos, text.galley.size()),
                                ))
                            }
                            _ => None,
                        });
                        let message_visible = output.shapes.iter().any(|shape| matches!(
                            &shape.shape, egui::Shape::Text(text) if text.galley.text() == "Message"
                                && shape.clip_rect.contains_rect(egui::Rect::from_min_size(text.pos, text.galley.size()))
                        ));
                        output.drop_without_applying_deltas();
                        if frame > 0 {
                            if size.y == 900.0 {
                                assert!(message_visible, "the default height fits the message row");
                            }
                            let (clip, button) = save.expect("save action is painted");
                            assert!(
                                clip.contains_rect(button),
                                "save action is clipped: {button:?}"
                            );
                        }
                    }
                    let rect = ctx
                        .memory(|m| m.area_rect(egui::Id::unique("create_alert")))
                        .unwrap();
                    assert!(
                        rect.left() >= 0.0
                            && rect.right() <= size.x
                            && rect.top() >= 0.0
                            && rect.bottom() <= size.y,
                        "dark={dark}, invalid={invalid}, size={size:?}: {rect:?}"
                    );
                }
            }
        }
    }

    #[test]
    fn expiry_fields_resolve_in_the_entry_zone() {
        let at = |y, mo, d, h, mi| Utc.with_ymd_and_hms(y, mo, d, h, mi, 0).unwrap();
        let check = |zone: TimezoneId, fields: Option<(&str, &str)>, expected| {
            let mut dialog = AlertDialog::new();
            dialog.timezone = zone.clone();
            dialog.expires = fields.is_some();
            (dialog.expiry_date, dialog.expiry_time) = fields
                .map(|(date, time)| (date.into(), time.into()))
                .unwrap_or_default();
            let expiry = dialog.expiry(at(2026, 1, 1, 0, 0));
            assert_eq!(expiry, expected, "{} {fields:?}", zone.name());
            // Editing a saved alert shows its expiry in the same fields.
            if let (Ok(Some(saved)), Some(fields)) = (expiry, fields) {
                let mut alert = Alert::new("SAMPLE", AlertCondition::Crossing(1.0));
                alert.expires = Some(saved);
                dialog.edit(alert);
                let shown = (dialog.expiry_date.as_str(), dialog.expiry_time.as_str());
                assert_eq!(shown, fields);
            }
        };
        let check_saved = |zone: TimezoneId, saved, edited: &str, expected| {
            let mut dialog = AlertDialog::new();
            dialog.timezone = zone;
            let mut alert = Alert::new("SAMPLE", AlertCondition::Crossing(1.0));
            alert.expires = Some(saved);
            dialog.edit(alert);
            let now = at(2026, 1, 1, 0, 0);
            assert_eq!(
                dialog.expiry(now),
                Ok(Some(saved)),
                "unchanged fields retain the saved instant"
            );
            dialog.expiry_time = edited.into();
            assert_eq!(
                dialog.expiry(now),
                Ok(Some(expected)),
                "edited fields resolve in the entry zone"
            );
        };
        let utc = TimezoneId::utc;
        check_saved(
            utc(),
            at(2026, 3, 8, 2, 30) + chrono::Duration::milliseconds(12_345),
            "02:31",
            at(2026, 3, 8, 2, 31),
        );
        let east_of_utc = |hours: i32| TimezoneId::fixed_offset(hours * 3600).unwrap();
        for (zone, fields, expected) in [
            (utc(), None, Ok(None)),
            (
                utc(),
                Some(("2026-03-08", "02:30")),
                Ok(Some(at(2026, 3, 8, 2, 30))),
            ),
            (
                east_of_utc(-5),
                Some(("2026-03-08", "02:30")),
                Ok(Some(at(2026, 3, 8, 7, 30))),
            ),
            (
                east_of_utc(9),
                Some(("2026-03-08", "02:30")),
                Ok(Some(at(2026, 3, 7, 17, 30))),
            ),
            (
                utc(),
                Some(("08/03/2026", "02:30")),
                Err("Enter the expiry date as YYYY-MM-DD"),
            ),
            (
                utc(),
                Some(("2026-03-08", "2:30 pm")),
                Err("Enter the expiry time as HH:MM"),
            ),
            (
                utc(),
                Some(("2025-12-31", "23:59")),
                Err("Choose an expiry after the current time"),
            ),
        ] {
            check(zone, fields, expected);
        }
        // A saved expiry at the end of the range has no local time on that side of UTC, so an
        // entered time replaces it.
        for (hours, saved) in [
            (9, DateTime::<Utc>::MAX_UTC),
            (-9, DateTime::<Utc>::MIN_UTC),
        ] {
            let mut dialog = AlertDialog::new();
            dialog.timezone = east_of_utc(hours);
            let mut alert = Alert::new("SAMPLE", AlertCondition::Crossing(1.0));
            alert.expires = Some(saved);
            dialog.edit(alert);
            dialog.expiry_date = "2030-01-01".into();
            dialog.expiry_time = "10:00".into();
            assert_eq!(
                dialog.expiry(at(2026, 1, 1, 0, 0)),
                Ok(Some(at(2030, 1, 1, (10 - hours) as u32, 0)))
            );
        }
        #[cfg(feature = "timezones")]
        {
            let new_york = || TimezoneId::named("America/New_York").unwrap();
            check_saved(
                new_york(),
                at(2026, 11, 1, 6, 30) + chrono::Duration::seconds(17),
                "01:31",
                at(2026, 11, 1, 5, 31),
            );
            // Clocks went from 02:00 to 03:00 on 8 March 2026, and on 1 November 2026 from
            // 02:00 daylight time (UTC-4) back to 01:00 standard time (UTC-5).
            for (fields, expected) in [
                (
                    ("2026-03-08", "02:30"),
                    Err("The expiry time is skipped when clocks go forward"),
                ),
                (("2026-11-01", "01:30"), Ok(Some(at(2026, 11, 1, 5, 30)))),
                (("2026-07-04", "11:45"), Ok(Some(at(2026, 7, 4, 15, 45)))),
            ] {
                check(new_york(), Some(fields), expected);
            }
        }
    }

    #[test]
    fn schedule_fields_resolve_to_a_valid_schedule_or_name_the_problem() {
        let mut dialog = AlertDialog::new();
        assert_eq!(dialog.schedule(), Ok(None));
        dialog.scheduled = true;
        dialog.schedule_zone = "UTC".into();
        assert_eq!(dialog.schedule(), Err("Select at least one weekday"));
        dialog.schedule_days[4] = true;
        assert_eq!(dialog.schedule(), Err("Add a notification window"));
        dialog.schedule_windows = vec![["22:00".into(), "22:00".into()]];
        assert_eq!(
            dialog.schedule(),
            Err("A window needs different start and end times")
        );
        dialog.schedule_windows = vec![["22:00".into(), "2am".into()]];
        assert_eq!(dialog.schedule(), Err("Enter the window times as HH:MM"));
        dialog.schedule_windows = vec![["22:00".into(), "02:00".into()]];
        dialog.schedule_zone = "Mars/Olympus".into();
        assert!(dialog.schedule().is_err());
        dialog.schedule_zone = "UTC".into();
        let schedule = dialog.schedule().unwrap().unwrap();
        assert_eq!(schedule.days, [Weekday::Fri]);
        // Editing a saved alert shows the same fields.
        let mut alert = Alert::new("SAMPLE", AlertCondition::Crossing(1.0));
        alert.schedule = Some(Box::new(schedule.clone()));
        let mut other = AlertDialog::new();
        other.edit(alert);
        assert_eq!(other.schedule(), Ok(Some(schedule)));
    }

    #[test]
    fn presets_survive_a_new_dialog_and_unknown_versions_cannot_be_overwritten() {
        let store = Arc::new(Store::default());
        let ctx = Context::default();
        let mut dialog = AlertDialog::new();
        dialog.set_storage(store.clone());
        dialog.poll(&ctx);
        dialog.open("EURUSD".into(), 1.125);
        dialog.alert.name = "Breakout".into();
        dialog.alert.frequency = AlertFrequency::OncePerBarClose;
        dialog.preset_name = "Close".into();
        dialog.save_preset();
        dialog.poll(&ctx);
        let expected = dialog.alert.clone();
        let mut restored = AlertDialog::new();
        restored.set_storage(store.clone());
        restored.poll(&ctx);
        assert_eq!(restored.presets["Close"], expected);
        *store.0.lock().unwrap() = Some(r#"{"version":2,"presets":{}}"#.into());
        restored.set_storage(store);
        restored.poll(&ctx);
        assert!(!restored.loaded);
        assert!(restored.error.is_some());
        restored.open("AAPL".into(), 123.0);
        assert_eq!(restored.alert.condition, AlertCondition::Crossing(123.0));
        assert!(restored.alert.name.is_empty());
    }
}