use crate::backend::{BackendEvent, Output, OutputId};
use crate::drm::drm::{ConnectorStatus, ConnectorType, DrmBlob, DrmConnector, DrmCrtc, DrmEncoder, DrmError, DrmFb, DrmFramebuffer, DrmMaster, DrmModeInfo, DrmObject, DrmPlane, DrmProperty, DrmPropertyDefinition, DrmPropertyType, PropBlob, DRM_CLIENT_CAP_ATOMIC, DRM_MODE_ATOMIC_ALLOW_MODESET, DRM_MODE_ATOMIC_NONBLOCK, DRM_MODE_PAGE_FLIP_EVENT, DrmEvent};
use crate::drm::gbm::{GbmDevice, GBM_BO_USE_RENDERING, GBM_BO_USE_SCANOUT};
use crate::drm::{ModifiedFormat, INVALID_MODIFIER};
use crate::format::{Format, XRGB8888};
use crate::metal::{DrmId, MetalBackend, MetalError};
use crate::render::{Framebuffer, RenderContext};
use crate::utils::bitflags::BitflagsExt;
use crate::{CloneCell, ErrorFmt, NumCell, State};
use ahash::AHashMap;
use bstr::{BString, ByteSlice};
use std::cell::Cell;
use std::ffi::CString;
use std::fmt::{Debug, Formatter};
use std::rc::Rc;
use uapi::c;
use crate::async_engine::{AsyncFd, SpawnedFuture};

pub struct PendingDrmDevice {
    pub id: DrmId,
    pub devnum: c::dev_t,
    pub devnode: CString,
}

#[derive(Debug)]
pub struct MetalDrmDeviceStatic {
    pub id: DrmId,
    pub devnum: c::dev_t,
    pub devnode: CString,
    pub master: Rc<DrmMaster>,
    pub crtcs: AHashMap<DrmCrtc, Rc<MetalCrtc>>,
    pub encoders: AHashMap<DrmEncoder, Rc<MetalEncoder>>,
    pub planes: AHashMap<DrmPlane, Rc<MetalPlane>>,
    pub min_width: u32,
    pub max_width: u32,
    pub min_height: u32,
    pub max_height: u32,
    pub gbm: GbmDevice,
    pub egl: Rc<RenderContext>,
    pub async_fd: AsyncFd,
    pub handle_events: HandleEvents,
}

pub struct HandleEvents {
    pub handle_events: Cell<Option<SpawnedFuture<()>>>,
}

impl Debug for HandleEvents {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("HandleEvents").finish_non_exhaustive()
    }
}

#[derive(Debug)]
pub struct MetalDrmDevice {
    pub dev: Rc<MetalDrmDeviceStatic>,
    pub connectors: AHashMap<DrmConnector, Rc<MetalConnector>>,
}

#[derive(Debug)]
pub struct MetalConnector {
    pub id: DrmConnector,
    pub master: Rc<DrmMaster>,

    pub output_id: OutputId,

    pub crtcs: AHashMap<DrmCrtc, Rc<MetalCrtc>>,
    pub modes: Vec<DrmModeInfo>,
    pub mode: CloneCell<Option<Rc<DrmModeInfo>>>,

    pub buffers: CloneCell<Option<Rc<[RenderBuffer; 2]>>>,
    pub next_buffer: NumCell<usize>,

    pub connector_type: ConnectorType,
    pub connector_type_id: u32,

    pub connection: ConnectorStatus,
    pub mm_width: u32,
    pub mm_height: u32,
    pub subpixel: u32,

    pub primary_plane: CloneCell<Option<Rc<MetalPlane>>>,
    pub cursor_plane: Cell<DrmPlane>,

    pub crtc_id: MutableProperty<DrmCrtc>,

    pub egl_fb: CloneCell<Option<Rc<Framebuffer>>>,

    pub on_change: OnChange,
}

#[derive(Default)]
pub struct OnChange {
    pub on_change: CloneCell<Option<Rc<dyn Fn()>>>,
}

impl Debug for OnChange {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self.on_change.get() {
            None => f.write_str("None"),
            Some(_) => f.write_str("Some"),
        }
    }
}

impl Output for MetalConnector {
    fn id(&self) -> OutputId {
        self.output_id
    }

    fn removed(&self) -> bool {
        false
    }

