// For now, to implement a custom native widget you will need to add
// `iced_native` and `iced_wgpu` to your dependencies.
//
// Then, you simply need to define your widget type and implement the
// `iced_native::Widget` trait with the `iced_wgpu::Renderer`.
//
// Of course, you can choose to make the implementation renderer-agnostic,
// if you wish to, by creating your own `Renderer` trait, which could be
// implemented by `iced_wgpu` and other renderers.

use iced_native::layout::{self, Layout};
use iced_native::renderer;
use iced_native::{Color, Element, Length, Point, Rectangle, Size, Widget};
use iced_native::text;
use iced_native::alignment;


//-------------------------------------------------------------------------

const DAYS_PER_MONTH: [i32;12] = [
    31, // jan
    28, // feb
    31, // mar
    30, // apr
    31, // may
    30, // jun
    31, // jul
    31, // ago
    30, // sep
    31, // oct
    30, // nov
    31, // dec
];

#[derive(Clone)]
pub struct CalendarParams {
    weekday_on_first_of_january: i32, // 0 -> Monday .. 6 -> Sunday
    first_week_on_first_of_january: bool,
    leap_year: bool,
}

impl CalendarParams {
    pub fn new() -> Self {
        // temp: data for 2022
        Self {
            weekday_on_first_of_january: 5, // saturday
            first_week_on_first_of_january: false,
            leap_year: false
        }
    }

    pub fn day_first_of_month(&self, month: i32) -> i32 {
        let mut day : i32 = 0;
        for i in 0..month {
            day += DAYS_PER_MONTH[i as usize];
            if i == 1 && self.leap_year {
                day += 1;
            }
        }
        day
    }

    pub fn monthday(&self, month: i32, day: i32) -> i32 {
        let mut month_days: i32 = DAYS_PER_MONTH[month as usize];
        let mut month: i32 = month;
        let mut day: i32 = day;
        while day < 0 || day >= month_days {
            if day < 0 {
                month = (month + 12 - 1) % 12;
                day = day + DAYS_PER_MONTH[month as usize];
            } else {
                day = day - DAYS_PER_MONTH[month as usize];
                month = (month + 1) % 12;
            }
            month_days = DAYS_PER_MONTH[month as usize];
        }
        day
    }

    pub fn weekday(&self, month: i32, day: i32) -> i32 {
        let day = self.day_first_of_month(month) + day;
        (self.weekday_on_first_of_january + day) % 7
    }

    pub fn weekday_first_of_month(&self, month: i32) -> i32 {
        self.weekday(month, 0)
    }
}
//-------------------------------------------------------------------------

pub struct CalendarMonthView {
    month: i32,
    params: CalendarParams,
    weekday_on_first: i32, // 0 -> Monday .. 6 -> Sunday
    header_fg: Color,
    header_bg: Color,
    day_text: Color,
    day_text_other_month: Color,
    day_weekend_bg: Color,
}

impl CalendarMonthView {
    pub fn new(params: &CalendarParams, month: i32) -> Self {
        Self { 
            month,
            params: params.clone(),
            weekday_on_first: params.weekday_first_of_month(month), 
            header_fg: Color::BLACK,
            header_bg: Color::from_rgb8(214, 242, 252),
            day_text: Color::BLACK,
            day_text_other_month: Color::from_rgb8(220, 220, 220),
//            day_background: Color::from_rgb8(230, 230, 255),
            day_weekend_bg: Color::from_rgb8(250, 250, 250),
        }
    }

    pub fn set_month(&mut self, month: i32) {
        self.month = month;
        self.weekday_on_first = self.params.weekday_first_of_month(month);
    }

    fn draw_header(
        &self,
        renderer: &mut impl text::Renderer,
        bounds: Rectangle,
    ) {
        let origin = bounds.position();

        // font dimension
        let font_size = renderer.default_size() as f32;

        // dimensions of each box representing a day
        let w: f32 = bounds.width / 7.0;
        let h: f32 = bounds.height;

        let days_of_week = ["Lun", "Mar", "Mer", "Gio", "Ven", "Sab", "Dom"];

        renderer.fill_quad(renderer::Quad {
                bounds,
                border_radius: 0.0,
                border_width: 0.0,
                border_color: Color::TRANSPARENT,
            }, 
            self.header_bg);
        
        for weekday in 0..7i32 {
            let bounds = Rectangle { 
                x: (weekday as f32) * w + origin.x,
                y: origin.y,
                width: w,
                height: h
            };
                    
            // label (day letter on row 0, day number on the rest)
            let t =  days_of_week[weekday as usize];

            // color of text
            let fg = self.header_fg;

            let x = bounds.center_x();
            let y = bounds.center_y();
            renderer.fill_text(text::Text {
                content : t,
                size: font_size,
                bounds: Rectangle {x, y, ..bounds},
                color: fg,
                font: Default::default(),
                horizontal_alignment: alignment::Horizontal::Center,
                vertical_alignment: alignment::Vertical::Center,
                });
        }
    }

