//! Screen Output

use embedded_graphics::prelude::*;
use embedded_graphics::{geometry, mono_font, pixelcolor, primitives, text};

use crate::applogic;

pub struct Handler<D>
where
    D: DrawTarget<Color = pixelcolor::Rgb565>,
{
    target: D,
    width: u16,
    height: u16,

    // internal state
    prev_state: ScreenState,
    hb_state: bool,
}

#[derive(Debug, Default, PartialEq, Eq)]
pub enum ScreenState {
    #[default]
    Uninitialized,
    /// aka. "no GNSS fix" or "splash screen"
    Initial,
    Error(alloc::string::String),
    #[cfg(feature = "spat")]
    GlosaSearching(applogic::GlosaSearching),
    #[cfg(feature = "spat")]
    GlosaFound(applogic::GlosaFound),
    #[cfg(feature = "spat")]
    GlosaLocked(applogic::GlosaSignalInfo),
}

#[cfg(feature = "spat")]
impl From<applogic::GlosaOutput> for ScreenState {
    fn from(value: applogic::GlosaOutput) -> Self {
        match value {
            applogic::GlosaOutput::Searching(glosa_searching) => {
                Self::GlosaSearching(glosa_searching)
            }
            applogic::GlosaOutput::Found(glosa_found) => Self::GlosaFound(glosa_found),
            applogic::GlosaOutput::Locked(glosa_signal_info) => {
                Self::GlosaLocked(glosa_signal_info)
            }
            applogic::GlosaOutput::Error(err_str) => Self::Error(err_str),
        }
    }
}