    fn width(&self) -> i32 {
        match self.mode.get() {
            Some(m) => m.hdisplay as _,
            _ => 0,
        }
    }

    fn height(&self) -> i32 {
        match self.mode.get() {
            Some(m) => m.vdisplay as _,
            _ => 0,
        }
    }

    fn on_change(&self, cb: Rc<dyn Fn()>) {
        self.on_change.on_change.set(Some(cb));
    }
}

#[derive(Debug)]
pub struct MetalCrtc {
    pub id: DrmCrtc,
    pub idx: usize,
    pub master: Rc<DrmMaster>,

    pub possible_planes: AHashMap<DrmPlane, Rc<MetalPlane>>,

    pub connector: CloneCell<Option<Rc<MetalConnector>>>,

    pub active: MutableProperty<bool>,
    pub mode_id: MutableProperty<DrmBlob>,

    pub mode_blob: CloneCell<Option<Rc<PropBlob>>>,
}

#[derive(Debug)]
pub struct MetalEncoder {
    pub id: DrmEncoder,
    pub crtcs: AHashMap<DrmCrtc, Rc<MetalCrtc>>,
}

#[derive(Debug, Copy, Clone, Eq, PartialEq)]
pub enum PlaneType {
    Overlay,
    Primary,
    Cursor,
}

#[derive(Debug)]
pub struct MetalPlane {
    pub id: DrmPlane,
    pub master: Rc<DrmMaster>,

    pub ty: PlaneType,

    pub possible_crtcs: u32,
    pub formats: AHashMap<u32, &'static Format>,

    pub fb_id: MutableProperty<DrmFb>,
    pub crtc_id: MutableProperty<DrmCrtc>,
    pub crtc_x: MutableProperty<i32>,
    pub crtc_y: MutableProperty<i32>,
    pub crtc_w: MutableProperty<i32>,
    pub crtc_h: MutableProperty<i32>,
    pub src_x: MutableProperty<u32>,
    pub src_y: MutableProperty<u32>,
    pub src_w: MutableProperty<u32>,
    pub src_h: MutableProperty<u32>,
}

impl MetalDrmDevice {}

fn get_connectors(
    state: &State,
    dev: &MetalDrmDeviceStatic,
    ids: &[DrmConnector],
) -> Result<AHashMap<DrmConnector, Rc<MetalConnector>>, DrmError> {
    let mut connectors = AHashMap::new();
    for connector in ids {
        match create_connector(state, *connector, dev) {
            Ok(e) => {
                connectors.insert(e.id, Rc::new(e));
            }
            Err(e) => return Err(DrmError::CreateConnector(Box::new(e))),
        }
    }
    Ok(connectors)
}

fn create_connector(
    state: &State,
    connector: DrmConnector,
    dev: &MetalDrmDeviceStatic,
) -> Result<MetalConnector, DrmError> {
    let info = dev.master.get_connector_info(connector, true)?;
    let mut crtcs = AHashMap::new();
    for encoder in info.encoders {
        if let Some(encoder) = dev.encoders.get(&encoder) {
            for (_, crtc) in &encoder.crtcs {
                crtcs.insert(crtc.id, crtc.clone());
            }
        }
    }
    let props = collect_properties(&dev.master, connector)?;
    Ok(MetalConnector {
        id: connector,
        master: dev.master.clone(),
        output_id: state.output_ids.next(),
        crtcs,
        modes: info.modes,
        mode: Default::default(),
        buffers: Default::default(),
        next_buffer: Default::default(),
        connector_type: info.connector_type.into(),
        connector_type_id: info.connector_type_id,
        connection: info.connection.into(),
        mm_width: info.mm_width,
        mm_height: info.mm_height,
        subpixel: info.subpixel,
        primary_plane: Default::default(),
        cursor_plane: Default::default(),
        crtc_id: props.get("CRTC_ID")?.map(|v| DrmCrtc(v as _)),
        egl_fb: Default::default(),
        on_change: Default::default(),
    })
}

fn create_encoder(
    encoder: DrmEncoder,
    master: &Rc<DrmMaster>,
    crtcs: &AHashMap<DrmCrtc, Rc<MetalCrtc>>,
) -> Result<MetalEncoder, DrmError> {
    let info = master.get_encoder_info(encoder)?;
    let mut possible = AHashMap::new();
    for crtc in crtcs.values() {
        if info.possible_crtcs.contains(1 << crtc.idx) {
            possible.insert(crtc.id, crtc.clone());
        }
    }
    Ok(MetalEncoder {
        id: encoder,
        crtcs: possible,
    })
}

