#![feature(async_fn_traits)]
#![windows_subsystem = "windows"]

use crate::{data::ClientData, state::ClientState};
use iris::prelude::*;
use openworm::net::{ServerMsg, install_crypto_provider};
use winit::{
    event::{ElementState, MouseButton, WindowEvent},
    window::WindowAttributes,
};

mod account;
mod data;
mod debug;
mod net;
mod state;
mod ui;

fn main() {
    install_crypto_provider();
    DefaultApp::<Client>::run();
}

#[derive(DefaultUiState)]
pub struct Client {
    ui_state: DefaultUiState,
    data: ClientData,
    state: ClientState,
    main_ui: WeakWidget<WidgetPtr>,
    notif: WeakWidget<WidgetPtr>,
    proxy: Proxy<ClientEvent>,
}

pub type Rsc = DefaultRsc<Client>;

pub enum ClientEvent {
    ServerMsg(ServerMsg),
    Err(String),
}

impl DefaultAppState for Client {
    type Event = ClientEvent;

    fn new(
        mut ui_state: DefaultUiState,
        rsc: &mut DefaultRsc<Self>,
        proxy: Proxy<Self::Event>,
    ) -> Self {
        let notif = WidgetPtr::default().add(rsc);
        let main_ui = WidgetPtr::default().add(rsc);
        let bg = (
            image(include_bytes!("./assets/fuit.jpg")),
            rect(Color::BLACK.alpha((0.8 * 255.0) as u8)),
        )
            .stack();

        (
            bg,
            main_ui,
            notif.pad(Padding::top(10)).align(Align::TOP_CENTER),
        )
            .stack()
            .set_root(rsc, &mut ui_state);

        let data = ClientData::load();
        ui::start(rsc, &data).set_ptr(main_ui, rsc);

        Self {
            ui_state,
            data,
            state: Default::default(),
            main_ui,
            notif,
            proxy,
        }
    }

    fn event(
        &mut self,
        event: Self::Event,
        rsc: &mut DefaultRsc<Self>,
        _render: &mut UiRenderState,
    ) {
        match event {
            ClientEvent::ServerMsg(_) => {}
            ClientEvent::Err(msg) => {
                rsc[self.notif].inner = Some(ui::werror(&msg, rsc));
            }
        }
    }

    fn exit(&mut self, _rsc: &mut DefaultRsc<Self>, _render: &mut UiRenderState) {
        self.state.exit();
    }

    fn window_event(
        &mut self,
        event: WindowEvent,
        rsc: &mut DefaultRsc<Self>,
        render: &mut UiRenderState,
    ) {
        if let WindowEvent::MouseInput {
            state: ElementState::Pressed,
            button: MouseButton::Middle,
            ..
        } = event
        {
            self.debug(rsc, render);
        }
    }

    fn window_attributes() -> WindowAttributes {
        WindowAttributes::default().with_title("OPENWORM")
    }
}