impl<D> Handler<D>
where
    D: DrawTarget<Color = pixelcolor::Rgb565>,
{
    const COLOR_BG: pixelcolor::Rgb565 = pixelcolor::Rgb565::BLACK;
    const COLOR_FG: pixelcolor::Rgb565 = pixelcolor::Rgb565::WHITE;

    const BK_STYLE: primitives::PrimitiveStyle<pixelcolor::Rgb565> =
        primitives::PrimitiveStyleBuilder::new()
            .fill_color(Self::COLOR_BG)
            .build();
    const RD_STYLE: primitives::PrimitiveStyle<pixelcolor::Rgb565> =
        primitives::PrimitiveStyleBuilder::new()
            .fill_color(pixelcolor::Rgb565::CSS_RED)
            .build();
    const YE_STYLE: primitives::PrimitiveStyle<pixelcolor::Rgb565> =
        primitives::PrimitiveStyleBuilder::new()
            .fill_color(pixelcolor::Rgb565::new(31, 55, 0))
            .build();
    const GN_STYLE: primitives::PrimitiveStyle<pixelcolor::Rgb565> =
        primitives::PrimitiveStyleBuilder::new()
            .fill_color(pixelcolor::Rgb565::new(10, 50, 0))
            .build();
    const BLANK_SIGNAL_STYLE: primitives::PrimitiveStyle<pixelcolor::Rgb565> =
        primitives::PrimitiveStyleBuilder::new()
            .fill_color(pixelcolor::Rgb565::CSS_GRAY)
            .build();

    const DEFAULT_TEXT_STYLE: mono_font::MonoTextStyle<'static, pixelcolor::Rgb565> =
        mono_font::MonoTextStyle::new(&profont::PROFONT_24_POINT, Self::COLOR_FG);
    const SMALL_TEXT_STYLE: mono_font::MonoTextStyle<'static, pixelcolor::Rgb565> =
        mono_font::MonoTextStyle::new(&profont::PROFONT_14_POINT, Self::COLOR_FG);

    pub fn new(target: D, width: u16, height: u16) -> Self {
        Self {
            target,
            width,
            height,
            prev_state: ScreenState::Uninitialized,
            hb_state: false,
        }
    }

    pub fn update(&mut self, state: ScreenState) -> Result<(), D::Error> {
        if self.prev_state != state {
            match &state {
                ScreenState::Uninitialized | ScreenState::Initial => self.draw_slash_screen()?,
                ScreenState::GlosaSearching(_glosa_searching) => self.draw_glosa_searching()?,
                ScreenState::GlosaFound(glosa_found) => self.draw_glosa_found(glosa_found)?,
                ScreenState::GlosaLocked(glosa_data) => {
                    let prev_glosa_data =
                        if let ScreenState::GlosaLocked(prev_glosa_data) = &self.prev_state {
                            Some(prev_glosa_data.clone())
                        } else {
                            None
                        };

                    self.draw_glosa(glosa_data, prev_glosa_data)?;
                }
                ScreenState::Error(msg) => self.draw_message(msg)?,
            }
        }

        // Update indicator/ heartbeat
        {
            let update_ind_dia = 10;
            let circle_x_pos = i32::from(self.width) - update_ind_dia - 10;

            text::Text::with_alignment(
                "HB",
                geometry::Point::new(circle_x_pos - 5, 10),
                Self::SMALL_TEXT_STYLE,
                text::Alignment::Right,
            )
            .draw(&mut self.target)?;

            primitives::Circle::new(
                geometry::Point::new(circle_x_pos, 2),
                update_ind_dia.cast_unsigned(),
            )
            .into_styled(if self.hb_state {
                Self::GN_STYLE
            } else {
                Self::BK_STYLE
            })
            .draw(&mut self.target)?;
        }

        self.prev_state = state;
        self.hb_state = !self.hb_state;

        Ok(())
    }

    fn clear(&mut self) -> Result<(), D::Error>
    where
        D: DrawTarget<Color = pixelcolor::Rgb565>,
    {
        primitives::Rectangle::new(
            geometry::Point::new(0, 0),
            geometry::Size::new(self.width.into(), self.height.into()),
        )
        .into_styled(Self::BK_STYLE)
        .draw(&mut self.target)?;

        Ok(())
    }

    #[allow(unused)]
    pub fn test_img(&mut self) -> Result<(), D::Error> {
        mipidsi::TestImage::new().draw(&mut self.target)?;

        Ok(())
    }

    #[allow(unused)]
    pub fn draw_message(&mut self, msg: &str) -> Result<(), D::Error> {
        // clear whole display and draw text
        self.clear()?;

        text::Text::with_alignment(
            msg,
            geometry::Point::new(i32::from(self.width) / 2, 40),
            Self::DEFAULT_TEXT_STYLE,
            text::Alignment::Center,
        )
        .draw(&mut self.target)?;

        Ok(())
    }

    #[allow(unused)]
    fn draw_glosa_searching(&mut self) -> Result<(), D::Error> {
        // clear whole display and draw text
        self.clear()?;

        text::Text::with_alignment(
            "No upcoming SPAT",
            geometry::Point::new(i32::from(self.width) / 2, 130),
            Self::DEFAULT_TEXT_STYLE,
            text::Alignment::Center,
        )
        .draw(&mut self.target)?;

        Ok(())
    }

    #[allow(unused)]
    fn draw_glosa_found(&mut self, data: &applogic::GlosaFound) -> Result<(), D::Error> {
        // clear whole display and draw text
        self.clear()?;

        let text = if let Some(appr) = data.approach_id {
            alloc::format!("Int. {}\nApproach {appr}", data.intersection_id)
        } else {
            alloc::format!("Int. {}\nno approach ID available", data.intersection_id)
        };

        text::Text::with_alignment(
            &text,
            geometry::Point::new(i32::from(self.width) / 2, 130),
            Self::DEFAULT_TEXT_STYLE,
            text::Alignment::Center,
        )
        .draw(&mut self.target)?;

        Ok(())
    }

    #[allow(unused)]
    fn draw_glosa(
        &mut self,
        data: &applogic::GlosaSignalInfo,
        prev_data: Option<applogic::GlosaSignalInfo>,
    ) -> Result<(), D::Error> {
        let num_signals = data.signal_groups.len();

        if let Some(prev) = prev_data
            && prev.signal_groups.len() != num_signals
        {
            // clear everything if number of signals has changed
            self.clear();
        } else {
            // only clear maneuver and timing area otherwise

            primitives::Rectangle::new(
                geometry::Point::new(0, 105),
                geometry::Size::new(self.width.into(), 67),
            )
            .into_styled(Self::BK_STYLE)
            .draw(&mut self.target)?;
        }

        // draw intersection ID
        text::Text::new(
            &alloc::format!("#{}", data.intersection_id),
            geometry::Point::new(15, 10),
            Self::SMALL_TEXT_STYLE,
        )
        .draw(&mut self.target)?;

        #[allow(clippy::cast_possible_truncation, clippy::cast_possible_wrap)]
        let sig_width = i32::from(self.width) / (num_signals as i32);

        for (idx, sig) in data.signal_groups.iter().enumerate() {
            #[allow(clippy::cast_possible_truncation, clippy::cast_possible_wrap)]
            let offset = (idx as i32) * sig_width;

            let circle_dia = 50;
            let circle_margin = (sig_width - circle_dia) / 2;
            let centerline = offset + (sig_width / 2);

            // draw phase color
            let style = match sig.phase {
                applogic::SignalPhase::Unknown => Self::BLANK_SIGNAL_STYLE,
                applogic::SignalPhase::Red => Self::RD_STYLE,
                applogic::SignalPhase::Green => Self::GN_STYLE,
                applogic::SignalPhase::RedYellow | applogic::SignalPhase::Yellow => Self::YE_STYLE,
            };
            primitives::Circle::new(
                geometry::Point::new(offset + circle_margin, 15),
                circle_dia.cast_unsigned(),
            )
            .into_styled(style)
            .draw(&mut self.target)?;

            // TODO: draw lane type?

            // draw maneuver
            text::Text::with_alignment(
                &maneuver_to_str(sig.maneuver),
                geometry::Point::new(centerline, 130),
                Self::DEFAULT_TEXT_STYLE,
                text::Alignment::Center,
            )
            .draw(&mut self.target)?;

            // draw timing indicator
            if let Some(end_sec) = sig.end_sec {
                text::Text::with_alignment(
                    &alloc::format!("{end_sec}s"),
                    geometry::Point::new(centerline, 160),
                    Self::DEFAULT_TEXT_STYLE,
                    text::Alignment::Center,
                )
                .draw(&mut self.target)?;
            }
        }

        Ok(())
    }

    #[allow(unused)]
    fn draw_slash_screen(&mut self) -> Result<(), D::Error> {
        let text_style = mono_font::MonoTextStyle::new(&profont::PROFONT_18_POINT, Self::COLOR_FG);

        self.clear()?;

        let sig_width = i32::from(self.width) / 3;
        let circle_dia = 50;
        let circle_margin = (sig_width - circle_dia) / 2;

        for (idx, style) in [Self::RD_STYLE, Self::YE_STYLE, Self::GN_STYLE]
            .iter()
            .enumerate()
        {
            #[allow(clippy::cast_possible_truncation, clippy::cast_possible_wrap)]
            let offset = (idx as i32) * sig_width;

            primitives::Circle::new(
                geometry::Point::new(offset + circle_margin, 15),
                circle_dia.cast_unsigned(),
            )
            .into_styled(*style)
            .draw(&mut self.target)?;
        }

        // draw welcome text
        let centerline = i32::from(self.width) / 2;
        text::Text::with_alignment(
            "C-ITS Signal Phase Display\nWaiting for GNSS fix...",
            geometry::Point::new(centerline, 130),
            text_style,
            text::Alignment::Center,
        )
        .draw(&mut self.target)?;

        Ok(())
    }
}

