use crate::*;
//use unicode_width::{UnicodeWidthStr, UnicodeWidthChar};
//use rand::distributions::uniform::UniformSampler;
pub(crate) use ::{
    std::{
        io::{stdout, Write},
        time::Duration,
    },
    ratatui::{
        prelude::{Style, Position, Backend, Color},
        style::{Modifier},
        backend::{CrosstermBackend, ClearType},
        layout::{Size, Rect},
        buffer::{Buffer, Cell},
        crossterm::{
            ExecutableCommand,
            terminal::{EnterAlternateScreen, LeaveAlternateScreen, enable_raw_mode, disable_raw_mode},
            //event::{poll, read, Event, KeyEvent, KeyCode, KeyModifiers, KeyEventKind, KeyEventState},
        }
    },
    crossterm::event::read,
};

mod border; pub use self::border::*;
mod buffer; pub use self::buffer::*;
mod event;  pub use self::event::*;
mod keys;   pub use self::keys::*;
mod modify; pub use self::modify::*;
mod phat;   pub use self::phat::*;
mod repeat; pub use self::repeat::*;
mod scroll; pub use self::scroll::*;

#[macro_export] macro_rules! tui_app {
    ($Struct:ident { $($fields:tt)* }) => {
        #[dizzle::namespace(bool)]
        #[dizzle::namespace(u8)]
        #[dizzle::namespace(u16)]
        #[dizzle::namespace(Option<u16>)]
        #[dizzle::namespace(Color Tui::eval_color_expr)]
        #[derive(Debug, Default)]
        pub struct $Struct { $($fields)* }
        tui_main!($Struct { ..Default::default() });
    }
}

/// Implement standard [main] entrypoint for TUI apps.
#[macro_export] macro_rules! tui_main {
    ($state:expr) => {
        pub fn main () -> Usually<()> {
            tengri::Tui::setup_panic();
            Exit::run(|exit|tengri::Tui::run_main(
                exit,
                ::std::sync::Arc::new(::std::sync::RwLock::new($state))
            ))
        }
    }
}

/// Enable TUI output for state struct.
#[macro_export] macro_rules! tui_view {
    ($self:ident: $State:ty $body:block) => {
        impl tengri::View<Tui> for $State {
            fn view (&$self) -> impl tengri::Draw<tengri::Tui> $body
        }
    }
}

/// Enable TUI keyboard input for main state struct.
#[macro_export] macro_rules! tui_keys {
    ($self:ident:$State:ty,$input:ident $($body:tt)+) => {
        impl dizzle::Apply<TuiEvent, Usually<()>> for $State {
            fn apply (&mut $self, $input: &tengri::TuiEvent) -> Usually<()> $($body)+
        }
    };
}

/// Terminal output.
pub enum Tui {
    /// Draw mode: updates contained [Buffer].
    Draw (
        /// Ratatui buffer; area is screen size
        Buffer,
        /// Current draw area
        XYWH<u16>
    ),
    /// Discard mode: only computes sizes
    Layout (
        /// Draw area; no buffer
        XYWH<u16>
    )
}

impl Screen for Tui {
    type Unit = u16;
    fn area (&self) -> XYWH<Self::Unit> {
        self.into()
    }
    fn size <'a> (
        &mut self, area: impl Into<Option<XYWH<u16>>>, draw: impl Draw<Self>,
    ) -> Drawn<Self::Unit> {
        Self::Layout(self.area()).clip(area, &|to|draw.draw(to))
    }
    fn draw <'a> (
        &mut self, area: impl Into<Option<XYWH<u16>>>, draw: impl Draw<Tui>
    ) -> Drawn<Self::Unit> {
        self.clip(area, &|to|draw.draw(to))
    }
    fn clip <T> (
        &mut self, area: impl Into<Option<XYWH<u16>>>, draw: &impl Fn(&mut Self)->T,
    ) -> T {
        let prev = self.area();
        if let Some(area) = area.into() {
            *self.area_mut() = area.into();
        }
        let result = draw(self);
        *self.area_mut() = prev;
        result
    }
}

