leaf-markdown-viewer 1.28.1

use super::App;
use crate::markdown::hash_str;
use crate::picker_width as pw;
use std::time::Instant;

pub(crate) const FLASH_DURATION_MS: u64 = 1500;

#[derive(Clone, Debug, PartialEq, Eq)]
pub(crate) enum EditorFlash {
    Opened(String),
    NoFile,
    EditorNotFound(String),
}

#[derive(Clone, Debug, PartialEq, Eq)]
pub(crate) enum WatchFlash {
    Activated,
    Deactivated,
    Stdin,
    NoFile,
    FileNotFound,
    NotActive,
}

#[derive(Clone, Debug, PartialEq, Eq)]
pub(crate) enum LinkFlash {
    Copied,
    CopyFailed,
}

#[derive(Clone, Debug, PartialEq, Eq)]
pub(crate) enum PathFlash {
    RelativeCopied,
    AbsoluteCopied,
    CopyFailed,
}

#[derive(Clone, Debug, PartialEq, Eq)]
pub(crate) enum CodeBlockFlash {
    Copied,
    CopyFailed,
    NoneVisible,
}

#[derive(Clone, Debug, PartialEq, Eq)]
pub(crate) enum HistoryFlash {
    WriteFailed,
    LengthCapped { was: i32 },
}

impl App {
    pub(crate) fn set_editor_flash(&mut self, flash: EditorFlash) {
        self.editor_flash = Some((flash, Instant::now()));
    }

    pub(crate) fn editor_flash(&self) -> Option<&(EditorFlash, Instant)> {
        self.editor_flash.as_ref()
    }

    pub(crate) fn clear_editor_flash(&mut self) {
        self.editor_flash = None;
    }

    pub(crate) fn toggle_watch(&mut self) {
        let p = match &self.filepath {
            None => {
                self.set_watch_flash(if self.filename == "stdin" {
                    WatchFlash::Stdin
                } else {
                    WatchFlash::NoFile
                });
                return;
            }
            Some(p) => p,
        };
        if !p.exists() {
            self.set_watch_flash(WatchFlash::FileNotFound);
            return;
        }
        self.watch = !self.watch;
        self.set_watch_flash(if self.watch {
            WatchFlash::Activated
        } else {
            WatchFlash::Deactivated
        });
        if self.watch {
            self.last_file_state = None;
            self.last_content_hash = hash_str(&self.source);
            self.last_hash_check = Some(Instant::now());
            self.watch_error = false;
        }
    }

    pub(crate) fn watch_flash(&self) -> Option<(&WatchFlash, &Instant)> {
        self.watch_flash.as_ref().map(|(f, t)| (f, t))
    }

    pub(crate) fn set_watch_flash(&mut self, flash: WatchFlash) {
        self.watch_flash = Some((flash, Instant::now()));
    }

    pub(crate) fn watch_flash_for_no_file(&self) -> WatchFlash {
        if self.filename == "stdin" {
            WatchFlash::Stdin
        } else {
            WatchFlash::NoFile
        }
    }

    pub(crate) fn clear_watch_flash(&mut self) {
        self.watch_flash = None;
    }

    pub(crate) fn set_config_warning(&mut self, warning: Option<String>) {
        if let Some(msg) = warning {
            self.config_flash = Some((msg, Instant::now()));
        }
    }

    pub(crate) fn refresh_picker_width_floor(&mut self, area_width: u16) -> u16 {
        let raw = pw::picker_width_raw(self.file_picker_width, area_width);
        let below_floor = raw < pw::PICKER_WIDTH_FLOOR_CELLS;

        let cap = area_width.saturating_sub(2);
        let floor_has_visible_effect = raw.min(cap) != pw::PICKER_WIDTH_FLOOR_CELLS.min(cap);
        let should_signal = below_floor && floor_has_visible_effect;

        if should_signal && !self.picker_width_floor_active {
            self.set_config_warning(Some(pw::PICKER_WIDTH_FLOOR_WARNING.to_string()));
            self.picker_width_floor_active = true;
        } else if !should_signal {
            self.picker_width_floor_active = false;
        }

        raw.max(pw::PICKER_WIDTH_FLOOR_CELLS)
    }

    pub(crate) fn config_flash(&self) -> Option<(&str, &Instant)> {
        self.config_flash.as_ref().map(|(msg, t)| (msg.as_str(), t))
    }

    pub(crate) fn clear_config_flash(&mut self) {
        self.config_flash = None;
    }

    pub(crate) fn set_link_flash(&mut self, flash: LinkFlash) {
        self.link_flash = Some((flash, Instant::now()));
    }

    pub(crate) fn link_flash(&self) -> Option<(&LinkFlash, &Instant)> {
        self.link_flash.as_ref().map(|(f, t)| (f, t))
    }

    pub(crate) fn clear_link_flash(&mut self) {
        self.link_flash = None;
    }

    pub(crate) fn set_path_flash(&mut self, flash: PathFlash) {
        self.path_flash = Some((flash, Instant::now()));
    }

    pub(crate) fn path_flash(&self) -> Option<&(PathFlash, Instant)> {
        self.path_flash.as_ref()
    }

    pub(crate) fn clear_path_flash(&mut self) {
        self.path_flash = None;
    }

    pub(crate) fn clear_reload_flash(&mut self) {
        self.reload_flash = None;
    }

    pub(crate) fn reload_flash_started(&self) -> Option<Instant> {
        self.reload_flash
    }

    pub(crate) fn set_code_block_flash(&mut self, flash: CodeBlockFlash) {
        self.code_block_flash = Some((flash, Instant::now()));
    }

    pub(crate) fn code_block_flash(&self) -> Option<(&CodeBlockFlash, &Instant)> {
        self.code_block_flash.as_ref().map(|(f, t)| (f, t))
    }

    pub(crate) fn set_history_flash(&mut self, flash: HistoryFlash) {
        self.history_flash = Some((flash, Instant::now()));
    }

    pub(crate) fn history_flash(&self) -> Option<(&HistoryFlash, &Instant)> {
        self.history_flash.as_ref().map(|(f, t)| (f, t))
    }

    pub(crate) fn clear_history_flash(&mut self) {
        self.history_flash = None;
    }
}