fn create_crtc(
    crtc: DrmCrtc,
    idx: usize,
    master: &Rc<DrmMaster>,
    planes: &AHashMap<DrmPlane, Rc<MetalPlane>>,
) -> Result<MetalCrtc, DrmError> {
    let mask = 1 << idx;
    let mut possible_planes = AHashMap::new();
    for plane in planes.values() {
        if plane.possible_crtcs.contains(mask) {
            possible_planes.insert(plane.id, plane.clone());
        }
    }
    let props = collect_properties(master, crtc)?;
    Ok(MetalCrtc {
        id: crtc,
        idx,
        master: master.clone(),
        possible_planes,
        connector: Default::default(),
        active: props.get("ACTIVE")?.map(|v| v == 1),
        mode_id: props.get("MODE_ID")?.map(|v| DrmBlob(v as u32)),
        mode_blob: Default::default(),
    })
}

fn create_plane(plane: DrmPlane, master: &Rc<DrmMaster>) -> Result<MetalPlane, DrmError> {
    let info = master.get_plane_info(plane)?;
    let mut formats = AHashMap::new();
    for format in info.format_types {
        if let Some(f) = crate::format::formats().get(&format) {
            formats.insert(format, *f);
        } else {
            // log::warn!(
            //     "{:?} supports unknown format '{:?}'",
            //     plane,
            //     crate::format::debug(format)
            // );
        }
    }
    let props = collect_properties(master, plane)?;
    let ty = match props.props.get(b"type".as_bstr()) {
        Some((def, val)) => match &def.ty {
            DrmPropertyType::Enum { values, .. } => 'ty: {
                for v in values {
                    if v.value == *val {
                        match v.name.as_bytes() {
                            b"Overlay" => break 'ty PlaneType::Overlay,
                            b"Primary" => break 'ty PlaneType::Primary,
                            b"Cursor" => break 'ty PlaneType::Cursor,
                            _ => return Err(DrmError::UnknownPlaneType(v.name.to_owned())),
                        }
                    }
                }
                return Err(DrmError::InvalidPlaneType(*val));
            }
            _ => return Err(DrmError::InvalidPlaneTypeProperty),
        },
        _ => {
            return Err(DrmError::MissingProperty(
                "type".to_string().into_boxed_str(),
            ))
        }
    };
    Ok(MetalPlane {
        id: plane,
        master: master.clone(),
        ty,
        possible_crtcs: info.possible_crtcs,
        formats,
        fb_id: props.get("FB_ID")?.map(|v| DrmFb(v as _)),
        crtc_id: props.get("CRTC_ID")?.map(|v| DrmCrtc(v as _)),
        crtc_x: props.get("CRTC_X")?.map(|v| v as i32),
        crtc_y: props.get("CRTC_Y")?.map(|v| v as i32),
        crtc_w: props.get("CRTC_W")?.map(|v| v as i32),
        crtc_h: props.get("CRTC_H")?.map(|v| v as i32),
        src_x: props.get("SRC_X")?.map(|v| v as u32),
        src_y: props.get("SRC_Y")?.map(|v| v as u32),
        src_w: props.get("SRC_W")?.map(|v| v as u32),
        src_h: props.get("SRC_H")?.map(|v| v as u32),
    })
}

fn collect_properties<T: DrmObject>(
    master: &Rc<DrmMaster>,
    t: T,
) -> Result<CollectedProperties, DrmError> {
    let mut props = AHashMap::new();
    for prop in master.get_properties(t)? {
        let def = master.get_property(prop.id)?;
        props.insert(def.name.clone(), (def, prop.value));
    }
    Ok(CollectedProperties { props })
}

struct CollectedProperties {
    props: AHashMap<BString, (DrmPropertyDefinition, u64)>,
}

impl CollectedProperties {
    fn get(&self, name: &str) -> Result<MutableProperty<u64>, DrmError> {
        match self.props.get(name.as_bytes().as_bstr()) {
            Some((def, value)) => Ok(MutableProperty {
                id: def.id,
                value: Cell::new(*value),
            }),
            _ => Err(DrmError::MissingProperty(name.to_string().into_boxed_str())),
        }
    }
}

