use crate::prelude::*;

pub struct Pad {
    pub padding: Padding,
    pub inner: WidgetRef,
}

impl Widget for Pad {
    fn draw(&mut self, painter: &mut Painter) {
        painter.widget_within(&self.inner, self.padding.region());
    }

    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
        let width = self.padding.left + self.padding.right;
        let height = self.padding.top + self.padding.bottom;
        ctx.outer.x.abs -= width;
        ctx.outer.y.abs -= height;
        let mut size = ctx.width(&self.inner);
        size.abs += width;
        size
    }

    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
        let width = self.padding.left + self.padding.right;
        let height = self.padding.top + self.padding.bottom;
        ctx.outer.x.abs -= width;
        ctx.outer.y.abs -= height;
        let mut size = ctx.height(&self.inner);
        size.abs += height;
        size
    }
}

pub struct Padding {
    pub left: f32,
    pub right: f32,
    pub top: f32,
    pub bottom: f32,
}

impl Padding {
    pub const ZERO: Self = Self {
        left: 0.0,
        right: 0.0,
        top: 0.0,
        bottom: 0.0,
    };

    pub fn uniform(amt: impl UiNum) -> Self {
        let amt = amt.to_f32();
        Self {
            left: amt,
            right: amt,
            top: amt,
            bottom: amt,
        }
    }
    pub fn region(&self) -> UiRegion {
        let mut region = UiRegion::FULL;
        region.x.start.abs += self.left;
        region.y.start.abs += self.top;
        region.x.end.abs -= self.right;
        region.y.end.abs -= self.bottom;
        region
    }
    pub fn x(amt: impl UiNum) -> Self {
        let amt = amt.to_f32();
        Self {
            left: amt,
            right: amt,
            top: 0.0,
            bottom: 0.0,
        }
    }
    pub fn y(amt: impl UiNum) -> Self {
        let amt = amt.to_f32();
        Self {
            left: 0.0,
            right: 0.0,
            top: amt,
            bottom: amt,
        }
    }

    pub fn top(amt: impl UiNum) -> Self {
        let mut s = Self::ZERO;
        s.top = amt.to_f32();
        s
    }

    pub fn bottom(amt: impl UiNum) -> Self {
        let mut s = Self::ZERO;
        s.bottom = amt.to_f32();
        s
    }

    pub fn left(amt: impl UiNum) -> Self {
        let mut s = Self::ZERO;
        s.left = amt.to_f32();
        s
    }

    pub fn right(amt: impl UiNum) -> Self {
        let mut s = Self::ZERO;
        s.right = amt.to_f32();
        s
    }

    pub fn with_top(mut self, amt: impl UiNum) -> Self {
        self.top = amt.to_f32();
        self
    }

    pub fn with_bottom(mut self, amt: impl UiNum) -> Self {
        self.bottom = amt.to_f32();
        self
    }

    pub fn with_left(mut self, amt: impl UiNum) -> Self {
        self.left = amt.to_f32();
        self
    }

    pub fn with_right(mut self, amt: impl UiNum) -> Self {
        self.right = amt.to_f32();
        self
    }
}

impl<T: UiNum> From<T> for Padding {
    fn from(amt: T) -> Self {
        Self::uniform(amt.to_f32())
    }
}