fn maneuver_to_str(value: applogic::v2x::map::Maneuvers) -> alloc::string::String {
    alloc::format!(
        "{}{}{}",
        if value.left_allowed { "<" } else { " " },
        if value.staight_allowed { "^" } else { " " },
        if value.right_allowed { ">" } else { " " },
    )
}

/// Creates an [`mipidsi::Display`], width, height tuple for an ST7789 172*320px screen in landscape orientation
///
/// # Errors
/// Human-readable fatal errors
#[allow(clippy::too_many_arguments, clippy::type_complexity)]
pub fn make_small_display<IoScl, IoSda, IoRes, IoDc, IoCs, IoBl, Spi>(
    scl: IoScl,
    sda: IoSda,
    res: IoRes,
    dc: IoDc,
    cs: IoCs,
    bl: IoBl,
    spi: Spi,
    spi_buffer: &mut [u8],
) -> Result<
    (
        mipidsi::Display<
            mipidsi::interface::SpiInterface<
                '_,
                embedded_hal_bus::spi::ExclusiveDevice<
                    esp_hal::spi::master::Spi<'_, esp_hal::Blocking>,
                    esp_hal::gpio::Output<'_>,
                    embedded_hal_bus::spi::NoDelay,
                >,
                esp_hal::gpio::Output<'_>,
            >,
            mipidsi::models::ST7789,
            esp_hal::gpio::Output<'_>,
        >,
        u16,
        u16,
    ),
    alloc::string::String,