#[derive(Debug)]
pub struct MutableProperty<T: Copy> {
    pub id: DrmProperty,
    pub value: Cell<T>,
}

impl<T: Copy> MutableProperty<T> {
    fn map<U: Copy, F>(self, f: F) -> MutableProperty<U>
    where
        F: FnOnce(T) -> U,
    {
        MutableProperty {
            id: self.id,
            value: Cell::new(f(self.value.into_inner())),
        }
    }
}

impl MetalBackend {
    pub fn creat_drm_device(
        self: &Rc<Self>,
        pending: PendingDrmDevice,
        master: &Rc<DrmMaster>,
    ) -> Result<Rc<MetalDrmDevice>, MetalError> {
        if let Err(e) = master.set_client_cap(DRM_CLIENT_CAP_ATOMIC, 2) {
            return Err(MetalError::AtomicModesetting(e));
        }
        let resources = master.get_resources()?;

        let mut planes = AHashMap::new();
        for plane in master.get_planes()? {
            match create_plane(plane, master) {
                Ok(p) => {
                    planes.insert(p.id, Rc::new(p));
                }
                Err(e) => return Err(MetalError::CreatePlane(e)),
            }
        }

        let mut crtcs = AHashMap::new();
        for (idx, crtc) in resources.crtcs.iter().copied().enumerate() {
            match create_crtc(crtc, idx, master, &planes) {
                Ok(c) => {
                    crtcs.insert(c.id, Rc::new(c));
                }
                Err(e) => return Err(MetalError::CreateCrtc(e)),
            }
        }

        let mut encoders = AHashMap::new();
        for encoder in resources.encoders {
            match create_encoder(encoder, master, &crtcs) {
                Ok(e) => {
                    encoders.insert(e.id, Rc::new(e));
                }
                Err(e) => return Err(MetalError::CreateEncoder(e)),
            }
        }

        let gbm = match GbmDevice::new(master) {
            Ok(g) => g,
            Err(e) => return Err(MetalError::GbmDevice(e)),
        };
        let egl = match RenderContext::from_drm_device(master) {
            Ok(r) => Rc::new(r),
            Err(e) => return Err(MetalError::CreateRenderContex(e)),
        };
        let async_fd = match self.state.eng.fd(master.fd()) {
            Ok(f) => f,
            Err(e) => return Err(MetalError::CreateDrmAsyncFd(e)),
        };

        let dev = Rc::new(MetalDrmDeviceStatic {
            id: pending.id,
            devnum: pending.devnum,
            devnode: pending.devnode,
            master: master.clone(),
            crtcs,
            encoders,
            planes,
            min_width: resources.min_width,
            max_width: resources.max_width,
            min_height: resources.min_height,
            max_height: resources.max_height,
            gbm,
            egl: egl.clone(),
            async_fd,
            handle_events: HandleEvents {
                handle_events: Cell::new(None),
            },
        });

        let connectors = get_connectors(&self.state, &dev, &resources.connectors)?;

        let slf = Rc::new(MetalDrmDevice {
            dev,
            connectors,
        });

        self.reset_drm_device(&slf)?;

        let handler = self.state.eng.spawn(self.clone().handle_drm_events(slf.clone()));
        slf.dev.handle_events.handle_events.set(Some(handler));

        self.state.render_ctx.set(Some(egl));

        Ok(slf)
    }

    async fn handle_drm_events(self: Rc<Self>, dev: Rc<MetalDrmDevice>) {
        loop {
            if let Err(e) = dev.dev.async_fd.readable().await {
                log::error!("Could not register the DRM fd for reading: {}", ErrorFmt(e));
                break;
            }
            loop {
                match dev.dev.master.event() {
                    Ok(Some(e)) => self.handle_drm_event(e, &dev),
                    Ok(None) => break,
                    Err(e) => {
                        log::error!("Could not read DRM event: {}", ErrorFmt(e));
                        return;
                    }
                }
            }
        }
    }

    fn handle_drm_event(self: &Rc<Self>, event: DrmEvent, dev: &Rc<MetalDrmDevice>) {
        match event {
            DrmEvent::FlipComplete { tv_sec, tv_usec, sequence, crtc_id } => self.handle_drm_flip_event(
                dev, crtc_id, tv_sec, tv_usec, sequence
            ),
        }
    }

