// ABOUTME: Entry point for Moongreet — greetd greeter for Wayland.
// ABOUTME: Sets up GTK Application, Layer Shell, CSS, and multi-monitor windows.

mod config;
mod greeter;
mod i18n;
mod ipc;
mod power;
mod sessions;
mod users;

use gdk4 as gdk;
use gtk4::prelude::*;
use gtk4::{self as gtk, gio};
use gtk4_layer_shell::LayerShell;
use std::path::PathBuf;

fn load_css(display: &gdk::Display) {
    let css_provider = gtk::CssProvider::new();
    css_provider.load_from_resource("/dev/moonarch/moongreet/style.css");
    gtk::style_context_add_provider_for_display(
        display,
        &css_provider,
        gtk::STYLE_PROVIDER_PRIORITY_APPLICATION,
    );
}

fn setup_layer_shell(window: &gtk::ApplicationWindow, keyboard: bool) {
    window.init_layer_shell();
    window.set_layer(gtk4_layer_shell::Layer::Top);
    window.set_exclusive_zone(-1);
    if keyboard {
        window.set_keyboard_mode(gtk4_layer_shell::KeyboardMode::Exclusive);
    }
    // Anchor to all edges for fullscreen
    window.set_anchor(gtk4_layer_shell::Edge::Top, true);
    window.set_anchor(gtk4_layer_shell::Edge::Bottom, true);
    window.set_anchor(gtk4_layer_shell::Edge::Left, true);
    window.set_anchor(gtk4_layer_shell::Edge::Right, true);
}

fn activate(app: &gtk::Application) {
    let display = match gdk::Display::default() {
        Some(d) => d,
        None => {
            log::error!("No display available — cannot start greeter UI");
            return;
        }
    };

    load_css(&display);

    // Load config and resolve wallpaper
    let config = config::load_config(None);
    let bg_path = config::resolve_background_path(&config);

    let use_layer_shell = std::env::var("MOONGREET_NO_LAYER_SHELL").is_err();

    // Main greeter window (login UI) — compositor picks focused monitor
    let greeter_window = greeter::create_greeter_window(&bg_path, &config, app);
    if use_layer_shell {
        setup_layer_shell(&greeter_window, true);
    }
    greeter_window.present();

    // Wallpaper-only windows on all monitors (only with layer shell)
    if use_layer_shell {
        let monitors = display.monitors();
        for i in 0..monitors.n_items() {
            if let Some(monitor) = monitors
                .item(i)
                .and_then(|obj| obj.downcast::<gdk::Monitor>().ok())
            {
                let wallpaper = greeter::create_wallpaper_window(&bg_path, app);
                setup_layer_shell(&wallpaper, false);
                wallpaper.set_monitor(Some(&monitor));
                wallpaper.present();
            }
        }
    }
}

fn setup_logging() {
    let mut builder = env_logger::Builder::from_default_env();
    builder.filter_level(log::LevelFilter::Info);

    // Try file logging to /var/cache/moongreet/ — fall back to stderr
    let log_dir = PathBuf::from("/var/cache/moongreet");
    if log_dir.is_dir() {
        let log_file = log_dir.join("moongreet.log");
        if let Ok(file) = std::fs::OpenOptions::new()
            .create(true)
            .append(true)
            .open(&log_file)
        {
            builder.target(env_logger::Target::Pipe(Box::new(file)));
        }
    }

    builder.init();
}

fn main() {
    setup_logging();
    log::info!("Moongreet starting");

    // Register compiled GResources
    gio::resources_register_include!("moongreet.gresource").expect("Failed to register resources");

    let app = gtk::Application::builder()
        .application_id("dev.moonarch.moongreet")
        .build();

    app.connect_activate(activate);
    app.run();
}