// SPDX-License-Identifier: GPL-3.0-only

use crate::utils::prelude::*;
use smithay::{
    backend::{
        allocator::Fourcc,
        renderer::{
            element::{
                surface::{render_elements_from_surface_tree, WaylandSurfaceRenderElement},
                texture::{TextureBuffer, TextureRenderElement},
                Kind,
            },
            ImportAll, ImportMem, Renderer,
        },
    },
    input::{
        pointer::{CursorImageAttributes, CursorImageStatus},
        Seat,
    },
    reexports::wayland_server::protocol::wl_surface,
    render_elements,
    utils::{IsAlive, Logical, Monotonic, Point, Scale, Time, Transform},
    wayland::compositor::{get_role, with_states},
};
use std::{
    any::{Any, TypeId},
    cell::RefCell,
    collections::HashMap,
    io::Read,
    sync::Mutex,
    time::Duration,
};
use tracing::warn;
use xcursor::{
    parser::{parse_xcursor, Image},
    CursorTheme,
};

static FALLBACK_CURSOR_DATA: &[u8] = include_bytes!("../../../resources/cursor.rgba");

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum CursorShape {
    Default,
    ColResize,
    RowResize,
    Grab,
}

impl ToString for CursorShape {
    fn to_string(&self) -> String {
        match self {
            CursorShape::Default => "default",
            CursorShape::ColResize => "col-resize",
            CursorShape::RowResize => "row-resize",
            CursorShape::Grab => "grabbing",
        }
        .to_string()
    }
}

#[derive(Debug, Clone)]
pub struct Cursor {
    icons: Vec<Image>,
    size: u32,
}

impl Cursor {
    pub fn load(theme: &CursorTheme, shape: CursorShape, size: u32) -> Cursor {
        let icons = load_icon(&theme, shape)
            .map_err(|err| warn!(?err, "Unable to load xcursor, using fallback cursor"))
            .unwrap_or_else(|_| {
                vec![Image {
                    size: 32,
                    width: 64,
                    height: 64,
                    xhot: 1,
                    yhot: 1,
                    delay: 1,
                    pixels_rgba: Vec::from(FALLBACK_CURSOR_DATA),
                    pixels_argb: vec![], //unused
                }]
            });

        Cursor { icons, size }
    }

    pub fn get_image(&self, scale: u32, millis: u32) -> Image {
        let size = self.size * scale;
        frame(millis, size, &self.icons)
    }
}

fn nearest_images(size: u32, images: &[Image]) -> impl Iterator<Item = &Image> {
    // Follow the nominal size of the cursor to choose the nearest
    let nearest_image = images
        .iter()
        .min_by_key(|image| (size as i32 - image.size as i32).abs())
        .unwrap();

    images.iter().filter(move |image| {
        image.width == nearest_image.width && image.height == nearest_image.height
    })
}

fn frame(mut millis: u32, size: u32, images: &[Image]) -> Image {
    let total = nearest_images(size, images).fold(0, |acc, image| acc + image.delay);
    millis %= total;

    for img in nearest_images(size, images) {
        if millis < img.delay {
            return img.clone();
        }
        millis -= img.delay;
    }

    unreachable!()
}

