hunter 1.2.1

use termion::event::{Event};

use crate::widget::{Widget, WidgetCore};
use crate::coordinates::{Coordinates, Size, Position};
use crate::fail::{HResult, HError, ErrorLog};

#[derive(PartialEq)]
pub struct VBox<T: Widget> {
    pub core: WidgetCore,
    pub widgets: Vec<T>,
    pub widget_sizes: Option<Vec<usize>>,
    pub zoom_active: bool,
    pub active: Option<usize>,
}


impl<T> VBox<T> where T: Widget + PartialEq {
    pub fn new(core: &WidgetCore) -> VBox<T> {
        VBox { core: core.clone(),
               widgets: vec![],
               widget_sizes: None,
               zoom_active: false,
               active: None
         }
    }


    pub fn resize_children(&mut self) -> HResult<()> {
        let len = self.widgets.len();
        if len == 0 { return Ok(()) }

        if self.zoom_active {
            let coords = self.core.coordinates.clone();
            self.active_widget_mut()?.set_coordinates(&coords).log();
            return Ok(());
        }

        let coords: Vec<Coordinates> = self.calculate_coordinates()?;


        for (widget, coord) in self.widgets.iter_mut().zip(coords.iter()) {
            //dbg!(&coord);
            widget.set_coordinates(coord).log();
            //widget.refresh();
            //widget.draw();
        }

        Ok(())
    }

    pub fn push_widget(&mut self, widget: T) {
        self.widgets.push(widget);
    }

    pub fn pop_widget(&mut self) -> Option<T> {
        let widget = self.widgets.pop();
        widget
    }

    pub fn remove_widget(&mut self, index: usize) -> T {
        self.widgets.remove(index)
    }

    pub fn prepend_widget(&mut self, widget: T) {
        self.widgets.insert(0, widget);
    }

    pub fn insert_widget(&mut self, index: usize, widget: T) {
        self.widgets.insert(index, widget);
    }

    pub fn replace_widget(&mut self, index: usize, mut widget: T) -> T {
        std::mem::swap(&mut self.widgets[index], &mut widget);
        widget
    }

    pub fn toggle_zoom(&mut self) -> HResult<()> {
        self.clear().log();
        self.zoom_active = !self.zoom_active;
        self.resize_children()
    }

    pub fn set_widget_sizes(&mut self, widget_sizes: Vec<usize>) {
        self.widget_sizes = Some(widget_sizes);
    }

    pub fn calculate_equal_widget_sizes(&self) -> HResult<Vec<usize>> {
        let len = self.widgets.len();
        if len == 0 { return HError::no_widget(); }

        let widget_sizes = (0..len).map(|_| 100 / len).collect();
        Ok(widget_sizes)
    }

    pub fn calculate_coordinates(&self)
                                 -> HResult<Vec<Coordinates>> {
        let box_coords = self.get_coordinates()?;
        let box_xpos = box_coords.xpos();
        let box_xsize = box_coords.xsize();
        let box_ysize = box_coords.ysize();
        let box_top = box_coords.top().y();

        let widget_sizes = match &self.widget_sizes {
            Some(widget_sizes) => widget_sizes.clone(),
            None => self.calculate_equal_widget_sizes()?
        };

        let coords = widget_sizes
            .iter()
            .fold(Vec::<Coordinates>::new(),
                  |mut coords, widget_size| {
                      let prev_ypos = coords
                          .last()
                          .map_or(box_top,
                                  |prev_coords| prev_coords.ypos()
                                  + prev_coords.ysize());

                      let widget_coords = Coordinates::new_at(box_xsize,
                                                              *widget_size as u16,
                                                              box_xpos,
                                                              prev_ypos);
                      //dbg!(&widget_coords);
                      coords.push(widget_coords);
                      coords
                  });
            // let widget_size = *widget_size as u16;
            // let len = coords.len();
            // let gap = if len == 0 { 0 } else { 1 };

            // let widget_xsize = box_xsize;
            // let widget_xpos = box_coords.position().x();

            // let widget_ypos = if len == 0 {
            //     box_coords.top().x()
            // } else {
            //     let prev_coords = coords.last().unwrap();
            //     let prev_ysize = prev_coords.ysize();
            //     let prev_ypos = prev_coords.position().y();

            //     prev_ysize + prev_ypos + gap
            // };

            // coords.push(Coordinates {
            //     size: Size((widget_xsize,
            //                 widget_size)),
            //     position: Position((widget_xpos,
            //                        box_top))
            // });
            // coords
        // });

        Ok(coords)
    }

    pub fn set_active(&mut self, i: usize) -> HResult<()> {
        if i+1 > self.widgets.len() {
            HError::no_widget()?
        }
        self.active = Some(i);
        Ok(())
    }

    pub fn active_widget(&self) -> Option<&T> {
        self.widgets.get(self.active?)
    }

    pub fn active_widget_mut(&mut self) -> Option<&mut T> {
        self.widgets.get_mut(self.active?)
    }
}




impl<T> Widget for VBox<T> where T: Widget + PartialEq {
    fn get_core(&self) -> HResult<&WidgetCore> {
        Ok(&self.core)
    }
    fn get_core_mut(&mut self) -> HResult<&mut WidgetCore> {
        Ok(&mut self.core)
    }

    fn set_coordinates(&mut self, coordinates: &Coordinates) -> HResult<()> {
        self.core.coordinates = coordinates.clone();
        self.resize_children()
    }

    fn render_header(&self) -> HResult<String> {
        self.active_widget()?.render_header()
    }

    fn refresh(&mut self) -> HResult<()> {
        if self.zoom_active {
            self.active_widget_mut()?.refresh().log();
            return Ok(());
        }

        self.resize_children().log();
        for child in &mut self.widgets {
            child.refresh().log();
        }
        Ok(())
    }

    fn get_drawlist(&self) -> HResult<String> {
        if self.zoom_active {
            return self.active_widget()?.get_drawlist();
        }

        Ok(self.widgets.iter().map(|child| {
            child.get_drawlist().log_and().unwrap_or_else(|_| String::new())
        }).collect())
    }

    fn on_event(&mut self, event: Event) -> HResult<()> {
        self.active_widget_mut()?.on_event(event)?;
        Ok(())
    }
}