use {
    crate::{
        backend::{InputDeviceCapability, InputDeviceId},
        control_center::{
            ControlCenterInner, GridExt, PaneState, bool, bool_ui, combo_box, combo_box_ui,
            drag_value, drag_value_ui, grid, grid_label, grid_label_ui, label, text_edit, tip,
        },
        egui_adapter::egui_platform::icons::ICON_PENDING,
        ifs::{
            wl_output::WlOutputGlobal,
            wl_seat::{SeatId, WlSeatGlobal},
        },
        kbvm::KbvmMap,
        state::{DeviceHandlerData, State},
        utils::{errorfmt::ErrorFmt, static_text::StaticText},
    },
    ahash::AHashMap,
    egui::{
        CollapsingHeader, ComboBox, DragValue, Event, Grid, Id, TextBuffer, TextFormat, Ui,
        UiBuilder, ViewportCommand, Widget, emath::Numeric, text::LayoutJob,
    },
    isnt::std_1::string::IsntStringExt,
    jay_config::keyboard::syms::KeySym,
    kbvm::Keysym,
    linearize::LinearizeExt,
    rand::random,
    std::{mem, rc::Rc},
};

pub struct InputPane {
    state: Rc<State>,
    paste_requested: Option<Id>,
    keymaps: AHashMap<Key, KeymapState>,
}

#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
enum Key {
    Seat(SeatId),
    Dev(InputDeviceId),
}

struct KeymapState {
    seed: u64,
    rules_default: bool,
    rules: String,
    model_default: bool,
    model: String,
    layouts: String,
    variants: String,
    options: String,
    backup: Option<Rc<KbvmMap>>,
    pointer_revert_key: Keysym,
    pointer_revert_key_str: Option<String>,
    unknown_pointer_revert_key: bool,
}

impl Default for KeymapState {
    fn default() -> Self {
        Self {
            seed: random(),
            rules_default: true,
            rules: Default::default(),
            model_default: true,
            model: Default::default(),
            layouts: Default::default(),
            variants: Default::default(),
            options: Default::default(),
            backup: Default::default(),
            pointer_revert_key: Default::default(),
            pointer_revert_key_str: None,
            unknown_pointer_revert_key: false,
        }
    }
}

impl ControlCenterInner {
    pub fn create_input_pane(self: &Rc<Self>) -> InputPane {
        InputPane {
            state: self.state.clone(),
            paste_requested: Default::default(),
            keymaps: Default::default(),
        }
    }
}

impl InputPane {
    pub fn title(&self, res: &mut String) {
        res.push_str("Input");
    }

    pub fn show(&mut self, ps: &mut PaneState, ui: &mut Ui) {
        let state = self.state.clone();
        let seats = state.globals.seats.lock();
        let mut seats: Vec<_> = seats.values().collect();
        seats.sort_by_key(|d| d.seat_name());
        for seat in &seats {
            self.show_seat(ps, ui, seat);
        }
        let outputs = state.globals.outputs.lock();
        let mut outputs: Vec<_> = outputs.values().collect();
        outputs.sort_by_key(|o| &o.connector.name);
        let dev = &*state.input_device_handlers.borrow();
        let mut dev: Vec<_> = dev.values().collect();
        dev.sort_by_key(|d| d.data.device.name());
        for dev in dev {
            self.show_device(ps, ui, &dev.data, &seats, &outputs);
        }
    }