impl Tui {
    pub fn setup_panic () {
        use ::std::panic::{set_hook, PanicHookInfo};
        use ::better_panic::{Settings, Verbosity};
        let panic = Settings::auto()
            .verbosity(Verbosity::Full)
            .create_panic_handler();
        set_hook(Box::new(move |info: &PanicHookInfo|{
            let _ = Tui::teardown(&mut stdout());
            panic(info);
        }));
    }
    pub fn run_main <T> (exit: Exit, state: Arc<RwLock<T>>) -> Usually<()> where
        T: Draw<Tui> + Apply<TuiEvent, Usually<()>> + Send + Sync + 'static
    {
        let scan  = Duration::from_millis(100);
        let frame = Duration::from_millis(10);
        let (_input, output) = Tui::io(exit.as_ref(), &state, scan, frame, std::io::stdout())?;
        let _ = output.join();
        Tui::teardown(&mut stdout())
    }
    /// Spawn the TUI input and output threadsl.
    pub fn io <
        T: Draw<Tui> + Apply<TuiEvent, Usually<()>> + Send + Sync + 'static,
        W: Write + Send + Sync + 'static,
    > (
        exited: &Arc<AtomicBool>,
        state:  &Arc<RwLock<T>>,
        poll:   Duration,
        sleep:  Duration,
        output: W,
    ) -> Result<(Task, Task), Box<dyn std::error::Error>> {
        Ok((
            Tui::input(exited, state, poll)?,
            Tui::output(exited, state, sleep, output)?,
        ))
    }
    /// Spawn the TUI input thread which reads keys from the terminal.
    pub fn input <T: Apply<TuiEvent, Usually<()>> + Send + Sync + 'static> (
        exited: &Arc<AtomicBool>, state: &Arc<RwLock<T>>, poll: Duration
    ) -> Result<Task, std::io::Error> {
        let exited = exited.clone();
        let state = state.clone();
        Task::new_poll(Some("tengri input"), exited.clone(), poll, move |_| {
            let event = read().unwrap();
            if Exit::is(&event) {
                exited.store(true, Relaxed);
            } else if let Err(e) = state.write().apply(&TuiEvent(event)) {
                panic!("{e}")
            }
        })
    }
    pub fn teardown <W: Write> (backend: &mut W) -> Usually<()> {
        use ::ratatui::backend::Backend;
        stdout().execute(LeaveAlternateScreen)?;
        CrosstermBackend::new(backend).show_cursor()?;
        disable_raw_mode().map_err(Into::into)
    }
    pub fn new (width: u16, height: u16) -> Self {
        Self::Draw(Buffer::empty(Rect { x: 0, y: 0, width, height }), XYWH(0, 0, width, height))
    }
    pub fn resize <W: Write> (&mut self, back: &mut CrosstermBackend<W>, width: u16, height: u16) {
        let size = Rect { x: 0, y: 0, width, height };
        if let Self::Draw(buffer, ..) = self {
            if buffer.area != size {
                back.clear_region(ClearType::All).unwrap();
                buffer.resize(size);
                buffer.reset();
            }
        }
    }
    pub fn redraw <'b, W: Write> (
        &'b mut self,
        back: &mut CrosstermBackend<W>,
        next: &'b mut Self
    ) {
        if let Self::Draw(prev, ..) = self && let Self::Draw(next, ..) = next {
            let updates = prev.diff(&next);
            back.draw(updates.into_iter()).expect("failed to render");
            Backend::flush(back).expect("failed to flush output new");
            std::mem::swap(prev, next);
            next.reset();
        }
    }
    pub fn update (&mut self, callback: &impl Fn(&mut Cell, u16, u16)) -> XYWH<u16> {
        let XYWH(x0, y0, w, h) = self.area();
        if let Self::Draw(buffer, ..) = self {
            for row in 0..h {
                let y = y0 + row;
                for col in 0..w {
                    let x = x0 + col;
                    if x < buffer.area.width && y < buffer.area.height {
                        if let Some(cell) = buffer.cell_mut(Position { x, y }) {
                            callback(cell, col, row);
                        }
                    }
                }
            }
        }
        self.xywh()
    }
    pub fn blit (&mut self, text: &impl AsRef<str>, x: u16, y: u16, style: Option<Style>) {
        if let Self::Draw(buffer, ..) = self {
            let text = text.as_ref();
            let style = style.unwrap_or(Style::default());
            if x < buffer.area.width && y < buffer.area.height {
                buffer.set_string(x, y, text, style);
            }
        }
    }
    pub fn tint_all (&mut self, fg: Color, bg: Color, modifier: Modifier) {
        if let Self::Draw(buffer, ..) = self {
            for cell in buffer.content.iter_mut() {
                cell.fg = fg;
                cell.bg = bg;
                cell.modifier = modifier;
            }
        }
    }
    /// Spawn the TUI output thread which writes colored characters to the terminal.
    ///
    /// ```
    /// let state = std::sync::Arc::new(std::sync::RwLock::new(()));
    /// let _ = tengri::Exit::run(|exit|{
    ///     tengri::Tui::output(
    ///         exit.as_ref(),
    ///         &state,
    ///         std::time::Duration::from_millis(10),
    ///         std::io::stdout()
    ///     )
    /// });
    /// ```
    pub fn output <
        W: Write + Send + Sync + 'static,
        T: Draw<Tui> + Send + Sync + 'static
    > (
        exited: &Arc<AtomicBool>,
        state:  &Arc<RwLock<T>>,
        sleep:  Duration,
        output: W,
    ) -> Usually<Task> {
        let state = state.clone();
        stdout().execute(EnterAlternateScreen)?;
        CrosstermBackend::new(stdout()).hide_cursor()?;
        enable_raw_mode()?;
        let mut backend = CrosstermBackend::new(output);
        let Size { width, height } = backend.size().expect("get size failed");
        let mut prev = Tui::new(width, height);
        let mut next = Tui::new(width, height);
        Ok(Task::new_sleep(Some("tengri output"), exited.clone(), sleep, move |_perf| {
            let Size { width, height } = backend.size().expect("get size failed");
            if let Some(state) = state.try_read() {
                prev.resize(&mut backend, width, height);
                state.draw(&mut next).expect("draw failed"); // TODO draw error
                prev.redraw(&mut backend, &mut next);
            }
            //let timer = format!("{:>3.3}ms", perf.used.load(Relaxed));
            //prev.blit(&timer, 0, 0, Some(Style::default()));
        })?)
    }
    /// Draw TUI content or its error message.
    ///
    /// ```
    /// for variant in [
    ///     Ok(Some("hello")),
    ///     Ok(None),
    ///     Err("fail".into()),
    /// ] {
    ///     let _ = tengri::Tui::catcher(&variant);
    /// }
    /// ```
    pub fn catcher <'a, T: Draw<Tui>> (result: &Usually<T>) -> impl Draw<Tui> {
        draw(move|to: &mut Tui|match result {
            Ok(content) => content.draw(to),
            Err(e) => {
                let err_fg = Color::Rgb(255,224,244);
                let err_bg = Color::Rgb(96, 24, 24);
                let title  = east(bold(true, "upsi daisy. "), "rendering failed.");
                let error  = east("\"why?\" ", bold(true, format!("{e}")));
                fg(err_fg, bg(err_bg, south(title, error))).draw(to)
            }
        })
    }

    pub fn buffer (&mut self) -> Option<&mut Buffer> {
        if let Tui::Draw(buffer, _) = self {
            Some(buffer)
        } else {
            None
        }
    }

    pub fn set_char (&mut self, x: u16, y: u16, c: char) {
        self.buffer()
            .and_then(|buff|buff.cell_mut(Position { x, y }))
            .map(|cell|cell.set_char(c));
    }

    /// Get mutable reference to current clipping area
    fn area_mut (&mut self) -> &mut XYWH<u16> {
        self.into()
    }
}