>
where
    IoScl: esp_hal::gpio::interconnect::PeripheralOutput<'static>,
    IoSda: esp_hal::gpio::interconnect::PeripheralOutput<'static>,
    IoRes:
        esp_hal::gpio::interconnect::PeripheralOutput<'static> + esp_hal::gpio::OutputPin + 'static,
    IoDc:
        esp_hal::gpio::interconnect::PeripheralOutput<'static> + esp_hal::gpio::OutputPin + 'static,
    IoCs:
        esp_hal::gpio::interconnect::PeripheralOutput<'static> + esp_hal::gpio::OutputPin + 'static,
    IoBl:
        esp_hal::gpio::interconnect::PeripheralOutput<'static> + esp_hal::gpio::OutputPin + 'static,
    Spi: esp_hal::spi::master::Instance + 'static,
{
    const DISPLAY_WIDTH: u16 = 320;
    const DISPLAY_HEIGHT: u16 = 172;
    const DISPLAY_HIDDEN_X: u16 = 34; // somehow this display has 34 px of invisible space on the left (in native orientation)

    let (spi, cs) = setup_st7789_spi(scl, sda, cs, spi)
        .map_err(|err| alloc::format!("Failed to build SPI config: {err}"))?;

    let output_config = esp_hal::gpio::OutputConfig::default();
    let dc_output = esp_hal::gpio::Output::new(dc, esp_hal::gpio::Level::Low, output_config);
    let rst_output = esp_hal::gpio::Output::new(res, esp_hal::gpio::Level::High, output_config);
    let _ = esp_hal::gpio::Output::new(bl, esp_hal::gpio::Level::High, output_config); // enable backlight

    let mut display_delay = esp_hal::delay::Delay::new();

    let spi_device = embedded_hal_bus::spi::ExclusiveDevice::new_no_delay(spi, cs)
        .map_err(|err| alloc::format!("Failed to initialize SPI device: {err}"))?;

    let display = mipidsi::Builder::new(
        mipidsi::models::ST7789,
        mipidsi::interface::SpiInterface::new(spi_device, dc_output, spi_buffer),
    )
    .display_size(DISPLAY_HEIGHT + DISPLAY_HIDDEN_X, DISPLAY_WIDTH)
    .reset_pin(rst_output)
    .invert_colors(mipidsi::options::ColorInversion::Inverted)
    .orientation(mipidsi::options::Orientation::new().rotate(mipidsi::options::Rotation::Deg90))
    .init(&mut display_delay)
    .map_err(|err| alloc::format!("Failed to initialize display: {err:?}"))?;

    Ok((display, DISPLAY_WIDTH, DISPLAY_HEIGHT))
}

/// Builds the SPI interface for the ST7789 display
///
/// Returns (spi master, chip-select) tuple
///
/// # Errors
/// Returns SPI config error when SPI setup failed
fn setup_st7789_spi<IoScl, IoSda, IoCs, Spi>(
    scl: IoScl,
    sda: IoSda,
    cs: IoCs,
    spi: Spi,
) -> Result<
    (
        esp_hal::spi::master::Spi<'static, esp_hal::Blocking>,
        esp_hal::gpio::Output<'static>,
    ),
    esp_hal::spi::master::ConfigError,
>
where
    IoScl: esp_hal::gpio::interconnect::PeripheralOutput<'static>,
    IoSda: esp_hal::gpio::interconnect::PeripheralOutput<'static>,
    IoCs:
        esp_hal::gpio::interconnect::PeripheralOutput<'static> + esp_hal::gpio::OutputPin + 'static,
    Spi: esp_hal::spi::master::Instance + 'static,
{
    let spi_config = esp_hal::spi::master::Config::default()
        .with_frequency(esp_hal::time::Rate::from_mhz(40))
        .with_mode(esp_hal::spi::Mode::_0);
    let spi: esp_hal::spi::master::Spi<'_, esp_hal::Blocking> =
        esp_hal::spi::master::Spi::new(spi, spi_config)?
            .with_sck(scl)
            .with_mosi(sda);

    let cs_output = esp_hal::gpio::Output::new(
        cs,
        esp_hal::gpio::Level::High,
        esp_hal::gpio::OutputConfig::default(),
    );

    Ok((spi, cs_output))
}