    fn show_seat(&mut self, ps: &mut PaneState, ui: &mut Ui, seat: &Rc<WlSeatGlobal>) {
        let mut layout_job = LayoutJob::default();
        layout_job.append(
            "Seat",
            0.0,
            TextFormat {
                color: ui.style().visuals.widgets.inactive.text_color(),
                ..Default::default()
            },
        );
        layout_job.append(
            seat.seat_name(),
            10.0,
            TextFormat {
                color: ui.style().visuals.widgets.active.text_color(),
                ..Default::default()
            },
        );
        let ks = self.keymaps.entry(Key::Seat(seat.id())).or_default();
        CollapsingHeader::new(layout_job)
            .id_salt(("seat", seat.id()))
            .show(ui, |ui| {
                grid(ui, ("seat", seat.id()), |ui| {
                    let mut dv = |name: &str, get: &dyn Fn(&mut (i32, i32)) -> &mut i32| {
                        let ui = &mut *ui.row();
                        grid_label(ui, name);
                        let mut v = seat.get_rate();
                        let old = v;
                        ui.horizontal(|ui| {
                            let v = get(&mut v);
                            DragValue::new(v).range(0..=i32::MAX).ui(ui);
                            if ui.button("-20").clicked() {
                                *v = v.saturating_sub(20).max(0)
                            }
                            if ui.button("+20").clicked() {
                                *v = v.saturating_add(20);
                            }
                        });
                        if v != old {
                            seat.set_rate(v.0, v.1);
                        }
                    };
                    dv("Repeat Rate", &|v| &mut v.0);
                    dv("Repeat Delay", &|v| &mut v.1);
                    drag_value(
                        ui,
                        "Cursor Size",
                        seat.cursor_group().cursor_size(),
                        0..=u32::MAX,
                        1.0,
                        |v| seat.cursor_group().set_cursor_size(v),
                    );
                    bool_ui(
                        ui,
                        "Simple IM",
                        |ui| {
                            tip(ui, |ui| {
                                ui.label("A simple input method based on Xcompose files.");
                                ui.label(concat!(
                                    "If you're not using another input method, you should ",
                                    "leave this enabled as it will work for sandboxed ",
                                    "applications, which regular Xcompose will not.",
                                ));
                                ui.label(concat!(
                                    "The `enable-unicode-input` action can be used to input ",
                                    "characters by their unicode value.",
                                ));
                            });
                        },
                        seat.simple_im_enabled(),
                        |b| seat.set_simple_im_enabled(b),
                    );
                    bool_ui(
                        ui,
                        "Hardware Cursor",
                        |ui| {
                            tip(ui, |ui| {
                                ui.label(
                                    "Allow this seat to use the hardware cursor, if available.",
                                );
                                ui.label("Only one seat can use the hardware cursor at a time.");
                            });
                        },
                        seat.cursor_group().hardware_cursor(),
                        |b| seat.cursor_group().set_hardware_cursor(b),
                    );
                    {
                        let ui = &mut *ui.row();
                        let v = seat.pointer_revert_key();
                        let v = Keysym(v.0);
                        if mem::replace(&mut ks.pointer_revert_key, v) != v {
                            ks.pointer_revert_key_str = None;
                        }
                        let name = ks
                            .pointer_revert_key_str
                            .get_or_insert_with(|| v.name().unwrap_or_default().to_string());
                        grid_label_ui(ui, |ui| {
                            ui.label("Pointer Revert Key");
                            tip(ui, |ui| {
                                ui.label(concat!(
                                    "Pressing this key reverts the pointer to the default state, ",
                                    "breaking grabs, drags, etc.",
                                ));
                                ui.label(
                                    "Setting this to `NoSymbol` effectively disables this feature.",
                                );
                            });
                        });
                        ui.horizontal(|ui| {
                            if ui.text_edit_singleline(name).changed() {
                                let v = Keysym::from_str(name);
                                ks.unknown_pointer_revert_key = v.is_none();
                                if let Some(v) = v {
                                    ks.pointer_revert_key = v;
                                    seat.set_pointer_revert_key(KeySym(v.0));
                                }
                            }
                            if ks.unknown_pointer_revert_key {
                                ui.label("Error: Unknown key");
                            }
                        });
                    }
                    bool(ui, "Focus Follows Mouse", seat.focus_follows_mouse(), |v| {
                        seat.set_focus_follows_mouse(v);
                    });
                    combo_box_ui(
                        ui,
                        "Fallback Output Mode",
                        |ui| {
                            tip(ui, |ui| {
                                ui.label(concat!(
                                    "This determines the output to use in operations where no ",
                                    "output is explicitly specified.",
                                ));
                                ui.label(concat!(
                                    "For example, when a new window is opened, this determines ",
                                    "where the window will be opened.",
                                ));
                                ui.label("`Cursor` refers to the output that contains the cursor.");
                                ui.label(
                                    "`Focus` refers to the output that has the keyboard focus.",
                                );
                            });
                        },
                        seat.fallback_output_mode(),
                        |v| seat.set_fallback_output_mode(v),
                    );
                });
                ui.label("Focus History");
                ui.indent("focus-history", |ui| {
                    let mut v = seat.focus_history_visible();
                    if ui.checkbox(&mut v, "Only Visible").changed() {
                        seat.focus_history_set_visible(v);
                    }
                    let mut v = seat.focus_history_same_workspace();
                    if ui.checkbox(&mut v, "Same Workspace").changed() {
                        seat.focus_history_set_same_workspace(v);
                    }
                });
                if ui.button("Reload Simple IM").clicked() {
                    seat.reload_simple_im();
                }
                show_keymap(
                    &self.state,
                    ps,
                    &mut self.paste_requested,
                    ks,
                    ui,
                    Some(&seat.keymap()),
                    |m| seat.set_seat_keymap(m),
                );
            });
    }

