use std::ffi::c_void;
use std::ptr::NonNull;

use iced_graphics::{Shell, Viewport};
use iced_runtime::user_interface::{self, UserInterface};
use iced_wgpu::core::renderer::Style;
use iced_wgpu::core::time::Instant;
use iced_wgpu::core::{clipboard, keyboard, mouse, window, Color, Event, Font, Pixels, Point, Size, Theme};
use iced_wgpu::Engine;
use raw_window_handle::{RawDisplayHandle, RawWindowHandle};
#[cfg(target_os = "macos")]
use raw_window_handle::{AppKitDisplayHandle, AppKitWindowHandle};
#[cfg(target_os = "ios")]
use raw_window_handle::{UiKitDisplayHandle, UiKitWindowHandle};
#[cfg(target_os = "windows")]
use raw_window_handle::{Win32WindowHandle, WindowsDisplayHandle};

use crate::editor::{EditorState, Message, RenderMode};
use crate::palette;
use crate::table_block::TableMessage;
use crate::ViewportHandle;

#[cfg(all(not(target_os = "ios"), feature = "native-shell"))]
struct AcordClipboard {
    board: std::cell::RefCell<arboard::Clipboard>,
}

#[cfg(all(not(target_os = "ios"), feature = "native-shell"))]
impl clipboard::Clipboard for AcordClipboard {
    fn read(&self, _kind: clipboard::Kind) -> Option<String> {
        let mut board = self.board.borrow_mut();
        // encode pasteboard bitmap to PNG and yield a markdown image reference
        if let Ok(img) = board.get_image() {
            if let Some(path) = crate::editor::write_clipboard_image_to_cache(&img) {
                return Some(format!("\n![]({})\n", path));
            }
        }
        // normalize \r\n to \n
        board.get_text()
            .ok()
            .map(|s| s.replace("\r\n", "\n").replace('\r', "\n"))
    }

    fn write(&mut self, _kind: clipboard::Kind, contents: String) {
        let _ = self.board.borrow_mut().set_text(contents);
    }
}

/// stub clipboard for iOS and embedded consumers without native-shell.
#[cfg(any(target_os = "ios", not(feature = "native-shell")))]
struct AcordClipboard;

#[cfg(any(target_os = "ios", not(feature = "native-shell")))]
impl clipboard::Clipboard for AcordClipboard {
    fn read(&self, _kind: clipboard::Kind) -> Option<String> { None }
    fn write(&mut self, _kind: clipboard::Kind, _contents: String) {}
}

/// synthesizes platform display+window handles from a single native pointer.
pub fn create(
    native_handle: *mut c_void,
    width: f32,
    height: f32,
    scale: f32,
) -> Option<ViewportHandle> {
    let ptr = NonNull::new(native_handle)?;

    #[cfg(target_os = "macos")]
    let (raw_window, raw_display) = (
        RawWindowHandle::AppKit(AppKitWindowHandle::new(ptr)),
        RawDisplayHandle::AppKit(AppKitDisplayHandle::new()),
    );
    #[cfg(target_os = "ios")]
    let (raw_window, raw_display) = (
        RawWindowHandle::UiKit(UiKitWindowHandle::new(ptr)),
        RawDisplayHandle::UiKit(UiKitDisplayHandle::new()),
    );
    #[cfg(target_os = "windows")]
    let (raw_window, raw_display) = {
        let wh = Win32WindowHandle::new(std::num::NonZero::new(ptr.as_ptr() as isize).unwrap());
        (
            RawWindowHandle::Win32(wh),
            RawDisplayHandle::Windows(WindowsDisplayHandle::new()),
        )
    };
    #[cfg(not(any(target_os = "macos", target_os = "ios", target_os = "windows")))]
    {
        let _ = (ptr, width, height, scale);
        return None;
    }

    #[cfg(any(target_os = "macos", target_os = "ios", target_os = "windows"))]
    create_native(raw_display, raw_window, width, height, scale)
}