    fn handle_drm_flip_event(self: &Rc<Self>, dev: &Rc<MetalDrmDevice>, crtc_id: DrmCrtc, _tv_sec: u32, _tv_usec: u32, _sequence: u32) {
        let crtc = match dev.dev.crtcs.get(&crtc_id) {
            Some(c) => c,
            _ => return,
        };
        let connector = match crtc.connector.get() {
            Some(c) => c,
            _ => return,
        };
        self.present(&connector);
    }

    fn reset_drm_device(&self, dev: &MetalDrmDevice) -> Result<(), DrmError> {
        let mut changes = dev.dev.master.change(DRM_MODE_ATOMIC_ALLOW_MODESET);
        for connector in dev.connectors.values() {
            if connector.crtc_id.value.take().is_some() {
                changes.change_object(connector.id, |c| {
                    c.change(connector.crtc_id.id, 0);
                })
            }
        }
        for plane in dev.dev.planes.values() {
            changes.change_object(plane.id, |c| {
                if plane.crtc_id.value.take().is_some() {
                    c.change(plane.crtc_id.id, 0);
                }
                if plane.fb_id.value.take().is_some() {
                    c.change(plane.fb_id.id, 0);
                }
            })
        }
        for crtc in dev.dev.crtcs.values() {
            changes.change_object(crtc.id, |c| {
                if crtc.active.value.take() {
                    c.change(crtc.active.id, 0);
                }
                if crtc.mode_id.value.take().is_some() {
                    c.change(crtc.mode_id.id, 0);
                }
            })
        }
        if let Err(e) = changes.commit(0) {
            return Err(DrmError::ResetFailed(Box::new(e)));
        }
        Ok(())
    }

    pub fn init_drm_device(&self, dev: &Rc<MetalDrmDevice>) {
        for connector in dev.connectors.values() {
            if let Err(e) = self.init_drm_connector(dev, connector) {
                log::error!("Could not initialize drm connector: {}", ErrorFmt(e));
            }
        }
    }

    fn create_scanout_buffers(&self, dev: &Rc<MetalDrmDevice>, connector: &Rc<MetalConnector>, format: &ModifiedFormat, width: i32, height: i32) -> Result<[RenderBuffer; 2], MetalError> {
        let create = || self.create_scanout_buffer(dev, connector, format, width, height);
        Ok([
            create()?,
            create()?,
        ])
    }

    fn create_scanout_buffer(&self, dev: &Rc<MetalDrmDevice>, connector: &Rc<MetalConnector>, format: &ModifiedFormat, width: i32, height: i32) -> Result<RenderBuffer, MetalError> {
        let bo = dev.dev.gbm.create_bo(
            width,
            height,
            &format,
            GBM_BO_USE_RENDERING | GBM_BO_USE_SCANOUT,
        );
        let bo = match bo {
            Ok(b) => b,
            Err(e) => return Err(MetalError::ScanoutBuffer(e)),
        };
        let drm_fb = match connector.master.add_fb(&bo) {
            Ok(fb) => Rc::new(fb),
            Err(e) => return Err(MetalError::Framebuffer(e)),
        };
        let egl_fb = match dev.dev.egl.dmabuf_fb(&bo.dma()) {
            Ok(fb) => fb,
            Err(e) => return Err(MetalError::ImportFb(e)),
        };
        Ok(RenderBuffer {
            drm: drm_fb,
            egl: egl_fb,
        })
    }

