use std::marker::PhantomData;

use crate::prelude::*;

pub struct Stack {
    pub children: Vec<WidgetId>,
    pub size: StackSize,
    pub offset: usize,
}

impl Widget for Stack {
    fn draw(&mut self, painter: &mut Painter) {
        for _ in 0..self.offset {
            painter.layer = painter.next_layer();
        }
        let base = painter.layer;
        for child in &self.children {
            painter.layer = if painter.layer == base {
                painter.child_layer()
            } else {
                painter.next_layer()
            };
            painter.widget(child);
        }
    }

    fn desired_size(&mut self, ctx: &mut SizeCtx) -> UiVec2 {
        match self.size {
            StackSize::Full => UiVec2::MAX_SIZE,
            StackSize::Child(i) => ctx.size(&self.children[i]),
        }
    }
}

#[derive(Default, Debug)]
pub enum StackSize {
    #[default]
    Full,
    Child(usize),
}

pub struct StackBuilder<const LEN: usize, Wa: WidgetArrLike<LEN, Tag>, Tag> {
    pub children: Wa,
    pub size: StackSize,
    pub offset: usize,
    _pd: PhantomData<Tag>,
}

impl<const LEN: usize, Wa: WidgetArrLike<LEN, Tag>, Tag> FnOnce<(&mut Ui,)>
    for StackBuilder<LEN, Wa, Tag>
{
    type Output = Stack;

    extern "rust-call" fn call_once(self, args: (&mut Ui,)) -> Self::Output {
        Stack {
            children: self.children.ui(args.0).arr.to_vec(),
            offset: self.offset,
            size: self.size,
        }
    }
}

impl<const LEN: usize, Wa: WidgetArrLike<LEN, Tag>, Tag> StackBuilder<LEN, Wa, Tag> {
    pub fn new(children: Wa) -> Self {
        Self {
            children,
            size: StackSize::default(),
            offset: 0,
            _pd: PhantomData,
        }
    }

    pub fn stack_size(mut self, size: StackSize) -> Self {
        self.size = size;
        self
    }

    pub fn offset_layer(mut self, offset: usize) -> Self {
        self.offset = offset;
        self
    }
}