/// creates the wgpu surface, device, queue, renderer, and viewport from typed handles.
pub fn create_native(
    raw_display: RawDisplayHandle,
    raw_window: RawWindowHandle,
    width: f32,
    height: f32,
    scale: f32,
) -> Option<ViewportHandle> {
    #[cfg(any(target_os = "macos", target_os = "ios"))]
    let backends = wgpu::Backends::METAL;
    #[cfg(target_os = "windows")]
    let backends = wgpu::Backends::DX12;
    #[cfg(not(any(target_os = "macos", target_os = "ios", target_os = "windows")))]
    let backends = wgpu::Backends::VULKAN | wgpu::Backends::GL;

    let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor {
        backends,
        ..Default::default()
    });

    let target = wgpu::SurfaceTargetUnsafe::RawHandle {
        raw_display_handle: raw_display,
        raw_window_handle: raw_window,
    };

    let surface = unsafe { instance.create_surface_unsafe(target).ok()? };

    let adapter = pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions {
        power_preference: wgpu::PowerPreference::HighPerformance,
        compatible_surface: Some(&surface),
        force_fallback_adapter: false,
    }))
    .ok()?;

    let (device, queue) =
        pollster::block_on(adapter.request_device(&wgpu::DeviceDescriptor::default())).ok()?;

    let phys_w = (width * scale) as u32;
    let phys_h = (height * scale) as u32;

    let caps = surface.get_capabilities(&adapter);
    let format = caps.formats.first().copied()?;
    let alpha_mode = caps.alpha_modes.first().copied().unwrap_or(wgpu::CompositeAlphaMode::Auto);
    crate::ios_dlog!(
        "surface formats={:?} chose={:?} alpha_modes={:?} chose={:?} adapter={}",
        caps.formats, format, caps.alpha_modes, alpha_mode,
        adapter.get_info().name,
    );

    surface.configure(
        &device,
        &wgpu::SurfaceConfiguration {
            usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
            format,
            width: phys_w.max(1),
            height: phys_h.max(1),
            present_mode: wgpu::PresentMode::AutoVsync,
            alpha_mode,
            view_formats: vec![],
            desired_maximum_frame_latency: 2,
        },
    );

    let engine = Engine::new(
        &adapter,
        device.clone(),
        queue.clone(),
        format,
        None,
        Shell::headless(),
    );

    // Font::DEFAULT = cosmic-text "Noto Sans Mono", absent on iOS; EDITOR_FONT overrides per-span
    crate::ios_dlog!("renderer init font=Font::DEFAULT (= cosmic 'Noto Sans Mono', iOS likely missing) editor_font={:?}", crate::syntax::EDITOR_FONT);
    let renderer = iced_wgpu::Renderer::new(engine, Font::DEFAULT, Pixels(16.0));

    let viewport =
        Viewport::with_physical_size(Size::new(phys_w.max(1), phys_h.max(1)), scale);

    let focus_point = Point::new(width / 2.0, height / 2.0);
    let initial_events = vec![
        Event::Mouse(mouse::Event::CursorMoved { position: focus_point }),
        Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left)),
        Event::Mouse(mouse::Event::ButtonReleased(mouse::Button::Left)),
    ];

    Some(ViewportHandle {
        surface,
        device,
        queue,
        format,
        width: phys_w,
        height: phys_h,
        scale,
        renderer,
        viewport,
        cache: user_interface::Cache::new(),
        state: EditorState::new(),
        events: initial_events,
        cursor: mouse::Cursor::Available(focus_point),
        needs_redraw: true,
    })
}

