path: root/src/app.rs

use gtk4 as gtk;

use async_channel::{Receiver, Sender};
use chrono::{Datelike, NaiveDate, NaiveTime, Weekday};
use gtk::gdk::Display;
use gtk::glib::signal::Inhibit;
use gtk::glib;
use gtk::prelude::*;
use rusqlite::Connection;
use std::future::Future;
use std::rc::Rc;

use crate::model::event;
use crate::model::event::Event;
use crate::db;

/// Spawns a task on the default executor, without waiting for it to complete
pub fn spawn<F>(future: F)
where
    F: Future<Output = ()> + 'static,
{
    gtk::glib::MainContext::default().spawn_local(future);
}

fn send_message(tx: Sender<Msg>, msg: Msg) {
    spawn(async move {
        let _ = tx.send(msg).await;
    })
}

enum Msg {
    ShowAddForm { date: NaiveDate },
    AddEvent { event: Event },
}

static DAYS: [&str; 7] = ["LUN", "MAR", "MER", "JEU", "VEN", "SAM", "DIM"];
static MONTHES: [&str; 12] = [
    "Jan", "Fév", "Mar", "Avr", "Mai", "Juin", "Juil", "Aoû", "Sep", "Oct", "Nov", "Déc",
];

pub fn run(conn: Connection) {
    let conn = Rc::new(conn);
    let app = gtk::Application::new(Some("me.guyonvarch.calendar"), Default::default());
    app.connect_startup(|_| load_style());
    app.connect_activate(move |app| build_ui(conn.clone(), app));
    app.run();
}

fn build_ui(conn: Rc<Connection>, app: &gtk::Application) {
    let (tx, rx) = async_channel::unbounded();
    let app = App::new(conn.clone(), app, tx.clone());
    spawn(event_handler(conn, rx, tx, app))
}

async fn event_handler(conn: Rc<Connection>, rx: Receiver<Msg>, tx: Sender<Msg>, mut app: App) {
    while let Ok(msg) = rx.recv().await {
        match msg {
            Msg::ShowAddForm { date } => {
                add_event_dialog(Rc::clone(&conn), tx.clone(), Rc::clone(&app.window), date).await;
            }
            Msg::AddEvent { event } => {
                let date = event.date.clone();

                let d = date.signed_duration_since(app.start_date).num_days();

                app.events.push(event);

                let col = (d % 7) as i32;
                let row = 1 + (d / 7) as i32;

                app.grid.attach(
                    &day_entry(tx.clone(), &date, &app.today, &app.events),
                    col,
                    row,
                    1,
                    1,
                );
            }
        }
    }
}

struct App {
    pub window: Rc<gtk::ApplicationWindow>,
    pub grid: gtk::Grid,
    pub events: Vec<Event>,
    pub today: NaiveDate,
    pub start_date: NaiveDate,
}

impl App {
    fn new(conn: Rc<Connection>, app: &gtk::Application, tx: Sender<Msg>) -> Self {
        let window = Rc::new(
            gtk::ApplicationWindow::builder()
                .application(app)
                .title("Calendar")
                .default_width(800)
                .default_height(600)
                .visible(true)
                .build(),
        );

        let grid = gtk::Grid::builder().build();
        window.set_child(Some(&grid));

        for col in 0..7 {
            grid.attach(&day_title(col), col, 0, 1, 1);
        }

        let today = chrono::offset::Local::today().naive_utc();
        let start_date =
            NaiveDate::from_isoywd(today.year(), today.iso_week().week(), Weekday::Mon);


        let events = db::list(&conn).unwrap_or(vec!());
        show_days(tx, &grid, &start_date, &today, &events);

        window.connect_close_request(move |window| {
            if let Some(application) = window.application() {
                application.remove_window(window);
            }
            Inhibit(false)
        });

        Self {
            window,
            grid,
            events: events.clone(),
            today,
            start_date,
        }
    }
}

fn load_style() {
    let provider = gtk::CssProvider::new();
    provider.load_from_data(include_bytes!("style.css"));
    gtk::StyleContext::add_provider_for_display(
        &Display::default().expect("Error initializing gtk css provider."),
        &provider,
        gtk::STYLE_PROVIDER_PRIORITY_APPLICATION,
    );
}

fn show_days(
    tx: Sender<Msg>,
    grid: &gtk::Grid,
    start_day: &NaiveDate,
    today: &NaiveDate,
    events: &Vec<Event>,
) {
    let mut d = *start_day;
    for row in 1..5 {
        for col in 0..7 {
            grid.attach(&day_entry(tx.clone(), &d, &today, &events), col, row, 1, 1);
            d = d.succ();
        }
    }
}

fn day_title(col: i32) -> gtk::Box {
    let vbox = gtk::Box::builder()
        .orientation(gtk::Orientation::Vertical)
        .build();

    vbox.add_css_class("g-Calendar__DayTitle");

    let label = gtk::Label::builder().label(DAYS[col as usize]).build();

    vbox.append(&label);

    vbox
}