    fn show_device(
        &mut self,
        ps: &mut PaneState,
        ui: &mut Ui,
        dev: &Rc<DeviceHandlerData>,
        seats: &[&Rc<WlSeatGlobal>],
        outputs: &[&Rc<WlOutputGlobal>],
    ) {
        let mut layout_job = LayoutJob::default();
        layout_job.append(
            "Device",
            0.0,
            TextFormat {
                color: ui.style().visuals.widgets.inactive.text_color(),
                ..Default::default()
            },
        );
        layout_job.append(
            &dev.device.name(),
            10.0,
            TextFormat {
                color: ui.style().visuals.widgets.active.text_color(),
                ..Default::default()
            },
        );
        let dev_id = dev.device.id();
        CollapsingHeader::new(layout_job)
            .id_salt(("device", dev_id))
            .show(ui, |ui| {
                grid(ui, ("device", dev_id), |ui| {
                    {
                        let old = dev.seat.get();
                        let ui = &mut *ui.row();
                        grid_label(ui, "Seat");
                        let mut seat = old.as_ref();
                        ui.horizontal(|ui| {
                            let mut cb = ComboBox::from_id_salt("seat");
                            if let Some(seat) = seat {
                                cb = cb.selected_text(seat.seat_name());
                            }
                            cb.show_ui(ui, |ui| {
                                for s in seats {
                                    ui.selectable_value(&mut seat, Some(s), s.seat_name());
                                }
                            });
                            if ui.button("Detach").clicked() {
                                seat = None;
                            }
                        });
                        if seat != old.as_ref() {
                            dev.set_seat(&self.state, seat.cloned());
                        }
                    }
                    macro_rules! string {
                        ($field:ident, $name:expr) => {
                            if let Some(v) = &dev.$field {
                                label(ui, $name, v);
                            }
                        };
                    }
                    string!(syspath, "Syspath");
                    string!(devnode, "Devnode");
                    {
                        let ui = &mut *ui.row();
                        grid_label(ui, "Capabilities");
                        let mut s = String::new();
                        for cap in InputDeviceCapability::variants() {
                            if dev.device.has_capability(cap) {
                                if s.is_not_empty() {
                                    s.push_str(" | ");
                                }
                                s.push_str(cap.text());
                            }
                        }
                        ui.label(s);
                    }
                    if let Some(old) = dev.device.natural_scrolling_enabled() {
                        bool(ui, "Natural Scrolling", old, |v| {
                            dev.set_natural_scrolling_enabled(&self.state, v)
                        });
                    }
                    if dev.device.has_capability(InputDeviceCapability::Pointer) {
                        drag_value_ui(
                            ui,
                            "Scroll Distance (px)",
                            |ui| {
                                tip(ui, |ui| {
                                    ui.label(concat!(
                                        "This only applies to applications that use the ",
                                        "legacy px scrolling events.",
                                    ));
                                });
                            },
                            dev.px_per_scroll_wheel.get(),
                            -f64::INFINITY..=f64::INFINITY,
                            0.1,
                            |v| dev.set_px_per_scroll_wheel(&self.state, v),
                        );
                    }
                    if let Some(old) = dev.device.accel_profile() {
                        combo_box(ui, "Accel Profile", old, |v| {
                            dev.set_accel_profile(&self.state, v)
                        });
                    }
                    if let Some(old) = dev.device.accel_speed() {
                        drag_value(ui, "Accel Speed", old, -1.0..=1.0, 0.01, |v| {
                            dev.set_accel_speed(&self.state, v)
                        });
                    }
                    if let Some(old) = dev.device.click_method() {
                        combo_box(ui, "Click Method", old, |v| {
                            dev.set_click_method(&self.state, v)
                        });
                    }
                    if let Some(old) = dev.device.tap_enabled() {
                        bool(ui, "Tap Enabled", old, |v| {
                            dev.set_tap_enabled(&self.state, v)
                        });
                    }
                    if let Some(old) = dev.device.drag_enabled() {
                        bool(ui, "Tap Drag Enabled", old, |v| {
                            dev.set_drag_enabled(&self.state, v)
                        });
                    }
                    if let Some(old) = dev.device.drag_lock_enabled() {
                        bool(ui, "Tap Drag Lock Enabled", old, |v| {
                            dev.set_drag_lock_enabled(&self.state, v)
                        });
                    }
                    if let Some(old) = dev.device.left_handed() {
                        bool(ui, "Left Handed", old, |v| {
                            dev.set_left_handed(&self.state, v)
                        });
                    }
                    if let Some(old) = dev.device.middle_button_emulation_enabled() {
                        bool(ui, "Middle Button Emulation", old, |v| {
                            dev.set_middle_button_emulation_enabled(&self.state, v)
                        });
                    }
                    {
                        let ui = &mut *ui.row();
                        grid_label_ui(ui, |ui| {
                            ui.label("Output");
                            tip(ui, |ui| {
                                ui.label("This applies to touch and tablet input.");
                            });
                        });
                        ui.horizontal(|ui| {
                            let old = dev.output.get().and_then(|v| v.global.get());
                            let old = old.as_ref();
                            let mut v = old;
                            let mut cb = ComboBox::from_id_salt("output");
                            if let Some(v) = v {
                                cb = cb.selected_text(&*v.connector.name);
                            }
                            cb.show_ui(ui, |ui| {
                                for &output in outputs {
                                    ui.selectable_value(
                                        &mut v,
                                        Some(output),
                                        &*output.connector.name,
                                    );
                                }
                            });
                            if v != old {
                                dev.set_output(&self.state, v.map(|v| &**v));
                            }
                            if ui.button("Detach").clicked() {
                                dev.set_output(&self.state, None);
                            }
                        });
                    }
                    matrix_ui(
                        ui,
                        "Transform Matrix",
                        |ui| {
                            tip(ui, |ui| {
                                ui.label("This matrix is applied to relative pointer movements.");
                            });
                        },
                        dev.device
                            .has_capability(InputDeviceCapability::Pointer)
                            .then(|| {
                                dev.device
                                    .transform_matrix()
                                    .unwrap_or([[1.0, 0.0], [0.0, 1.0]])
                            }),
                        |v| dev.set_transform_matrix(&self.state, v),
                    );
                    matrix(
                        ui,
                        "Calibration Matrix",
                        dev.device.calibration_matrix(),
                        |v| dev.set_calibration_matrix(&self.state, v),
                    );
                });
                if dev.device.has_capability(InputDeviceCapability::Keyboard) {
                    ui.collapsing("Device Keymap", |ui| {
                        let ks = self.keymaps.entry(Key::Dev(dev_id)).or_default();
                        let map = dev.keymap.get();
                        ui.add_enabled_ui(map.is_some(), |ui| {
                            if ui.button("Use Seat Keymap").clicked() {
                                ks.backup(map.as_ref());
                                dev.set_keymap(&self.state, None);
                            }
                        });
                        show_keymap(
                            &self.state,
                            ps,
                            &mut self.paste_requested,
                            ks,
                            ui,
                            map.as_ref(),
                            |m| {
                                dev.set_keymap(&self.state, Some(m.clone()));
                            },
                        );
                    });
                }
            });
    }
}