    fn init_drm_connector(
        &self,
        dev: &Rc<MetalDrmDevice>,
        connector: &Rc<MetalConnector>,
    ) -> Result<(), MetalError> {
        if connector.connection != ConnectorStatus::Connected {
            return Ok(());
        }
        let crtc = 'crtc: {
            for crtc in connector.crtcs.values() {
                if crtc.connector.get().is_none() {
                    break 'crtc crtc.clone();
                }
            }
            return Err(MetalError::NoCrtcForConnector);
        };
        let primary_plane = 'plane: {
            for plane in crtc.possible_planes.values() {
                if plane.ty == PlaneType::Primary
                    && plane.crtc_id.value.get().is_none()
                    && plane.formats.contains_key(&XRGB8888.drm)
                {
                    break 'plane plane.clone();
                }
            }
            return Err(MetalError::NoPrimaryPlaneForConnector);
        };
        let mode = match connector.modes.first() {
            Some(m) => m,
            _ => return Err(MetalError::NoModeForConnector),
        };
        let mode_blob = mode.create_blob(&connector.master)?;
        let format = ModifiedFormat {
            format: XRGB8888,
            modifier: INVALID_MODIFIER,
        };
        let buffers = self.create_scanout_buffers(dev, connector, &format, mode.hdisplay as _, mode.vdisplay as _)?;
        let mut changes = connector.master.change(DRM_MODE_ATOMIC_ALLOW_MODESET);
        changes.change_object(connector.id, |c| {
            c.change(connector.crtc_id.id, crtc.id.0 as _);
        });
        changes.change_object(crtc.id, |c| {
            c.change(crtc.active.id, 1);
            c.change(crtc.mode_id.id, mode_blob.id().0 as _);
        });
        changes.change_object(primary_plane.id, |c| {
            c.change(primary_plane.fb_id.id, buffers[0].drm.id().0 as _);
            c.change(primary_plane.crtc_id.id, crtc.id.0 as _);
            c.change(primary_plane.crtc_x.id, 0);
            c.change(primary_plane.crtc_y.id, 0);
            c.change(primary_plane.crtc_w.id, mode.hdisplay as _);
            c.change(primary_plane.crtc_h.id, mode.vdisplay as _);
            c.change(primary_plane.src_x.id, 0);
            c.change(primary_plane.src_y.id, 0);
            c.change(primary_plane.src_w.id, (mode.hdisplay as u64) << 16);
            c.change(primary_plane.src_h.id, (mode.vdisplay as u64) << 16);
        });
        if let Err(e) = changes.commit(0) {
            return Err(MetalError::Configure(e));
        }
        primary_plane.fb_id.value.set(buffers[0].drm.id());
        primary_plane.crtc_id.value.set(crtc.id);
        primary_plane.crtc_x.value.set(0);
        primary_plane.crtc_y.value.set(0);
        primary_plane.crtc_w.value.set(mode.hdisplay as _);
        primary_plane.crtc_h.value.set(mode.vdisplay as _);
        primary_plane.src_x.value.set(0);
        primary_plane.src_y.value.set(0);
        primary_plane.src_w.value.set((mode.hdisplay as u32) << 16);
        primary_plane.src_h.value.set((mode.vdisplay as u32) << 16);
        connector.crtc_id.value.set(crtc.id);
        connector.mode.set(Some(Rc::new(mode.clone())));
        connector.buffers.set(Some(Rc::new(buffers)));
        connector.primary_plane.set(Some(primary_plane.clone()));
        crtc.connector.set(Some(connector.clone()));
        crtc.active.value.set(true);
        crtc.mode_id.value.set(mode_blob.id());
        crtc.mode_blob.set(Some(Rc::new(mode_blob)));
        self.state
            .backend_events
            .push(BackendEvent::NewOutput(connector.clone()));
        log::info!(
            "Initialized connector {}-{} with mode {:?}",
            connector.connector_type,
            connector.connector_type_id,
            mode
        );
        self.present(connector);
        Ok(())
    }

    fn present(&self, connector: &Rc<MetalConnector>) {
        let buffers = match connector.buffers.get() {
            None => return,
            Some(b) => b,
        };
        let plane = match connector.primary_plane.get() {
            Some(p) => p,
            _ => return,
        };
        let buffer = &buffers[connector.next_buffer.fetch_add(1) % buffers.len()];
        if let Some(node) = self.state.root.outputs.get(&connector.output_id) {
            buffer.egl.render(&*node, &self.state, Some(node.position.get()));
        }
        let mut changes = connector.master.change(DRM_MODE_ATOMIC_NONBLOCK | DRM_MODE_PAGE_FLIP_EVENT);
        changes.change_object(plane.id, |c| {
            c.change(plane.fb_id.id, buffer.drm.id().0 as _);
        });
        if let Err(e) = changes.commit(0) {
            log::error!("Could not set plane framebuffer: {}", ErrorFmt(e));
        }
    }
}

#[derive(Debug)]
pub struct RenderBuffer {
    drm: Rc<DrmFramebuffer>,
    egl: Rc<Framebuffer>,
}