monorepo/fitnesstrax/app/src/components/day.rs

/*
Copyright 2023-2024, Savanni D'Gerinel <savanni@luminescent-dreams.com>

This file is part of FitnessTrax.

FitnessTrax is free software: you can redistribute it and/or modify it under the terms of the GNU
General Public License as published by the Free Software Foundation, either version 3 of the
License, or (at your option) any later version.

FitnessTrax is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.

You should have received a copy of the GNU General Public License along with FitnessTrax. If not, see <https://www.gnu.org/licenses/>.
*/

// use chrono::NaiveDate;
// use ft_core::TraxRecord;
use crate::{
    components::{ActionGroup, Weight},
    view_models::DayDetailViewModel,
};
use emseries::Record;
use glib::Object;
use gtk::{prelude::*, subclass::prelude::*};
use std::{cell::RefCell, rc::Rc};

use super::weight::WeightEdit;

pub struct DaySummaryPrivate {
    date: gtk::Label,
    weight: RefCell<Option<gtk::Label>>,
}

#[glib::object_subclass]
impl ObjectSubclass for DaySummaryPrivate {
    const NAME: &'static str = "DaySummary";
    type Type = DaySummary;
    type ParentType = gtk::Box;

    fn new() -> Self {
        let date = gtk::Label::builder()
            .css_classes(["day-summary__date"])
            .halign(gtk::Align::Start)
            .build();
        Self {
            date,
            weight: RefCell::new(None),
        }
    }
}

impl ObjectImpl for DaySummaryPrivate {}
impl WidgetImpl for DaySummaryPrivate {}
impl BoxImpl for DaySummaryPrivate {}

glib::wrapper! {
    /// The DaySummary displays one day's activities in a narrative style. This is meant to give
    /// an overall feel of everything that happened during the day without going into details.
    pub struct DaySummary(ObjectSubclass<DaySummaryPrivate>) @extends gtk::Box, gtk::Widget, @implements gtk::Orientable;
}

impl DaySummary {
    pub fn new() -> Self {
        let s: Self = Object::builder().build();
        s.set_orientation(gtk::Orientation::Vertical);
        s.set_css_classes(&["day-summary"]);

        s.append(&s.imp().date);

        s
    }

    pub fn set_data(&self, date: chrono::NaiveDate, records: Vec<Record<ft_core::TraxRecord>>) {
        self.imp()
            .date
            .set_text(&date.format("%Y-%m-%d").to_string());

        if let Some(ref weight_label) = *self.imp().weight.borrow() {
            self.remove(weight_label);
        }

        if let Some(Record {
            data: ft_core::TraxRecord::Weight(weight_record),
            ..
        }) = records.iter().filter(|f| f.data.is_weight()).next()
        {
            let label = gtk::Label::builder()
                .halign(gtk::Align::Start)
                .label(&format!("{}", weight_record.weight))
                .css_classes(["day-summary__weight"])
                .build();
            self.append(&label);
            *self.imp().weight.borrow_mut() = Some(label);
        }

        /*
        self.append(
            &gtk::Label::builder()
                .halign(gtk::Align::Start)
                .label("15km of biking in 60 minutes")
                .build(),
        );
        */
    }
}

#[derive(Default)]
pub struct DayDetailPrivate {}

#[glib::object_subclass]
impl ObjectSubclass for DayDetailPrivate {
    const NAME: &'static str = "DayDetail";
    type Type = DayDetail;
    type ParentType = gtk::Box;
}

impl ObjectImpl for DayDetailPrivate {}
impl WidgetImpl for DayDetailPrivate {}
impl BoxImpl for DayDetailPrivate {}

glib::wrapper! {
    pub struct DayDetail(ObjectSubclass<DayDetailPrivate>) @extends gtk::Box, gtk::Widget, @implements gtk::Orientable;
}