//impl Deref         for Tui { type Target = Buffer; fn deref (&self) -> &Buffer { &self.0 } }
//impl DerefMut      for Tui { fn deref_mut (&mut self) -> &mut Buffer { &mut self.0 } }
//impl AsMut<Buffer> for Tui { fn as_mut (&mut self) -> &mut Buffer { &mut self.0 } }
impl AsRef<XYWH<u16>> for Tui {
    fn as_ref (&self) -> &XYWH<u16> {
        match self {
            Self::Draw(_, area) => area,
            Self::Layout(area) => area
        }
    }
}

impl Wide<u16> for Tui {
    fn w (&self) -> u16 { self.as_ref().2 }
}

impl Tall<u16> for Tui {
    fn h (&self) -> u16 { self.as_ref().3 }
}

impl Xy<u16> for Tui {
    fn x (&self) -> u16 { self.as_ref().0 }
    fn y (&self) -> u16 { self.as_ref().1 }
}

impl HasOrigin for Tui {
    fn origin (&self) -> Azimuth { Azimuth::NW }
}

impl From<&Tui> for XYWH<u16> {
    fn from (screen: &Tui) -> XYWH<u16> {
        match screen {
            Tui::Draw(_, area) => *area,
            Tui::Layout(area) => *area,
        }
    }
}

