use crate::{
    HashMap, Painter, Widget, WidgetId, WidgetLike,
    primitive::Primitives,
    util::{ID, IDTracker},
};
use std::{
    any::{Any, TypeId},
    ops::{Index, IndexMut},
};

#[derive(Default)]
pub struct Ui {
    ids: IDTracker,
    base: Option<WidgetId>,
    widgets: Widgets,
    updates: Vec<WidgetId>,
    primitives: Primitives,
    full_redraw: bool,
}

#[derive(Default)]
pub struct Widgets(HashMap<ID, Box<dyn Widget>>);

impl Ui {
    pub fn add<W: Widget>(&mut self, w: impl WidgetLike<Widget = W>) -> WidgetId<W> {
        w.add(self)
    }

    pub fn add_widget<W: Widget>(&mut self, w: W) -> WidgetId<W> {
        self.push(w)
    }

    pub fn push<W: Widget>(&mut self, w: W) -> WidgetId<W> {
        let id = self.ids.next();
        self.widgets.insert(id.duplicate(), w);
        WidgetId::new(id, TypeId::of::<W>())
    }

    pub fn set<W: Widget>(&mut self, i: &WidgetId<W>, w: W) {
        self.widgets.insert(i.id.duplicate(), w);
    }

    pub fn set_base(&mut self, w: impl WidgetLike) {
        self.base = Some(w.add(self).erase_type());
        self.full_redraw = true;
    }

    pub fn new() -> Self {
        Self::default()
    }

    pub fn get<W: Widget>(&self, id: &WidgetId<W>) -> Option<&W> {
        self.widgets.get(id)
    }

    pub fn get_mut<W: Widget>(&mut self, id: &WidgetId<W>) -> Option<&mut W> {
        self.widgets.get_mut(id)
    }

    pub fn id<W: Widget>(&mut self) -> WidgetId<W> {
        WidgetId::new(self.ids.next(), TypeId::of::<W>())
    }

    pub fn redraw_all(&mut self) {
        let mut painter = Painter::new(&self.widgets);
        if let Some(base) = &self.base {
            painter.draw(base);
        }
        self.primitives = painter.finish();
    }

    pub fn update(&mut self) -> Option<&Primitives> {
        if self.full_redraw {
            self.redraw_all();
            self.full_redraw = false;
            return Some(&self.primitives);
        }
        if self.updates.is_empty() {
            return None;
        }
        self.redraw_all();
        self.updates.drain(..);
        Some(&self.primitives)
    }

    pub fn needs_redraw(&self) -> bool {
        self.full_redraw || !self.updates.is_empty()
    }
}

impl<W: Widget> Index<&WidgetId<W>> for Ui {
    type Output = W;

    fn index(&self, id: &WidgetId<W>) -> &Self::Output {
        self.get(id).unwrap()
    }
}

impl<W: Widget> IndexMut<&WidgetId<W>> for Ui {
    fn index_mut(&mut self, id: &WidgetId<W>) -> &mut Self::Output {
        self.updates.push(id.clone().erase_type());
        self.get_mut(id).unwrap()
    }
}

impl Widgets {
    pub fn get_dyn(&self, id: &WidgetId) -> &dyn Widget {
        self.0.get(&id.id).unwrap().as_ref()
    }

    pub fn get<W: Widget>(&self, id: &WidgetId<W>) -> Option<&W> {
        self.0.get(&id.id).unwrap().as_any().downcast_ref()
    }

    pub fn get_mut<W: Widget>(&mut self, id: &WidgetId<W>) -> Option<&mut W> {
        self.0.get_mut(&id.id).unwrap().as_any_mut().downcast_mut()
    }

    pub fn insert(&mut self, id: ID, widget: impl Widget) {
        self.0.insert(id, Box::new(widget));
    }

    pub fn insert_any(&mut self, id: ID, widget: Box<dyn Widget>) {
        self.0.insert(id, widget);
    }
}

impl dyn Widget {
    pub fn as_any(&self) -> &dyn Any {
        self
    }

    pub fn as_any_mut(&mut self) -> &mut dyn Any {
        self
    }
}