impl DayDetail {
    pub fn new<OnEdit>(view_model: DayDetailViewModel, on_edit: OnEdit) -> Self
    where
        OnEdit: Fn() + 'static,
    {
        let s: Self = Object::builder().build();
        s.set_orientation(gtk::Orientation::Vertical);
        s.set_hexpand(true);

        s.append(
            &ActionGroup::builder()
                .primary_action("Edit", Box::new(move || on_edit()))
                .build(),
        );

        /*
        let click_controller = gtk::GestureClick::new();
        click_controller.connect_released({
            let s = s.clone();
            move |_, _, _, _| {
                println!("clicked outside of focusable entity");
                if let Some(widget) = s.focus_child().and_downcast_ref::<WeightView>() {
                    println!("focused child is the weight view");
                    widget.blur();
                }
            }
        });
        s.add_controller(click_controller);
        */

        /*
        let weight_record = records.iter().find_map(|record| match record {
            Record {
                id,
                data: ft_core::TraxRecord::Weight(record),
            } => Some((id.clone(), record.clone())),
            _ => None,
        });
        */

        let weight_view = Weight::new(view_model.weight());
        s.append(&weight_view.widget());

        /*
        records.into_iter().for_each(|record| {
            let record_view = match record {
                Record {
                    data: ft_core::TraxRecord::BikeRide(record),
                    ..
                } => Some(
                    TimeDistanceView::new(ft_core::RecordType::BikeRide, record)
                        .upcast::<gtk::Widget>(),
                ),
                Record {
                    data: ft_core::TraxRecord::Row(record),
                    ..
                } => Some(
                    TimeDistanceView::new(ft_core::RecordType::Row, record).upcast::<gtk::Widget>(),
                ),
                Record {
                    data: ft_core::TraxRecord::Run(record),
                    ..
                } => Some(
                    TimeDistanceView::new(ft_core::RecordType::Row, record).upcast::<gtk::Widget>(),
                ),
                Record {
                    data: ft_core::TraxRecord::Swim(record),
                    ..
                } => Some(
                    TimeDistanceView::new(ft_core::RecordType::Row, record).upcast::<gtk::Widget>(),
                ),
                Record {
                    data: ft_core::TraxRecord::Walk(record),
                    ..
                } => Some(
                    TimeDistanceView::new(ft_core::RecordType::Row, record).upcast::<gtk::Widget>(),
                ),
                _ => None,
            };

            if let Some(record_view) = record_view {
                record_view.add_css_class("day-detail");
                record_view.set_halign(gtk::Align::Start);

                s.append(&record_view);
            }
        });
        */

        s
    }
}

pub struct DayEditPrivate {
    on_finished: RefCell<Box<dyn Fn()>>,
}

impl Default for DayEditPrivate {
    fn default() -> Self {
        Self {
            on_finished: RefCell::new(Box::new(|| {})),
        }
    }
}

#[glib::object_subclass]
impl ObjectSubclass for DayEditPrivate {
    const NAME: &'static str = "DayEdit";
    type Type = DayEdit;
    type ParentType = gtk::Box;
}

impl ObjectImpl for DayEditPrivate {}
impl WidgetImpl for DayEditPrivate {}
impl BoxImpl for DayEditPrivate {}

glib::wrapper! {
    pub struct DayEdit(ObjectSubclass<DayEditPrivate>) @extends gtk::Box, gtk::Widget, @implements gtk::Orientable;
}

impl DayEdit {
    pub fn new<OnFinished>(view_model: DayDetailViewModel, on_finished: OnFinished) -> Self
    where
        OnFinished: Fn() + 'static,
    {
        let s: Self = Object::builder().build();
        s.set_orientation(gtk::Orientation::Vertical);
        s.set_hexpand(true);

        *s.imp().on_finished.borrow_mut() = Box::new(on_finished);

        s.append(
            &ActionGroup::builder()
                .primary_action("Save", {
                    let s = s.clone();
                    let view_model = view_model.clone();
                    move || {
                        view_model.save();
                        s.finish();
                    }
                })
                .secondary_action("Cancel", {
                    let s = s.clone();
                    let view_model = view_model.clone();
                    move || {
                        view_model.revert();
                        s.finish();
                    }
                })
                .build(),
        );

        s.append(
            &WeightEdit::new(view_model.weight(), {
                let view_model = view_model.clone();
                move |w| {
                    view_model.set_weight(w);
                }
            })
            .widget(),
        );

        s
    }

    fn finish(&self) {
        (self.imp().on_finished.borrow())()
    }
}