fn day_entry(
    tx: Sender<Msg>,
    date: &NaiveDate,
    today: &NaiveDate,
    events: &Vec<Event>,
) -> gtk::ScrolledWindow {
    let vbox = gtk::Box::builder()
        .orientation(gtk::Orientation::Vertical)
        .build();

    vbox.add_css_class("g-Calendar__Day");

    let gesture = gtk::GestureClick::new();
    gesture.connect_pressed(glib::clone!(@strong date => move |_, n, _, _| {
        if n == 2 {
            send_message(tx.clone(), Msg::ShowAddForm { date });
        }
    }));
    vbox.add_controller(&gesture);

    if date == today {
        vbox.add_css_class("g-Calendar__Day--Today");
    }

    vbox.append(&day_label(date));

    let mut events = events
        .iter()
        .filter(|e| e.date == *date)
        .collect::<Vec<&Event>>();
    events.sort_by_key(|e| e.start);

    if !events.is_empty() {
        vbox.append(&day_events(events));
    }

    let scrolled_window = gtk::ScrolledWindow::builder()
        .hscrollbar_policy(gtk::PolicyType::Never)
        .hexpand(true)
        .vexpand(true)
        .child(&vbox)
        .build();

    scrolled_window
}

fn day_label(date: &NaiveDate) -> gtk::Label {
    let label = gtk::Label::builder()
        .label(&format!(
            "{} {}",
            date.day(),
            MONTHES[date.month0() as usize]
        ))
        .halign(gtk::Align::Start)
        .build();

    label.add_css_class("g-Calendar__DayNumber");

    label
}

fn day_events(events: Vec<&Event>) -> gtk::Box {
    let vbox = gtk::Box::builder()
        .orientation(gtk::Orientation::Vertical)
        .build();

    for event in events {
        let hbox = gtk::Box::builder()
            .orientation(gtk::Orientation::Horizontal)
            .hexpand(true)
            .build();

        let gesture = gtk::GestureClick::new();
        let click_event = event.clone();
        gesture.connect_pressed(move |gesture, _, _, _| {
            gesture.set_state(gtk::EventSequenceState::Claimed);
            println!("Click: {:?}", click_event);
        });
        hbox.add_controller(&gesture);

        hbox.add_css_class("g-Calendar__DayEvent");

        let event_txt = &event.pprint();
        let label = gtk::Label::builder()
            .label(&event_txt)
            .ellipsize(gtk::pango::EllipsizeMode::End)
            .tooltip_text(&event_txt)
            .halign(gtk::Align::Start)
            .build();

        hbox.append(&label);
        vbox.append(&hbox);
    }

    vbox
}

static DATE_FORMAT: &str = "%d/%m/%Y";

async fn add_event_dialog(conn: Rc<Connection>, tx: Sender<Msg>, window: Rc<gtk::ApplicationWindow>, date: NaiveDate) {
    let dialog = gtk::Dialog::builder()
        .transient_for(&*window)
        .modal(true)
        .title("Ajouter")
        .css_classes(vec!["g-Form".to_string()])
        .build();

    let content_area = dialog.content_area();

    let vbox = gtk::Box::builder()
        .orientation(gtk::Orientation::Vertical)
        .build();
    vbox.add_css_class("g-Form__Inputs");
    content_area.append(&vbox);

    let name = entry("");
    vbox.append(&label("Événement"));
    vbox.append(&name);

    let date = entry(&date.format(DATE_FORMAT).to_string());
    vbox.append(&label("Jour"));
    vbox.append(&date);

    let start = entry("");
    vbox.append(&label("Début"));
    vbox.append(&start);

    let end = entry("");
    vbox.append(&label("Fin"));
    vbox.append(&end);

    let button = gtk::Button::with_label("Créer");
    vbox.append(&button);
    button.connect_clicked(glib::clone!(@weak dialog => move |_| {
        match validate_event(date.buffer().text(), name.buffer().text(), start.buffer().text(), end.buffer().text()) {
            Some(event) => {
                match db::insert(&conn, &event) {
                    Ok(_) => {
                        send_message(tx.clone(), Msg::AddEvent { event: event });
                        dialog.close()
                    },
                    Err(_) => ()
                }
            },
            None => ()
        }
    }));

    dialog.run_future().await;
}

fn entry(text: &str) -> gtk::Entry {
    gtk::Entry::builder().text(text).margin_bottom(10).build()
}

fn label(text: &str) -> gtk::Label {
    gtk::Label::builder()
        .label(text)
        .halign(gtk::Align::Start)
        .margin_bottom(5)
        .build()
}

fn validate_event(date: String, name: String, start: String, end: String) -> Option<Event> {
    let start = validate_time(start)?;
    let end = validate_time(end)?;

    match (start, end) {
        (Some(s), Some(e)) if s > e => None?,
        _ => (),
    }

    Some(Event {
        date: NaiveDate::parse_from_str(&date, DATE_FORMAT).ok()?,
        name: validate_name(name)?,
        start,
        end,
    })
}

fn validate_time(time: String) -> Option<Option<NaiveTime>> {
    let time = time.trim();
    if time.is_empty() {
        Some(None)
    } else {
        event::parse_time(time).map(|t| Some(t))
    }
}

fn validate_name(name: String) -> Option<String> {
    let name = name.trim();
    if name.is_empty() {
        None
    } else {
        Some(name.to_string())
    }
}