    fn draw_days(
        &self,
        renderer: &mut impl text::Renderer,
        bounds: Rectangle,
    ) {
        let size: Size = bounds.size();
        let origin = bounds.position();

        // font dimension
        let font_size = renderer.default_size() as f32;

        // dimensions of each box representing a day
        let w: f32 = size.width / 7.0;
        let h: f32 = size.height / 6.0;

        let days_of_month = [
            " 1", " 2", " 3", " 4", " 5", " 6", " 7", " 8", " 9", "10",
            "11", "12", "13", "14", "15", "16", "17", "18", "19", "20",
            "21", "22", "23", "24", "25", "26", "27", "28", "29", "30",
            "31",
            ];

        // paint the background of the last two columns as weekend
        renderer.fill_quad(renderer::Quad {
                bounds: Rectangle {x: 5.0 * w + origin.x, y: origin.y, width: 2.0 * w, height: 6.0 * h},
                border_radius: 0.0,
                border_width: 0.0,
                border_color: Color::TRANSPARENT,
            }, 
            self.day_weekend_bg);

        for week in 0..6i32 {
            for weekday in 0..7i32 {
                let monthday = weekday + week * 7 - self.weekday_on_first;
                let day_bounds = Rectangle { 
                    x: (weekday as f32) * (w + 2.0) + origin.x, 
                    y: (week as f32) * (h + 2.0) + origin.y, 
                    width: w, 
                    height: h 
                };
                        
                // label (day letter on row 0, day number on the rest)
                let t = days_of_month[self.params.monthday(self.month, monthday) as usize];

                // color of text
                let fg = if monthday >= 0 && monthday <= 30 {
                    self.day_text
                } else {
                    self.day_text_other_month
                };

                let x = day_bounds.center_x();
                let y = day_bounds.center_y();
                
                renderer.fill_text(text::Text {
                    content : t,
                    size: font_size,
                    bounds: Rectangle {x, y, ..day_bounds},
                    color: fg,
                    font: Default::default(),
                    horizontal_alignment: alignment::Horizontal::Center,
                    vertical_alignment: alignment::Vertical::Center,
                    });
            }
        }
    }

} // CalendarMonthView

impl<Message, Renderer> Widget<Message, Renderer> for CalendarMonthView
where
    Renderer: text::Renderer,
{
    fn width(&self) -> Length {
        Length::Shrink
    }

    fn height(&self) -> Length {
        Length::Shrink
    }

    fn layout(
        &self,
        _renderer: &Renderer,
        limits: &layout::Limits,
    ) -> layout::Node {
        layout::Node::new(limits.max())
    }

    fn draw(
        &self,
        renderer: &mut Renderer,
        _theme: &Renderer::Theme,
        _style: &renderer::Style,
        layout: Layout<'_>,
        _cursor_position: Point,
        _viewport: &Rectangle,
    ) {
        let size: Size = layout.bounds().size();
        let origin = layout.bounds().position();
        let margin: f32 = 20.0;

        // font and header dimension
        let font_size = renderer.default_size() as f32;
        let first_row_h = font_size + margin;

        // header
        let x = origin.x;
        let y = origin.y;
        let width = size.width;
        let height = first_row_h;
        self.draw_header(renderer, Rectangle {x, y, width, height});

        // monthly calendar cells
        let x = origin.x;
        let y = origin.y + first_row_h;
        let width = size.width;
        let height = size.height - first_row_h;
        self.draw_days(renderer, Rectangle{x, y, width, height});
    }
}

impl<'a, Message, Renderer> From<CalendarMonthView> for Element<'a, Message, Renderer>
where
    Renderer: text::Renderer,
{
    fn from(circle: CalendarMonthView) -> Self {
        Self::new(circle)
    }
}