use crate::{menu_entry_view, MenuEntryExtraView, MenuEntryViewInfo, MenuInstanceChoose, MenuInstanceView};
use prototty_event_routine::{common_event, event_or_peek_with_handled, EventOrPeek, EventRoutine, Handled};
use prototty_render::{ColModify, Frame, Rgb24, Style, View, ViewContext};
use prototty_text::StringViewSingleLine;
use std::collections::BTreeMap;
use std::marker::PhantomData;
use std::time::Duration;

fn duration_ratio_u8(delta: Duration, period: Duration) -> Result<u8, Duration> {
    if let Some(remaining) = delta.checked_sub(period) {
        Err(remaining)
    } else {
        Ok(((delta.as_micros() * 255) / period.as_micros()) as u8)
    }
}

struct FadeInstance {
    from: Rgb24,
    to: Rgb24,
    started_at_since_epoch: Duration,
    total_duration: Duration,
}

impl FadeInstance {
    fn new(from: Rgb24, to: Rgb24, total_duration: Duration, since_epoch: Duration) -> Self {
        Self {
            from,
            to,
            started_at_since_epoch: since_epoch,
            total_duration,
        }
    }

    fn constant(col: Rgb24) -> Self {
        Self::new(col, col, Duration::from_millis(0), Duration::from_millis(0))
    }

    fn current(&self, since_epoch: Duration) -> Rgb24 {
        if let Some(time_delta) = since_epoch.checked_sub(self.started_at_since_epoch) {
            match duration_ratio_u8(time_delta, self.total_duration) {
                Ok(ratio) => self.from.linear_interpolate(self.to, ratio),
                Err(_) => self.to,
            }
        } else {
            self.from
        }
    }

    fn transform_foreground(&self, style: &fade_spec::Style, since_epoch: Duration) -> Self {
        let from = match style.from.foreground {
            fade_spec::FromCol::Current => self.current(since_epoch),
            fade_spec::FromCol::Rgb24(rgb24) => rgb24,
        };
        Self::new(from, style.to.foreground, style.durations.foreground, since_epoch)
    }

    fn transform_background(&self, style: &fade_spec::Style, since_epoch: Duration) -> Self {
        let from = match style.from.background {
            fade_spec::FromCol::Current => self.current(since_epoch),
            fade_spec::FromCol::Rgb24(rgb24) => rgb24,
        };
        Self::new(from, style.to.background, style.durations.background, since_epoch)
    }
}

#[derive(Clone, Copy)]
enum MenuEntryStatus {
    Selected,
    Normal,
}

struct MenuEntryChange {
    change_to: MenuEntryStatus,
    foreground: FadeInstance,
    background: FadeInstance,
}

pub mod fade_spec {
    pub use prototty_render::Rgb24;
    pub use std::time::Duration;

    pub enum FromCol {
        Current,
        Rgb24(Rgb24),
    }

    pub struct From {
        pub foreground: FromCol,
        pub background: FromCol,
    }
    impl From {
        pub fn current() -> Self {
            Self {
                foreground: FromCol::Current,
                background: FromCol::Current,
            }
        }
    }

    pub struct To {
        pub foreground: Rgb24,
        pub background: Rgb24,
        pub bold: bool,
        pub underline: bool,
    }

    pub struct Durations {
        pub foreground: Duration,
        pub background: Duration,
    }

    pub struct Style {
        pub to: To,
        pub from: From,
        pub durations: Durations,
    }

    pub struct Spec {
        pub selected: Style,
        pub normal: Style,
    }
}

pub struct FadeMenuEntryView<E> {
    last_change: BTreeMap<E, MenuEntryChange>,
    previous_view_since_epoch: Duration,
    spec: fade_spec::Spec,
}

impl<E> FadeMenuEntryView<E>
where
    E: Ord,
{
    pub fn new(spec: fade_spec::Spec) -> Self {
        Self {
            last_change: BTreeMap::new(),
            previous_view_since_epoch: Duration::from_millis(0),
            spec,
        }
    }
    pub fn clear(&mut self) {
        self.last_change.clear();
    }
}

