use slint::{winit_030::WinitWindowAccessor, ComponentHandle, PlatformError, Timer, Weak};
use std::time::Duration;
slint::include_modules!();

fn main() -> Result<(), slint::PlatformError> {
    slint::BackendSelector::new()
        .backend_name("winit".into())
        .select()?;
    let window_1 = AppWindow::new()?;

    let window_2 = AppWindow::new()?;

    window_1
        .window()
        .set_rendering_notifier(|e, g| println!("rendering window 1: {:?}", e))
        .unwrap();

    window_2
        .window()
        .set_rendering_notifier(|e, g| println!("rendering window 2: {:?}", e))
        .unwrap();

    window_1.on_show_settings(|| {
        let dialog = SettingsDialog::new().unwrap();
        dialog.show().unwrap();
    });
    window_1.show()?;
    window_2.show()?;
    let windows = vec![window_1.as_weak(), window_2.as_weak()];
    let timer = Timer::default();
    let mut counter1 = 0;
    timer.start(
        slint::TimerMode::Repeated,
        Duration::from_millis(16),
        move || {
            force_redraw_all_windows(&windows, &mut counter1).unwrap();
        },
    );

    slint::run_event_loop()?;
    Ok(())
}

fn force_redraw_all_windows(
    windows: &[Weak<AppWindow>],
    counter: &mut i32,
) -> Result<(), PlatformError> {
    for weak_window in windows {
        if let Some(window) = weak_window.upgrade() {
            window
                .window()
                .with_winit_window(|winit_window: &winit::window::Window| {
                    winit_window.request_redraw();
                    *counter += 1;
                    winit_window.set_title(&format!("{}", counter));
                    eprintln!("window id = {:#?}", winit_window.id());
                    eprintln!("Counter value: {}", counter);
                });
        }
    }
    Ok(())
}

use winit::event::{Event, WindowEvent};
use winit::event_loop::{ControlFlow, EventLoop};
use winit::window::WindowBuilder;

fn main() {
    let event_loop = EventLoop::new();
    let window1 = WindowBuilder::new()
        .with_title("Window 1")
        .build(&event_loop)
        .unwrap();
    let window2 = WindowBuilder::new()
        .with_title("Window 2")
        .build(&event_loop)
        .unwrap();

    let mut counter1 = 0;
    let mut counter2 = 0;

    event_loop.run(move |event, _, control_flow| {
        *control_flow = ControlFlow::Poll;
        match event {
            Event::WindowEvent {
                event: WindowEvent::CloseRequested,
                ..
            } => {
                *control_flow = ControlFlow::Exit;
            }
            Event::MainEventsCleared => {
                counter1 += 1;
                counter2 += 1;
                window1.set_title(&format!("Window 1: {}", counter1));
                window2.set_title(&format!("Window 2: {}", counter2));
                window1.request_redraw();
                window2.request_redraw();
            }
            Event::RedrawRequested(id) => {
                // Add basic rendering logic here if needed
                println!("Redraw requested for window_{:?}", id);
            }
            _ => {}
        }
    });
}