/*
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 crate::{
    app::App,
    views::{
        DayDetailView, DayDetailViewModel, HistoricalView, PlaceholderView, View, WelcomeView,
    },
};
use adw::prelude::*;
use chrono::{Duration, Local};
use emseries::Record;
use ft_core::TraxRecord;
use gio::resources_lookup_data;
use gtk::STYLE_PROVIDER_PRIORITY_USER;
use std::{cell::RefCell, path::PathBuf, rc::Rc};

/// The application window, or the main window, is the main user interface for the app. Almost
/// everything occurs here.
#[derive(Clone)]
pub struct AppWindow {
    app: App,
    layout: gtk::Box,
    current_view: Rc<RefCell<View>>,
    settings: gio::Settings,
    navigation: adw::NavigationView,
}

impl AppWindow {
    /// Construct a new App Window.
    ///
    /// adw_app is an Adwaita application. Application windows need to have access to this, but
    /// otherwise we don't use this.
    ///
    /// app is a core [crate::app::App] object which encapsulates all of the basic logic.
    pub fn new(
        app_id: &str,
        resource_path: &str,
        adw_app: &adw::Application,
        ft_app: App,
    ) -> AppWindow {
        let window = adw::ApplicationWindow::builder()
            .application(adw_app)
            .width_request(800)
            .height_request(600)
            .build();

        let stylesheet = String::from_utf8(
            resources_lookup_data(
                &format!("{}style.css", resource_path),
                gio::ResourceLookupFlags::NONE,
            )
            .expect("stylesheet must be available in the resources")
            .to_vec(),
        )
        .expect("to parse stylesheet");

        let provider = gtk::CssProvider::new();
        provider.load_from_data(&stylesheet);

        #[allow(deprecated)]
        let context = window.style_context();
        #[allow(deprecated)]
        context.add_provider(&provider, STYLE_PROVIDER_PRIORITY_USER);

        let navigation = adw::NavigationView::new();

        let layout = gtk::Box::builder()
            .orientation(gtk::Orientation::Vertical)
            .build();

        let initial_view = View::Placeholder(PlaceholderView::new().upcast());

        layout.append(&initial_view.widget());

        let nav_layout = gtk::Box::new(gtk::Orientation::Vertical, 0);
        nav_layout.append(&adw::HeaderBar::new());
        nav_layout.append(&layout);
        navigation.push(
            &adw::NavigationPage::builder()
                .can_pop(false)
                .title("FitnessTrax")
                .child(&nav_layout)
                .build(),
        );

        window.set_content(Some(&navigation));
        window.present();

        let gesture = gtk::GestureClick::new();
        gesture.connect_released(|_, _, _, _| println!("detected gesture"));
        layout.add_controller(gesture);

        let s = Self {
            app: ft_app,
            layout,
            current_view: Rc::new(RefCell::new(initial_view)),
            settings: gio::Settings::new(app_id),
            navigation,
        };

        s.load_records();

        s.navigation.connect_popped({
            let s = s.clone();
            move |_, _| match *s.current_view.borrow() {
                View::Historical(_) => s.load_records(),
                _ => {}
            }
        });

        s
    }

    fn show_welcome_view(&self) {
        let view = View::Welcome(WelcomeView::new({
            let s = self.clone();
            move |path| s.on_apply_config(path)
        }));
        self.swap_main(view);
    }

    fn show_historical_view(&self, records: Vec<Record<TraxRecord>>) {
        let view = View::Historical(HistoricalView::new(records, {
            let s = self.clone();
            Rc::new(move |date, records| {
                let layout = gtk::Box::new(gtk::Orientation::Vertical, 0);
                layout.append(&adw::HeaderBar::new());
                // layout.append(&DayDetailView::new(date, records, s.app.clone()));
                layout.append(&DayDetailView::new(DayDetailViewModel::new(
                    date,
                    records,
                    s.app.clone(),
                )));
                let page = &adw::NavigationPage::builder()
                    .title(date.format("%Y-%m-%d").to_string())
                    .child(&layout)
                    .build();
                s.navigation.push(page);
            })
        }));
        self.swap_main(view);
    }

    fn load_records(&self) {
        glib::spawn_future_local({
            let s = self.clone();
            async move {
                let end = Local::now().date_naive();
                let start = end - Duration::days(7);
                match s.app.records(start, end).await {
                    Ok(records) => s.show_historical_view(records),
                    Err(_) => s.show_welcome_view(),
                }
            }
        });
    }

    // Switch views.
    //
    // This function only replaces the old view with the one which matches the current view state.
    // It is responsible for ensuring that the new view goes into the layout in the correct
    // position.
    fn swap_main(&self, view: View) {
        let mut current_widget = self.current_view.borrow_mut();
        self.layout.remove(&current_widget.widget());
        *current_widget = view;
        self.layout.append(&current_widget.widget());
    }

    fn on_apply_config(&self, path: PathBuf) {
        glib::spawn_future_local({
            let s = self.clone();
            async move {
                if s.app.open_db(path.clone()).await.is_ok() {
                    let _ = s.settings.set("series-path", path.to_str().unwrap());
                    s.load_records();
                }
            }
        });
    }

    fn on_put_record(&self, record: TraxRecord) {
        glib::spawn_future_local({
            let s = self.clone();
            async move {
                s.app.put_record(record).await;
            }
        });
    }

    fn on_update_record(&self, record: Record<TraxRecord>) {
        glib::spawn_future_local({
            let s = self.clone();
            async move {
                s.app.update_record(record).await;
            }
        });
    }
}