pub use app::App;
use arboard::Clipboard;
use input::Input;
use iris::prelude::*;
use render::Renderer;
use winit::{event::WindowEvent, event_loop::ActiveEventLoop};

use crate::client::ui::{Submit, UiData};

mod app;
mod input;
mod render;
mod ui;

pub use app::AppHandle;

#[derive(Debug)]
pub enum ClientEvent {
    Connect,
}

pub struct Client {
    renderer: Renderer,
    input: Input,
    ui: Ui,
    focus: Option<WidgetId<TextEdit>>,
    ui_data: UiData,
    clipboard: Clipboard,
}

impl Client {
    pub fn new(handle: AppHandle) -> Self {
        let renderer = Renderer::new(handle.window.clone());

        let (ui, ui_data) = ui::ui(handle);

        Self {
            renderer,
            input: Input::default(),
            ui,
            ui_data,
            focus: None,
            clipboard: Clipboard::new().unwrap(),
        }
    }

    pub fn event(&mut self, event: ClientEvent, _: &ActiveEventLoop) {
        match event {
            ClientEvent::Connect => {
                self.ui.set_root(self.ui_data.main_view.clone());
            }
        }
    }

    pub fn window_event(&mut self, event: WindowEvent, event_loop: &ActiveEventLoop) {
        let input_changed = self.input.event(&event);
        let cursor_state = self.cursor_state().clone();
        if let Some(focus) = &self.focus
            && cursor_state.buttons.left.is_start()
        {
            self.ui.text(focus).deselect();
            self.focus = None;
        }
        if input_changed {
            let window_size = self.window_size();
            self.run_sensors(&cursor_state, window_size);
            self.ui.run_sensors(&cursor_state, window_size);
        }
        match event {
            WindowEvent::CloseRequested => event_loop.exit(),
            WindowEvent::RedrawRequested => {
                self.ui.update();
                self.renderer.update(&mut self.ui);
                self.renderer.draw()
            }
            WindowEvent::Resized(size) => {
                self.ui.resize((size.width, size.height));
                self.renderer.resize(&size)
            }
            WindowEvent::KeyboardInput { event, .. } => {
                if let Some(sel) = &self.focus
                    && event.state.is_pressed()
                {
                    let mut text = self.ui.text(sel);
                    match text.apply_event(&event, &self.input.modifiers) {
                        TextInputResult::Unfocus => {
                            self.focus = None;
                        }
                        TextInputResult::Submit => {
                            self.run_event(&sel.clone(), Submit, ());
                        }
                        TextInputResult::Paste => {
                            if let Ok(t) = self.clipboard.get_text() {
                                text.insert(&t);
                            }
                        }
                        TextInputResult::Unused | TextInputResult::Used => (),
                    }
                }
            }
            _ => (),
        }
        if self.ui.needs_redraw() {
            self.renderer.window().request_redraw();
        }
        self.input.end_frame();
    }
}

impl UiCtx for Client {
    fn ui(&mut self) -> &mut Ui {
        &mut self.ui
    }
}