impl KeymapState {
    fn backup(&mut self, map: Option<&Rc<KbvmMap>>) {
        if self.backup.is_none()
            && let Some(map) = map
        {
            self.backup = Some(map.clone());
        }
    }
}

fn show_keymap(
    state: &State,
    ps: &mut PaneState,
    paste_requested: &mut Option<Id>,
    ks: &mut KeymapState,
    ui: &mut Ui,
    map: Option<&Rc<KbvmMap>>,
    set_map: impl Fn(&Rc<KbvmMap>),
) {
    ui.scope_builder(UiBuilder::new().id(("keymap-settings", ks.seed)), |ui| {
        ui.add_enabled_ui(map.is_some(), |ui| {
            if ui.button("Copy Keymap").clicked()
                && let Some(map) = map
            {
                ui.ctx().copy_text(map.map_text.clone());
            }
        });
        let backup = |ks: &mut KeymapState| {
            ks.backup(map);
        };
        if ui.button("Load Default Keymap").clicked() {
            backup(ks);
            set_map(&state.default_keymap);
        }
        ui.horizontal(|ui| {
            ui.add_enabled_ui(map.is_some(), |ui| {
                if ui.button("Backup Keymap").clicked() {
                    ks.backup = None;
                    backup(ks);
                }
            });
            if let Some(backup) = &ks.backup
                && ui.button("Restore Keymap").clicked()
            {
                set_map(backup);
                ks.backup = None;
            }
        });
        let mut label = "Load Keymap from Clipboard".to_string();
        if *paste_requested == Some(ui.id()) {
            label.push_str(" ");
            label.push_str(ICON_PENDING);
        }
        let button = ui.button(label);
        if button.clicked() {
            *paste_requested = Some(ui.id());
            button.request_focus();
            ui.ctx().send_viewport_cmd(ViewportCommand::RequestPaste);
        } else if *paste_requested == Some(ui.id()) && button.has_focus() {
            ui.input(|e| {
                let map = e
                    .events
                    .iter()
                    .filter_map(|e| match e {
                        Event::Paste(s) => Some(s),
                        _ => None,
                    })
                    .next();
                let Some(map) = map else {
                    return;
                };
                *paste_requested = None;
                let map = match state.kb_ctx.parse_keymap(map.as_bytes()) {
                    Ok(m) => m,
                    Err(e) => {
                        let error = format!("Could not parse keymap: {}", ErrorFmt(e));
                        ps.errors.push(error);
                        return;
                    }
                };
                backup(ks);
                set_map(&map);
            });
        } else if *paste_requested == Some(ui.id()) {
            *paste_requested = None;
        }
        ui.collapsing("Create Keymap from Names", |ui| {
            grid(ui, ("keymap-from-names", ui.id()), |ui| {
                let defaulted =
                    |ui: &mut Ui, name: &str, default: &mut bool, text: &mut dyn TextBuffer| {
                        let ui = &mut *ui.row();
                        grid_label(ui, name);
                        ui.add_enabled_ui(!*default, |ui| {
                            text_edit(ui, text);
                        });
                        ui.checkbox(default, "Default");
                    };
                let required = |ui: &mut Ui, name, text| {
                    let ui = &mut *ui.row();
                    grid_label(ui, name);
                    text_edit(ui, text);
                };
                defaulted(ui, "Rules", &mut ks.rules_default, &mut ks.rules);
                defaulted(ui, "Model", &mut ks.model_default, &mut ks.model);
                required(ui, "Layouts", &mut ks.layouts);
                required(ui, "Variants", &mut ks.variants);
                required(ui, "Options", &mut ks.options);
            });
            if ui.button("Load").clicked() {
                'set_map: {
                    let map = state.kb_ctx.keymap_from_rmlvo(
                        (!ks.rules_default).then_some(&ks.rules),
                        (!ks.model_default).then_some(&ks.model),
                        Some(&ks.layouts),
                        Some(&ks.variants),
                        Some(&ks.options),
                    );
                    let map = match map {
                        Ok(map) => map,
                        Err(e) => {
                            let error = format!("Could not parse keymap: {}", ErrorFmt(e));
                            ps.errors.push(error);
                            break 'set_map;
                        }
                    };
                    backup(ks);
                    set_map(&map);
                }
            }
        });
    });
}

fn matrix<T, const W: usize>(
    ui: &mut Ui,
    name: &str,
    old: Option<[[T; W]; 2]>,
    set: impl FnOnce([[T; W]; 2]),
) where
    T: Numeric,
{
    matrix_ui(ui, name, |_| (), old, set);
}

fn matrix_ui<R, T, const W: usize>(
    ui: &mut Ui,
    name: &str,
    label: impl FnOnce(&mut Ui) -> R,
    old: Option<[[T; W]; 2]>,
    set: impl FnOnce([[T; W]; 2]),
) where
    T: Numeric,
{
    if let Some(mut m) = old {
        let old = m;
        let ui = &mut *ui.row();
        grid_label_ui(ui, |ui| {
            ui.label(name);
            label(ui);
        });
        Grid::new(name).show(ui, |ui| {
            for row in &mut m {
                for cell in row {
                    DragValue::new(cell).speed(0.01).ui(ui);
                }
                ui.end_row();
            }
        });
        if old != m {
            set(m);
        }
    }
}