use crate::app;
use gpui::{ParentElement, Refineable as _, Styled, div};

#[derive(gpui::IntoElement)]
pub(crate) struct Text {
    content: gpui::AnyElement,
    font_weight: gpui::FontWeight,
    opacity: f32,
    text_align: gpui::TextAlign,
    text_size: Option<gpui::AbsoluteLength>,
    text_color: Option<gpui::Hsla>,
    line_height: gpui::DefiniteLength,
    style: gpui::StyleRefinement,
}

pub(crate) trait TextContent: gpui::IntoElement {}

impl TextContent for &'static str {}
impl TextContent for String {}
impl TextContent for gpui::SharedString {}

pub(crate) fn text(content: impl TextContent) -> Text {
    Text {
        content: content.into_any_element(),
        font_weight: gpui::FontWeight::NORMAL,
        opacity: 1.,
        text_align: gpui::TextAlign::Left,
        text_size: None,
        text_color: None,
        line_height: gpui::relative(1.5),
        style: gpui::StyleRefinement::default(),
    }
}

impl Styled for Text {
    fn style(&mut self) -> &mut gpui::StyleRefinement {
        &mut self.style
    }
}

impl Text {
    pub(crate) fn light(mut self) -> Self {
        self.font_weight = gpui::FontWeight::LIGHT;
        self
    }

    pub(crate) fn medium(mut self) -> Self {
        self.font_weight = gpui::FontWeight::MEDIUM;
        self
    }

    pub(crate) fn bold(mut self) -> Self {
        self.font_weight = gpui::FontWeight::BOLD;
        self
    }

    pub(crate) fn opacity(mut self, opacity: f32) -> Self {
        self.opacity = opacity;
        self
    }

    pub(crate) fn text_size(mut self, size: impl Into<gpui::AbsoluteLength>) -> Self {
        self.text_size = Some(size.into());
        self
    }

    pub(crate) fn text_xs(self) -> Self {
        self.text_size(gpui::rems(0.75))
    }

    pub(crate) fn text_sm(self) -> Self {
        self.text_size(gpui::rems(0.875))
    }

    pub(crate) fn text_base(self) -> Self {
        self.text_size(gpui::rems(1.0))
    }

    pub(crate) fn text_lg(self) -> Self {
        self.text_size(gpui::rems(1.125))
    }

    pub(crate) fn text_xl(self) -> Self {
        self.text_size(gpui::rems(1.25))
    }

    pub(crate) fn text_2xl(self) -> Self {
        self.text_size(gpui::rems(1.5))
    }

    pub(crate) fn text_3xl(self) -> Self {
        self.text_size(gpui::rems(1.875))
    }

    pub(crate) fn text_color(mut self, color: impl Into<gpui::Hsla>) -> Self {
        self.text_color = Some(color.into());
        self
    }

    pub(crate) fn line_height(mut self, line_height: impl Into<gpui::DefiniteLength>) -> Self {
        self.line_height = line_height.into();
        self
    }

    pub(crate) fn leading_none(self) -> Self {
        self.line_height(gpui::relative(1.0))
    }

    pub(crate) fn leading_tight(self) -> Self {
        self.line_height(gpui::relative(1.25))
    }

    pub(crate) fn leading_snug(self) -> Self {
        self.line_height(gpui::relative(1.375))
    }

    pub(crate) fn leading_normal(self) -> Self {
        self.line_height(gpui::relative(1.5))
    }

    pub(crate) fn leading_relaxed(self) -> Self {
        self.line_height(gpui::relative(1.625))
    }

    pub(crate) fn leading_loose(self) -> Self {
        self.line_height(gpui::relative(2.0))
    }

    pub(crate) fn leading_3(self) -> Self {
        self.line_height(gpui::rems(0.75))
    }

    pub(crate) fn leading_4(self) -> Self {
        self.line_height(gpui::rems(1.0))
    }

    pub(crate) fn leading_5(self) -> Self {
        self.line_height(gpui::rems(1.25))
    }

    pub(crate) fn leading_6(self) -> Self {
        self.line_height(gpui::rems(1.5))
    }

    pub(crate) fn leading_7(self) -> Self {
        self.line_height(gpui::rems(1.75))
    }

    pub(crate) fn leading_8(self) -> Self {
        self.line_height(gpui::rems(2.0))
    }

    pub(crate) fn leading_9(self) -> Self {
        self.line_height(gpui::rems(2.25))
    }

    pub(crate) fn leading_10(self) -> Self {
        self.line_height(gpui::rems(2.5))
    }

    pub(crate) fn centered(mut self) -> Self {
        self.text_align = gpui::TextAlign::Center;
        self
    }
}

impl gpui::RenderOnce for Text {
    fn render(self, _window: &mut gpui::Window, cx: &mut gpui::App) -> impl gpui::IntoElement {
        let theme = app::current_theme(cx);
        let mut div = div()
            .text_color(self.text_color.unwrap_or(theme.colors.text.into()))
            .font_weight(self.font_weight)
            .opacity(self.opacity)
            .text_align(self.text_align)
            .line_height(self.line_height)
            .child(self.content);
        if let Some(text_size) = self.text_size {
            div = div.text_size(text_size);
        }
        div.style().refine(&self.style);
        div
    }
}