use std::rc::Rc;

use wl_proxy::protocols::{
    wayland::{wl_output::WlOutput, wl_surface::WlSurface},
    xdg_shell::{
        xdg_popup::XdgPopup,
        xdg_positioner::XdgPositioner,
        xdg_surface::{XdgSurface, XdgSurfaceHandler},
        xdg_toplevel::{XdgToplevel, XdgToplevelHandler, XdgToplevelState},
        xdg_wm_base::{XdgWmBase, XdgWmBaseHandler},
    },
};

use crate::{deco::Deco, globals::Globals};

pub struct ClientXdgWmBase {
    pub globals: Rc<Globals>,
}

impl XdgWmBaseHandler for ClientXdgWmBase {
    fn handle_get_xdg_surface(
        &mut self,
        slf: &Rc<XdgWmBase>,
        id: &Rc<XdgSurface>,
        surface: &Rc<WlSurface>,
    ) {
        id.set_handler(ClientXdgSurface {
            deco: Rc::new(Deco::new(surface, &self.globals)),
        });
        slf.send_get_xdg_surface(id, surface);
    }
}

struct ClientXdgSurface {
    deco: Rc<Deco>,
}

impl XdgSurfaceHandler for ClientXdgSurface {
    fn handle_get_toplevel(&mut self, slf: &Rc<XdgSurface>, id: &Rc<XdgToplevel>) {
        id.set_handler(ClientXdgToplevel::new(&self.deco));
        slf.send_get_toplevel(id);
    }

    fn handle_get_popup(
        &mut self,
        slf: &Rc<XdgSurface>,
        id: &Rc<XdgPopup>,
        parent: Option<&Rc<XdgSurface>>,
        positioner: &Rc<XdgPositioner>,
    ) {
        // if let Some(parent) = parent {
        //     let handler = parent.get_handler_ref::<ClientXdgSurface>();
        //     self.deco.subsurface.send_place_below(&handler.wl_surface);
        // } welp sad
        slf.send_get_popup(id, parent, positioner);
    }

    fn handle_set_window_geometry(
        &mut self,
        slf: &Rc<XdgSurface>,
        x: i32,
        y: i32,
        width: i32,
        height: i32,
    ) {
        let (x, y, width, height) = self
            .deco
            .handle_window_geometry(x, y, width, height)
            .unwrap();
        slf.send_set_window_geometry(x, y, width, height);
    }

    fn handle_ack_configure(&mut self, slf: &Rc<XdgSurface>, serial: u32) {
        slf.send_ack_configure(serial);
    }

    fn handle_configure(&mut self, slf: &Rc<XdgSurface>, serial: u32) {
        slf.send_configure(serial);
    }
}

struct ClientXdgToplevel {
    deco: Rc<Deco>,
}

impl ClientXdgToplevel {
    fn new(deco: &Rc<Deco>) -> ClientXdgToplevel {
        ClientXdgToplevel { deco: deco.clone() }
    }
}

impl XdgToplevelHandler for ClientXdgToplevel {
    fn handle_set_title(&mut self, slf: &Rc<XdgToplevel>, title: &str) {
        slf.send_set_title(title);
    }

    fn handle_set_max_size(&mut self, slf: &Rc<XdgToplevel>, width: i32, height: i32) {
        slf.send_set_max_size(width, height);
    }

    fn handle_set_min_size(&mut self, slf: &Rc<XdgToplevel>, width: i32, height: i32) {
        slf.send_set_min_size(width, height);
    }

    fn handle_set_maximized(&mut self, slf: &Rc<XdgToplevel>) {
        slf.send_set_maximized();
    }

    fn handle_unset_maximized(&mut self, slf: &Rc<XdgToplevel>) {
        slf.send_unset_maximized();
    }

    fn handle_set_fullscreen(&mut self, slf: &Rc<XdgToplevel>, output: Option<&Rc<WlOutput>>) {
        slf.send_set_fullscreen(output);
    }

    fn handle_unset_fullscreen(&mut self, slf: &Rc<XdgToplevel>) {
        slf.send_unset_fullscreen();
    }

    fn handle_configure(&mut self, slf: &Rc<XdgToplevel>, width: i32, height: i32, _states: &[u8]) {
        let states = (1u64 << 32 | XdgToplevelState::TILED_TOP.0 as u64).to_ne_bytes();
        let (width, height) = self.deco.transform_configure(width, height);
        slf.send_configure(width, height, &states[..]);
    }

    fn handle_configure_bounds(&mut self, slf: &Rc<XdgToplevel>, width: i32, height: i32) {
        slf.send_configure_bounds(width, height);
    }
}