impl<'a: 'b, 'b> From<&'a mut Tui> for &'b mut XYWH<u16> {
    fn from (screen: &'a mut Tui) -> &'b mut XYWH<u16> {
        match screen {
            Tui::Draw(_, area) => area,
            Tui::Layout(area) => area,
        }
    }
}

pub const fn fill_char <'a> (c: char) -> impl Draw<Tui> {
    draw(move|to: &mut Tui|Ok(Some(to.update(&|cell,_,_|{
        cell.set_char(c);
    }))))
}

/// FIXME: Don't use `format!` but implement number blitting
pub struct ShowSize;

impl<'a> Draw<Tui> for ShowSize {
    fn draw (&self, to: &mut Tui) -> Drawn<u16> {
        let area = to.area();
        let info = format!("{area:?}");
        to.text(&info, area.0, area.1, info.len() as u16)
    }
}

pub struct ShowSizeOf<T>(pub T);

impl<'a, T: Draw<Tui>> Draw<Tui> for ShowSizeOf<T> {
    fn draw (&self, to: &mut Tui) -> Drawn<u16> {
        Ok(self.0.draw(to)?.map(|used|{
            let _ = to.text(&format!("{used:?}"), used.0, used.1, u16::MAX);
            used
        }))
    }
}

#[cfg(feature = "eval")] fn_kw_layout_tui!(kw_tui_text |_state, output, expr| {
    Ok(if matches!(expr.head()?, Some("text")) {
        expr.tail()?
            .and_then(|src|(src.len() > 0).then(||(&src[1..]).draw(output)))
            .transpose()?
            .flatten()
    } else {
        None
    })
});