pub fn render(handle: &mut ViewportHandle) {
    // skip frame entirely when idle and no eval debounce pending
    let pending_events = !handle.events.is_empty();
    if !handle.needs_redraw && !handle.state.has_pending_eval() && !pending_events {
        return;
    }

    let frame = match handle.surface.get_current_texture() {
        Ok(f) => f,
        Err(_) => return,
    };
    let view = frame.texture.create_view(&Default::default());

    let logical_size = handle.viewport.logical_size();

    handle
        .events
        .push(Event::Window(window::Event::RedrawRequested(Instant::now())));

    let cache = std::mem::take(&mut handle.cache);
    let mut ui = UserInterface::build(
        handle.state.view(),
        Size::new(logical_size.width, logical_size.height),
        cache,
        &mut handle.renderer,
    );

    #[cfg(all(not(target_os = "ios"), feature = "native-shell"))]
    let mut clipboard = AcordClipboard {
        board: std::cell::RefCell::new(arboard::Clipboard::new().unwrap()),
    };
    #[cfg(any(target_os = "ios", not(feature = "native-shell")))]
    let mut clipboard = AcordClipboard;
    let mut messages: Vec<Message> = Vec::new();
    let mut consumed: Vec<usize> = Vec::new();
    let mut latest_mods: Option<keyboard::Modifiers> = None;
    let mut new_cmd_a_armed: Option<bool> = None;

    for (ev_idx, event) in handle.events.iter().enumerate() {
        let is_user_input = matches!(
            event,
            Event::Keyboard(keyboard::Event::KeyPressed { .. })
                | Event::Mouse(mouse::Event::ButtonPressed(_))
        );
        if is_user_input {
            new_cmd_a_armed = Some(false);
        }

        if handle.state.render_mode == RenderMode::View {
            let is_typing_char = match event {
                Event::Keyboard(keyboard::Event::KeyPressed {
                    key: keyboard::Key::Character(c), modifiers, ..
                }) if !modifiers.logo() && !modifiers.control() && !modifiers.alt() => {
                    c.as_str() != "i" && c.as_str() != "/"
                }
                _ => false,
            };
            let is_destructive_named = matches!(
                event,
                Event::Keyboard(keyboard::Event::KeyPressed {
                    key: keyboard::Key::Named(
                        keyboard::key::Named::Backspace
                        | keyboard::key::Named::Delete
                        | keyboard::key::Named::Enter
                        | keyboard::key::Named::Tab
                    ),
                    ..
                })
            );
            if is_typing_char || is_destructive_named {
                consumed.push(ev_idx);
                continue;
            }
        }

        match event {
            Event::Keyboard(keyboard::Event::KeyPressed {
                key: keyboard::Key::Character(c),
                modifiers,
                ..
            }) if modifiers.logo() => {
                match c.as_str() {
                    "p" => {
                        messages.push(Message::TogglePreview);
                        consumed.push(ev_idx);
                    }
                    "t" => {
                        messages.push(Message::InsertTable);
                        consumed.push(ev_idx);
                    }
                    "a" => {
                        if handle.state.cmd_a_armed {
                            messages.push(Message::SelectAllBlocks);
                            new_cmd_a_armed = Some(false);
                            consumed.push(ev_idx);
                        } else {
                            if handle.state.table_is_focused_block()
                                && !handle.state.focused_table_is_select_all()
                                && handle.state.editing.is_none()
                            {
                                messages.push(Message::FocusedTableOp(
                                    TableMessage::SelectAll,
                                ));
                                consumed.push(ev_idx);
                            }
                            new_cmd_a_armed = Some(true);
                        }
                    }
                    "b" => {
                        messages.push(Message::ToggleBold);
                        consumed.push(ev_idx);
                    }
                    "i" => {
                        messages.push(Message::ToggleItalic);
                        consumed.push(ev_idx);
                    }
                    "u" => {
                        messages.push(Message::ToggleUnderline);
                        consumed.push(ev_idx);
                    }
                    "x" if modifiers.shift() => {
                        messages.push(Message::ToggleStrike);
                        consumed.push(ev_idx);
                    }
                    "." if modifiers.shift() => {
                        messages.push(Message::ToggleBlockquote);
                        consumed.push(ev_idx);
                    }
                    "\"" | "'" => {
                        let q: &'static str = if c.as_str() == "\"" { "\"" } else { "'" };
                        messages.push(Message::WrapWith(q, q));
                        consumed.push(ev_idx);
                    }
                    "9" | "(" => {
                        messages.push(Message::WrapWith("(", ")"));
                        consumed.push(ev_idx);
                    }
                    "0" if modifiers.shift() => {
                        messages.push(Message::ZoomReset);
                        consumed.push(ev_idx);
                    }
                    "0" => {
                        messages.push(Message::FixUp);
                        consumed.push(ev_idx);
                    }
                    "c" => {
                        if handle.state.should_intercept_table_copy() {
                            messages.push(Message::CopyFocusedTableSelection);
                            consumed.push(ev_idx);
                        }
                    }
                    "e" => {
                        messages.push(Message::SmartEval);
                        consumed.push(ev_idx);
                    }
                    "r" => {
                        messages.push(Message::EvalAll);
                        consumed.push(ev_idx);
                    }
                    "z" if modifiers.shift() => {
                        messages.push(Message::Redo);
                        consumed.push(ev_idx);
                    }
                    "z" => {
                        messages.push(Message::Undo);
                        consumed.push(ev_idx);
                    }
                    "f" => {
                        messages.push(Message::ToggleFind);
                        consumed.push(ev_idx);
                    }
                    "g" if modifiers.shift() => {
                        messages.push(Message::FindPrev);
                        consumed.push(ev_idx);
                    }
                    "g" => {
                        messages.push(Message::FindNext);
                        consumed.push(ev_idx);
                    }
                    _ => {}
                }
            }
            Event::Keyboard(keyboard::Event::KeyPressed {
                key: keyboard::Key::Character(c),
                modifiers,
                ..
            }) if modifiers.control() && !modifiers.logo() => {
                match c.as_str() {
                    "i" => {
                        messages.push(Message::SetRenderMode(RenderMode::Editor));
                        consumed.push(ev_idx);
                    }
                    "/" => {
                        messages.push(Message::SetRenderMode(RenderMode::Live));
                        consumed.push(ev_idx);
                    }
                    _ => {}
                }
            }
            Event::Keyboard(keyboard::Event::KeyPressed {
                key: keyboard::Key::Named(keyboard::key::Named::Escape),
                modifiers,
                ..
            }) if modifiers.control() => {
                messages.push(Message::SetRenderMode(RenderMode::View));
                consumed.push(ev_idx);
            }
            Event::Keyboard(keyboard::Event::KeyPressed {
                key: keyboard::Key::Character(c),
                modifiers,
                ..
            }) if handle.state.render_mode == RenderMode::View
                && !modifiers.logo() && !modifiers.control() && !modifiers.alt() => {
                match c.as_str() {
                    "i" => {
                        messages.push(Message::SetRenderMode(RenderMode::Editor));
                        consumed.push(ev_idx);
                    }
                    "/" => {
                        messages.push(Message::SetRenderMode(RenderMode::Live));
                        consumed.push(ev_idx);
                    }
                    _ => {}
                }
            }
            Event::Keyboard(keyboard::Event::KeyPressed {
                key: keyboard::Key::Named(named),
                modifiers,
                ..
            }) if modifiers.logo() && modifiers.alt() => {
                use keyboard::key::Named;
                let op = match named {
                    Named::ArrowUp => Some(TableMessage::InsertRowAbove),
                    Named::ArrowDown => Some(TableMessage::InsertRowBelow),
                    Named::ArrowLeft => Some(TableMessage::InsertColLeft),
                    Named::ArrowRight => Some(TableMessage::InsertColRight),
                    Named::Backspace if modifiers.shift() => Some(TableMessage::DeleteCol),
                    Named::Backspace => Some(TableMessage::DeleteRow),
                    _ => None,
                };
                if let Some(tmsg) = op {
                    messages.push(Message::FocusedTableOp(tmsg));
                    consumed.push(ev_idx);
                }
            }
            Event::Keyboard(keyboard::Event::KeyPressed {
                key: keyboard::Key::Named(named),
                modifiers,
                ..
            }) if !modifiers.logo() && !modifiers.alt() && !modifiers.control()
                && handle.state.table_is_focused_block() =>
            {
                use keyboard::key::Named;
                match named {
                    Named::Tab if modifiers.shift() => {
                        messages.push(Message::TableShiftTab);
                        consumed.push(ev_idx);
                    }
                    Named::Tab => {
                        messages.push(Message::TableTab);
                        consumed.push(ev_idx);
                    }
                    Named::Enter => {
                        messages.push(Message::TableEnter);
                        consumed.push(ev_idx);
                    }
                    Named::ArrowUp => {
                        if let Some((block_idx, row, _)) =
                            handle.state.active_table_focused_row()
                        {
                            if row == 0 {
                                messages.push(Message::EscapeTableUp(block_idx));
                            } else {
                                messages.push(Message::TableMoveUp);
                            }
                            consumed.push(ev_idx);
                        }
                    }
                    Named::ArrowDown => {
                        if let Some((block_idx, row, total)) =
                            handle.state.active_table_focused_row()
                        {
                            if row + 1 >= total {
                                messages.push(Message::EscapeTableDown(block_idx));
                            } else {
                                messages.push(Message::TableMoveDown);
                            }
                            consumed.push(ev_idx);
                        }
                    }
                    Named::ArrowLeft => {
                        messages.push(Message::TableMoveLeft);
                        consumed.push(ev_idx);
                    }
                    Named::ArrowRight => {
                        messages.push(Message::TableMoveRight);
                        consumed.push(ev_idx);
                    }
                    Named::Backspace | Named::Delete
                        if handle.state.focused_table_is_select_all() =>
                    {
                        messages.push(Message::FocusedTableOp(TableMessage::ClearAll));
                        consumed.push(ev_idx);
                    }
                    Named::Backspace | Named::Delete
                        if handle.state.has_selected_cell_not_editing() =>
                    {
                        messages.push(Message::ClearSelectedCell);
                        consumed.push(ev_idx);
                    }
                    _ => {}
                }
            }
            Event::Keyboard(keyboard::Event::KeyPressed {
                key: keyboard::Key::Named(keyboard::key::Named::Backspace),
                modifiers,
                ..
            }) if modifiers.logo() && !modifiers.alt() && !modifiers.control()
                && handle.state.all_blocks_selected =>
            {
                messages.push(Message::DeleteAllBlocks);
                consumed.push(ev_idx);
            }
            Event::Keyboard(keyboard::Event::KeyPressed {
                key: keyboard::Key::Named(keyboard::key::Named::Backspace),
                modifiers,
                ..
            }) if modifiers.logo() && !modifiers.alt() && !modifiers.control()
                && handle.state.focused_table_is_select_all() =>
            {
                messages.push(Message::DeleteCurrentTable);
                consumed.push(ev_idx);
            }
            Event::Keyboard(keyboard::Event::KeyPressed {
                key: keyboard::Key::Named(named),
                modifiers,
                ..
            }) if (matches!(named, keyboard::key::Named::Backspace | keyboard::key::Named::Delete))
                && !modifiers.logo() && !modifiers.alt() && !modifiers.control()
                && handle.state.all_blocks_selected =>
            {
                messages.push(Message::ClearAllBlocks);
                consumed.push(ev_idx);
            }
            Event::Keyboard(keyboard::Event::KeyPressed {
                key: keyboard::Key::Named(keyboard::key::Named::Escape),
                modifiers,
                ..
            }) if !modifiers.control() => {
                if handle.state.context_menu.is_some() {
                    messages.push(Message::HideContextMenu);
                    consumed.push(ev_idx);
                } else if handle.state.find.visible {
                    messages.push(Message::HideFind);
                    consumed.push(ev_idx);
                } else if handle.state.editing.is_some() {
                    messages.push(Message::ExitCellEdit);
                    consumed.push(ev_idx);
                } else {
                    match handle.state.render_mode {
                        RenderMode::Live => {
                            messages.push(Message::SetRenderMode(RenderMode::Editor));
                            consumed.push(ev_idx);
                        }
                        RenderMode::Editor => {
                            messages.push(Message::SetRenderMode(RenderMode::View));
                            consumed.push(ev_idx);
                        }
                        RenderMode::View => {
                            messages.push(Message::SetRenderMode(RenderMode::Live));
                            consumed.push(ev_idx);
                        }
                    }
                }
            }
            Event::Keyboard(keyboard::Event::KeyPressed {
                key: keyboard::Key::Character(c),
                modifiers,
                ..
            }) if !modifiers.logo() && !modifiers.alt() && !modifiers.control()
                && handle.state.has_selected_cell_not_editing() =>
            {
                if let Some(first) = c.chars().next() {
                    if !first.is_control() {
                        messages.push(Message::EnterCellEditWithChar(first));
                        consumed.push(ev_idx);
                    }
                }
            }
            Event::Keyboard(keyboard::Event::ModifiersChanged(mods)) => {
                latest_mods = Some(*mods);
            }
            _ => {}
        }
    }

    // remove consumed events before passing the remainder to iced
    if !consumed.is_empty() {
        let consumed_set: std::collections::HashSet<usize> = consumed.into_iter().collect();
        let mut filtered: Vec<Event> = Vec::with_capacity(handle.events.len());
        for (i, e) in handle.events.drain(..).enumerate() {
            if !consumed_set.contains(&i) {
                filtered.push(e);
            }
        }
        handle.events = filtered;
    }

    let _ = ui.update(
        &handle.events,
        handle.cursor,
        &mut handle.renderer,
        &mut clipboard,
        &mut messages,
    );
    handle.events.clear();

    let focused_id = {
        use iced_wgpu::core::widget::operation::{Focusable, Operation};
        use iced_wgpu::core::widget::Id as CoreId;
        use iced_wgpu::core::Rectangle;

        struct FindFocusedId {
            focused: Option<CoreId>,
        }

        impl Operation<()> for FindFocusedId {
            fn focusable(
                &mut self,
                id: Option<&CoreId>,
                _bounds: Rectangle,
                state: &mut dyn Focusable,
            ) {
                if state.is_focused() && id.is_some() && self.focused.is_none() {
                    self.focused = id.cloned();
                }
            }

            fn traverse(
                &mut self,
                operate: &mut dyn FnMut(&mut dyn Operation<()>),
            ) {
                operate(self);
            }

            fn container(&mut self, _id: Option<&CoreId>, _bounds: Rectangle) {}
        }

        let mut op = FindFocusedId { focused: None };
        ui.operate(&handle.renderer, &mut op);
        op.focused
    };

    let cache = ui.into_cache();

    if let Some(mods) = latest_mods {
        handle.state.mods = mods;
    }
    if let Some(armed) = new_cmd_a_armed {
        handle.state.cmd_a_armed = armed;
    }
    if let Some(pt) = handle.cursor.position() {
        handle.state.cursor_pos = pt;
        if handle.state.tick_promote_drag() {
            handle.needs_redraw = true;
        }
        if handle.state.tick_resize_drag() {
            handle.needs_redraw = true;
        }
    }
    handle.state.sync_focused_cell(focused_id.as_ref());

    for msg in messages.drain(..) {
        handle.state.update(msg);
    }

    #[cfg(all(not(target_os = "ios"), feature = "native-shell"))]
    if let Some(text) = handle.state.pending_clipboard.take() {
        if let Ok(mut board) = arboard::Clipboard::new() {
            let _ = board.set_text(text);
        }
    }
    #[cfg(any(target_os = "ios", not(feature = "native-shell")))]
    let _ = handle.state.pending_clipboard.take();

    handle.state.tick();
    let pending_focus = handle.state.take_pending_focus();
    let pending_scroll = handle.state.take_pending_scroll();

    let theme = Theme::Dark;
    let style = Style {
        text_color: Color::WHITE,
    };

    {
        use std::sync::atomic::{AtomicU64, Ordering};
        static FRAME: AtomicU64 = AtomicU64::new(0);
        let n = FRAME.fetch_add(1, Ordering::Relaxed);
        if n == 0 || n == 60 || n % 600 == 0 {
            let p = palette::current();
            let _ = (n, &p, &theme, &style);
            crate::ios_dlog!(
                "render frame={n} theme=Dark style.text={:?} palette.base={:?} palette.text={:?} palette.surface0={:?}",
                style.text_color,
                p.base,
                p.text,
                p.surface0,
            );
        }
    }

    let mut ui = UserInterface::build(
        handle.state.view(),
        Size::new(logical_size.width, logical_size.height),
        cache,
        &mut handle.renderer,
    );

    if let Some(focus_id) = pending_focus {
        use iced_wgpu::core::widget::operation::focusable;
        let mut op = focusable::focus(focus_id);
        ui.operate(&handle.renderer, &mut op);
    }

    // forward accumulated wheel-scroll delta to the document scrollable
    if let Some(delta_y) = pending_scroll {
        use iced_wgpu::core::widget::operation::scrollable::{scroll_by, AbsoluteOffset};
        use iced_wgpu::core::widget::Id as CoreId;
        let mut op = scroll_by::<()>(
            CoreId::new(crate::editor::DOC_SCROLLABLE_ID),
            AbsoluteOffset { x: 0.0, y: delta_y },
        );
        ui.operate(&handle.renderer, &mut op);
    }

    ui.draw(&mut handle.renderer, &theme, &style, handle.cursor);
    handle.cache = ui.into_cache();

    handle
        .renderer
        .present(Some(palette::current().base), handle.format, &view, &handle.viewport);

    frame.present();

    handle.needs_redraw = false;
}

pub fn resize(handle: &mut ViewportHandle, width: f32, height: f32, scale: f32) {
    let phys_w = (width * scale) as u32;
    let phys_h = (height * scale) as u32;
    if phys_w == 0 || phys_h == 0 {
        return;
    }

    handle.width = phys_w;
    handle.height = phys_h;
    handle.scale = scale;

    handle.viewport = Viewport::with_physical_size(Size::new(phys_w, phys_h), scale);

    handle.surface.configure(
        &handle.device,
        &wgpu::SurfaceConfiguration {
            usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
            format: handle.format,
            width: phys_w,
            height: phys_h,
            present_mode: wgpu::PresentMode::AutoVsync,
            alpha_mode: wgpu::CompositeAlphaMode::Auto,
            view_formats: vec![],
            desired_maximum_frame_latency: 2,
        },
    );
}