impl<E> MenuEntryExtraView<E> for FadeMenuEntryView<E>
where
    E: Ord + Clone,
    for<'a> &'a E: Into<&'a str>,
{
    type Extra = Duration;
    fn normal<G: Frame, C: ColModify>(
        &mut self,
        entry: &E,
        since_epoch: &Duration,
        context: ViewContext<C>,
        frame: &mut G,
    ) -> MenuEntryViewInfo {
        let spec = &self.spec;
        let current = self
            .last_change
            .entry(entry.clone())
            .or_insert_with(|| MenuEntryChange {
                change_to: MenuEntryStatus::Normal,
                foreground: FadeInstance::constant(spec.normal.to.foreground),
                background: FadeInstance::constant(spec.normal.to.background),
            });
        match current.change_to {
            MenuEntryStatus::Normal => (),
            MenuEntryStatus::Selected => {
                current.change_to = MenuEntryStatus::Normal;
                current.foreground = current.foreground.transform_foreground(&spec.normal, *since_epoch);
                current.background = current.background.transform_background(&spec.normal, *since_epoch);
            }
        }
        let foreground = current.foreground.current(*since_epoch);
        let background = current.background.current(*since_epoch);
        let s: &str = entry.into();
        menu_entry_view(
            s,
            StringViewSingleLine::new(
                Style::new()
                    .with_bold(spec.normal.to.bold)
                    .with_underline(spec.normal.to.underline)
                    .with_foreground(foreground)
                    .with_background(background),
            ),
            context,
            frame,
        )
    }
    fn selected<G: Frame, C: ColModify>(
        &mut self,
        entry: &E,
        since_epoch: &Duration,
        context: ViewContext<C>,
        frame: &mut G,
    ) -> MenuEntryViewInfo {
        let spec = &self.spec;
        let current = self
            .last_change
            .entry(entry.clone())
            .or_insert_with(|| MenuEntryChange {
                change_to: MenuEntryStatus::Selected,
                foreground: FadeInstance::constant(spec.selected.to.foreground),
                background: FadeInstance::constant(spec.selected.to.background),
            });
        match current.change_to {
            MenuEntryStatus::Selected => (),
            MenuEntryStatus::Normal => {
                current.change_to = MenuEntryStatus::Selected;
                current.foreground = current.foreground.transform_foreground(&spec.selected, *since_epoch);
                current.background = current.background.transform_background(&spec.selected, *since_epoch);
            }
        }
        let foreground = current.foreground.current(*since_epoch);
        let background = current.background.current(*since_epoch);
        let s: &str = entry.into();
        menu_entry_view(
            s,
            StringViewSingleLine::new(
                Style::new()
                    .with_bold(spec.selected.to.bold)
                    .with_underline(spec.selected.to.underline)
                    .with_foreground(foreground)
                    .with_background(background),
            ),
            context,
            frame,
        )
    }
}

pub struct FadeMenuInstanceRoutine<C> {
    choose: PhantomData<C>,
    since_epoch: Duration,
}

impl<C> FadeMenuInstanceRoutine<C>
where
    C: MenuInstanceChoose,
{
    pub fn new() -> Self {
        Self {
            choose: PhantomData,
            since_epoch: Duration::from_millis(0),
        }
    }
}

impl<C> Clone for FadeMenuInstanceRoutine<C>
where
    C: MenuInstanceChoose,
{
    fn clone(&self) -> Self {
        Self {
            choose: PhantomData,
            since_epoch: self.since_epoch,
        }
    }
}

impl<C> Copy for FadeMenuInstanceRoutine<C> where C: MenuInstanceChoose {}

impl<C> Default for FadeMenuInstanceRoutine<C>
where
    C: MenuInstanceChoose,
{
    fn default() -> Self {
        Self::new()
    }
}

impl<C> EventRoutine for FadeMenuInstanceRoutine<C>
where
    C: MenuInstanceChoose,
    C::Entry: Ord + Clone,
    for<'a> &'a C::Entry: Into<&'a str>,
{
    type Return = C::Output;
    type Data = C;
    type View = MenuInstanceView<FadeMenuEntryView<C::Entry>>;
    type Event = common_event::CommonEvent;

    fn handle<EP>(self, data: &mut Self::Data, view: &Self::View, event_or_peek: EP) -> Handled<Self::Return, Self>
    where
        EP: EventOrPeek<Event = Self::Event>,
    {
        event_or_peek_with_handled(event_or_peek, self, |s, event| match event {
            common_event::CommonEvent::Input(input) => {
                if let Some(menu_output) = data.choose(view, input) {
                    Handled::Return(menu_output)
                } else {
                    Handled::Continue(s)
                }
            }
            common_event::CommonEvent::Frame(duration) => {
                let Self { choose, since_epoch } = s;
                Handled::Continue(Self {
                    choose,
                    since_epoch: since_epoch + duration,
                })
            }
        })
    }

    fn view<F, CM>(&self, data: &Self::Data, view: &mut Self::View, context: ViewContext<CM>, frame: &mut F)
    where
        F: Frame,
        CM: ColModify,
    {
        if self.since_epoch < view.entry_view.previous_view_since_epoch {
            view.entry_view.clear();
        }
        view.view((data.menu_instance(), &self.since_epoch), context, frame);
        view.entry_view.previous_view_since_epoch = self.since_epoch;
    }
}