//#[cfg(feature = "text")] pub use self::tui_text::*;
#[cfg(feature = "text")] mod tui_text {
    use super::*;

    impl Tui {
        /// Write a line of text
        ///
        /// TODO: do a paragraph (handle newlines)
        pub fn text (&mut self, text: &impl AsRef<str>, x0: u16, y: u16, max_width: u16)
            -> Perhaps<XYWH<u16>>
        {
            let text = text.as_ref();
            let mut string_width: u16 = 0;
            for character in text.chars() {
                let x = x0 + string_width;
                let character_width = character.width().unwrap_or(0) as u16;
                string_width += character_width;
                if string_width > max_width {
                    break
                }
                if let Self::Draw(buffer, ..) = self {
                    if let Some(cell) = buffer.cell_mut(ratatui::prelude::Position { x, y }) {
                        cell.set_char(character);
                    } else {
                        break
                    }
                }
            }
            Ok(Some(XYWH(x0, y, string_width, 1)))
        }
    }

    impl_draw!(|self: usize, to: Tui|{
        let XYWH(x0, y0, w0, h0) = to.area();
        let mut v = *self;
        let w = (1 + if v > 0 { self.ilog10() } else { 0 }) as u16;
        let h = 1u16;
        Ok((w0 >= w && h0 >= h).then(||{
            if let Tui::Draw(buffer, ..) = to {
                let mut x = x0 + w - 1;
                while x >= x0 {
                    if let Some(cell) = buffer.cell_mut(Position { x, y: y0 }) {
                        cell.set_char([
                            '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'
                        ][(v % 10) as usize]);
                    }
                    x -= 1;
                    v = v / 10;
                }
            }
            XYWH(x0, y0, w, h)
        }))
    });

    impl_draw!(|self: String, to: Tui|{
        self.as_str().draw(to)
    });

    impl_draw!(|self: std::sync::Arc<str>, to: Tui|{
        self.as_ref().draw(to)
    });

    impl_draw!(<T: AsRef<str>,>|self: TrimString<T>, to: Tui|{
        self.as_ref().draw(to)
    });

    impl<'a> Draw<Tui> for &str {
        fn draw (&self, to: &mut Tui) -> Drawn<u16> {
            let XYWH(x, y, w, h) = to.area();
            let mut max_w = 0u16;
            let mut max_h = 0u16;
            for (index, line) in self.split("\n").enumerate() {
                let length = width_chars_max(w, line) as u16;
                max_w = max_w.max(length);
                max_h += 1;
                if let Tui::Draw(..) = to {
                    let _ = to.text(&line, x, y + index as u16, length)?;
                }
                if max_h >= h {
                    break;
                }
            }
            Ok(Some(XYWH(x, y, max_w, max_h)))
        }
    }

    impl<'a, T: AsRef<str>> Draw<Tui> for TrimStr<'a, T> {
        fn draw (&self, to: &mut Tui) -> Drawn<u16> {
            let text = self.1.as_ref();
            let area = layout_text_u16(text, to.area())?.unwrap();
            let XYWH(x, y, w, ..) = to.area();
            let mut width: u16 = 1;
            let mut chars = text.chars();
            while let Some(c) = chars.next() {
                if width > self.0 || width > w {
                    break
                }
                if let Tui::Draw(..) = to {
                    to.set_char(x + width - 1, y, c);
                }
                width += c.width().unwrap_or(0) as u16;
            }
            let XYWH(x, y, w, ..) = XYWH(
                to.x(), to.y(), to.w().min(self.0).min(self.1.as_ref().width() as u16), to.h()
            );
            to.text(&self.as_ref(), x, y, w)
        }
    }

    fn layout_text_u16 (text: &str, area: XYWH<u16>) -> Perhaps<XYWH<u16>> {
        let XYWH(x, y, w, h) = area;
        let mut max_w = 0u16;
        let mut max_h = 0u16;
        for line in text.split("\n") {
            max_h += 1;
            max_w = max_w.max(line.len() as u16);
        }
        Ok(Some(XYWH(x, y, w.min(max_w), h.min(max_h))))
    }

    #[cfg(test)] #[test] fn test_layout_text_u16 () -> Usually<()> {
        assert_eq!(layout_text_u16("foo", XYWH(5, 6, 10, 10))?, Some(XYWH(5, 6, 3, 1)));
        assert_eq!(layout_text_u16("foo\nbarz", XYWH(5, 6, 10, 10))?, Some(XYWH(5, 6, 4, 2)));
        Ok(())
    }

}