#[derive(thiserror::Error, Debug)]
enum Error {
    #[error("Theme has no default cursor")]
    NoDefaultCursor,
    #[error("Error opening xcursor file: {0}")]
    File(#[from] std::io::Error),
    #[error("Failed to parse XCursor file")]
    Parse,
}

fn load_icon(theme: &CursorTheme, shape: CursorShape) -> Result<Vec<Image>, Error> {
    let icon_path = theme
        .load_icon(&shape.to_string())
        .ok_or(Error::NoDefaultCursor)?;
    let mut cursor_file = std::fs::File::open(&icon_path)?;
    let mut cursor_data = Vec::new();
    cursor_file.read_to_end(&mut cursor_data)?;
    parse_xcursor(&cursor_data).ok_or(Error::Parse)
}

render_elements! {
    pub CursorRenderElement<R> where R: ImportAll;
    Static=TextureRenderElement<<R as Renderer>::TextureId>,
    Surface=WaylandSurfaceRenderElement<R>,
}

pub fn draw_surface_cursor<R>(
    renderer: &mut R,
    surface: &wl_surface::WlSurface,
    location: impl Into<Point<i32, Logical>>,
    scale: impl Into<Scale<f64>>,
) -> Vec<CursorRenderElement<R>>
where
    R: Renderer + ImportAll,
    <R as Renderer>::TextureId: 'static,
{
    let mut position = location.into();
    let scale = scale.into();
    let h = with_states(&surface, |states| {
        states
            .data_map
            .get::<Mutex<CursorImageAttributes>>()
            .unwrap()
            .lock()
            .unwrap()
            .hotspot
    });
    position -= h;

    render_elements_from_surface_tree(
        renderer,
        surface,
        position.to_physical_precise_round(scale),
        scale,
        1.0,
        Kind::Cursor,
    )
}

pub fn draw_dnd_icon<R>(
    renderer: &mut R,
    surface: &wl_surface::WlSurface,
    location: impl Into<Point<i32, Logical>>,
    scale: impl Into<Scale<f64>>,
) -> Vec<CursorRenderElement<R>>
where
    R: Renderer + ImportAll,
    <R as Renderer>::TextureId: 'static,
{
    #[cfg(feature = "debug")]
    puffin::profile_function!();

    if get_role(&surface) != Some("dnd_icon") {
        warn!(
            ?surface,
            "Trying to display as a dnd icon a surface that does not have the DndIcon role."
        );
    }
    let scale = scale.into();
    render_elements_from_surface_tree(
        renderer,
        surface,
        location.into().to_physical_precise_round(scale),
        scale,
        1.0,
        Kind::Cursor,
    )
}

pub struct CursorState {
    current_cursor: RefCell<CursorShape>,
    pub cursors: HashMap<CursorShape, Cursor>,
    current_image: RefCell<Option<Image>>,
    image_cache: RefCell<HashMap<(TypeId, usize), Vec<(Image, Box<dyn Any + 'static>)>>>,
}

impl CursorState {
    pub fn set_shape(&self, shape: CursorShape) {
        *self.current_cursor.borrow_mut() = shape;
    }
}

pub fn load_cursor_theme() -> (CursorTheme, u32) {
    let name = std::env::var("XCURSOR_THEME")
        .ok()
        .unwrap_or_else(|| "default".into());
    let size = std::env::var("XCURSOR_SIZE")
        .ok()
        .and_then(|s| s.parse().ok())
        .unwrap_or(24);
    (CursorTheme::load(&name), size)
}

impl Default for CursorState {
    fn default() -> CursorState {
        let (theme, size) = load_cursor_theme();
        CursorState {
            current_cursor: RefCell::new(CursorShape::Default),
            cursors: {
                let mut map = HashMap::new();
                map.insert(
                    CursorShape::Default,
                    Cursor::load(&theme, CursorShape::Default, size),
                );
                map.insert(
                    CursorShape::ColResize,
                    Cursor::load(&theme, CursorShape::ColResize, size),
                );
                map.insert(
                    CursorShape::RowResize,
                    Cursor::load(&theme, CursorShape::RowResize, size),
                );
                map.insert(
                    CursorShape::Grab,
                    Cursor::load(&theme, CursorShape::Grab, size),
                );
                map
            },
            current_image: RefCell::new(None),
            image_cache: RefCell::new(HashMap::new()),
        }
    }
}

pub fn draw_cursor<R>(
    renderer: &mut R,
    seat: &Seat<State>,
    location: Point<f64, Logical>,
    scale: Scale<f64>,
    time: Time<Monotonic>,
    draw_default: bool,
) -> Vec<CursorRenderElement<R>>
where
    R: Renderer + ImportMem + ImportAll,
    <R as Renderer>::TextureId: Clone + 'static,
{
    #[cfg(feature = "debug")]
    puffin::profile_function!();
    // draw the cursor as relevant
    // reset the cursor if the surface is no longer alive
    let cursor_status = seat
        .user_data()
        .get::<RefCell<CursorImageStatus>>()
        .map(|cell| {
            let mut cursor_status = cell.borrow_mut();
            if let CursorImageStatus::Surface(ref surface) = *cursor_status {
                if !surface.alive() {
                    *cursor_status = CursorImageStatus::Default;
                }
            }
            cursor_status.clone()
        })
        .unwrap_or(CursorImageStatus::Default);

    if let CursorImageStatus::Surface(ref wl_surface) = cursor_status {
        return draw_surface_cursor(renderer, wl_surface, location.to_i32_round(), scale);
    } else if draw_default && CursorImageStatus::Default == cursor_status {
        let integer_scale = scale.x.max(scale.y).ceil() as u32;

        let seat_userdata = seat.user_data();
        let state = seat_userdata.get::<CursorState>().unwrap();
        let frame = state
            .cursors
            .get(&*state.current_cursor.borrow())
            .unwrap()
            .get_image(
                integer_scale,
                Into::<Duration>::into(time).as_millis() as u32,
            );

        let mut cache = state.image_cache.borrow_mut();
        let pointer_images = cache
            .entry((TypeId::of::<TextureBuffer<R::TextureId>>(), renderer.id()))
            .or_default();

        let maybe_image = pointer_images
            .iter()
            .find_map(|(image, texture)| if image == &frame { Some(texture) } else { None })
            .and_then(|texture| texture.downcast_ref::<TextureBuffer<R::TextureId>>());
        let pointer_image = match maybe_image {
            Some(image) => image,
            None => {
                let texture = TextureBuffer::from_memory(
                    renderer,
                    &frame.pixels_rgba,
                    Fourcc::Abgr8888,
                    (frame.width as i32, frame.height as i32),
                    false,
                    integer_scale as i32,
                    Transform::Normal,
                    None,
                )
                .expect("Failed to import cursor bitmap");
                pointer_images.push((frame.clone(), Box::new(texture.clone())));
                pointer_images
                    .last()
                    .and_then(|(_, i)| i.downcast_ref::<TextureBuffer<R::TextureId>>())
                    .unwrap()
            }
        };

        let hotspot = Point::<i32, Logical>::from((frame.xhot as i32, frame.yhot as i32)).to_f64();
        *state.current_image.borrow_mut() = Some(frame);

        return vec![CursorRenderElement::Static(
            TextureRenderElement::from_texture_buffer(
                (location - hotspot).to_physical(scale),
                pointer_image,
                None,
                None,
                None,
                Kind::Cursor,
            ),
        )];
    } else {
        Vec::new()
    }
}