xkb_evdev_trans 0.1.2

// SPDX-FileCopyrightText: 2025 Arkadiusz Guzinski <kermit@aguzinski.de>
//
// SPDX-License-Identifier: MIT

use crate::map_builder::Replace::{CustomChar, CustomString};
use crate::map_builder::Replace::{MapChar, MapString};
use crate::Keymap;
use evdev_rs::enums::EventType;
use evdev_rs::util::event_code_to_int;
use evdev_rs::EventCodeIterator;
use std::collections::{BTreeMap, HashMap};
use std::marker::PhantomData;

/// SymbolType will determine which fields are used for the symbol part of the map.
pub enum SymbolType {
    /// The name xkb uses for the hardware key, e.g. "AE09". These are independent of the layout.
    KeyName,
    /// The Unicode character, e.g. "ä". Will return None if the key has no visible symbol.
    Unicode,
    /// The symbol name, e.g. "ampersand".
    SymbolName,
    /// Unicode character if *Symbol.visible* is true, else the symbol name.
    UnicodeSymbol,
    /// The content of *Symbol.display*
    SymbolDisplay,
}

/// Fill will determine whether unknown symbol strings are filled with EVDEV constant names and 
/// to apply transformations to these.
pub enum Fill {
    /// no further transformation applied
    None,
    /// fill unmapped symbols with evdev names, e.g. KEY_RESERVED
    /// if the parameter is set to true, the KEY_ prefix is removed
    Evdev(bool),
    /// fill unmapped symbols with evdev names, e.g. KEY_RESERVED, applying the passed transformation 
    /// function to the string.
    EvdevCustom(fn(String) -> String),
}

#[derive(Clone)]
enum Replace {
    MapString(BTreeMap<String, String>),
    MapChar(HashMap<char, char>),
    CustomString(fn(String) -> String),
    CustomChar(fn(char) -> char),
}

/// Determines the type of Code from which to map to a symbol
enum CodeType {
    /// Evdev codes (u16)
    EvDev,
    /// Xkb codes (u32)
    XKB,
    /// Xkb Hardware key names (String)
    XKBHwKey,
}

#[doc(hidden)]
pub struct CodeUnknown;
#[doc(hidden)]
pub struct CodeEvdev;
#[doc(hidden)]
pub struct CodeXkb;
#[doc(hidden)]
pub struct CodeXkbHw;

#[doc(hidden)]
pub struct SymbolUnknown;
#[doc(hidden)]
pub struct SymbolUnicode;
#[doc(hidden)]
pub struct SymbolString(SymbolType);
#[doc(hidden)]
pub struct SymbolCodes;

#[doc(hidden)]
pub struct Fixed;
#[doc(hidden)]
pub struct Open;

/// Provides an easy way to create translation maps between hardware keys and their associated symbols.
/// 
/// Supports building of maps from/to Hardware identifiers of a key (Evdev keycode, Xkb keycode, 
/// Xkb key names (e.g. AD02) on one side and the symbols as unicode ('&', 'ä'), names ("ampersand", 
/// "adiaeresis") and codes (38, 228).
/// For unmapped keys, symbol names can be set to evdev names (EV_KEY_1).
/// Accepts maps and functions for custom replacement or formating of symbols (unicode/names).
/// 
/// Once the builder is set up, it can be used to translate multiple keymaps using the same options.
///
/// ```
/// // Load programmer dvorak layout
/// use std::collections::BTreeMap;
/// use xkb_evdev_trans::Keymap;
/// use xkb_evdev_trans::map_builder::{BuildMaps, Fill, MapBuilder, SymbolType};
///
/// let keymap = Keymap::from_rmlvo(
///   Some("evdev"), Some("pc105"), Some("us"), Some("dvp"), None, false
/// ).unwrap();
///
/// // Replace symbol "&" with "\ampersand"
/// let mut replace: BTreeMap<String, String> = BTreeMap::new();
/// replace.insert("&".to_string(), "\\ampersand".to_string());
///
/// // create builder for evdev <-> unicode (String)
/// let builder_str = MapBuilder::default()
/// .code_evdev()
/// .symbol(SymbolType::UnicodeSymbol)
/// // fill unmapped/invisible symbols with names from evdev
/// .fill(Fill::Evdev(true))
/// // using previously created replacement table
/// .replace_symbol_by_map(replace);
///
/// // build maps
/// let (to, from) = builder_str.build(&keymap, BuildMaps::Both);
///
/// assert_eq!(to[&5], "}"); // KEY_4
/// assert_eq!(to[&23], "c"); // KEY_I
/// assert_eq!(to[&2], "\\ampersand"); // KEY_1
/// assert_eq!(from[&"Escape".to_string()], 1); // KEY_ESCAPE
/// assert_eq!(from[&"KEY_SELECT".to_string()], 0x161); // KEY_SELECT
/// ```
/// 
/// **Note:** the current version only creates maps for the first layer of symbols (without modifiers).
pub struct MapBuilder<C, S, F> {
    code: PhantomData<C>,
    symbol: S,
    fill: Fill,
    replace: Vec<Replace>,
    _marker: PhantomData<F>,
}

impl Default for MapBuilder<CodeUnknown, SymbolUnknown, Open> {
    fn default() -> MapBuilder<CodeUnknown, SymbolUnknown, Open> {
        MapBuilder {
            code: PhantomData,
            symbol: SymbolUnknown,
            fill: Fill::None,
            replace: Vec::new(),
            _marker: PhantomData,
        }
    }
}

/// 
impl<C, S> MapBuilder<C, S, Open> {
    /// Sets the Hardware code part to Evdev codes (u16).
    pub fn code_evdev(self) -> MapBuilder<CodeEvdev, S, Open> {
        MapBuilder {
            code: PhantomData,
            symbol: self.symbol,
            fill: self.fill,
            replace: self.replace,
            _marker: PhantomData,
        }
    }

    /// Sets the Hardware code part to XKB codes (u32).
    pub fn code_xkb(self) -> MapBuilder<CodeXkb, S, Open> {
        MapBuilder {
            code: PhantomData,
            symbol: self.symbol,
            fill: self.fill,
            replace: self.replace,
            _marker: PhantomData,
        }
    }

    /// Sets the Hardware code part to XKB key names (String).
    pub fn code_xkb_hw(self) -> MapBuilder<CodeXkbHw, S, Open> {
        MapBuilder {
            code: PhantomData,
            symbol: self.symbol,
            fill: self.fill,
            replace: self.replace,
            _marker: PhantomData,
        }
    }

    /// Sets the symbol part to Unicode characters (char).
    pub fn symbol_unicode(self) -> MapBuilder<C, SymbolUnicode, Open> {
        MapBuilder {
            code: PhantomData,
            symbol: SymbolUnicode,
            fill: self.fill,
            replace: self.replace,
            _marker: PhantomData,
        }
    }
    
    /// Sets the symbol part to String.
    /// 
    /// `symbol` determines which field of Symbol will be used.
    pub fn symbol(self, symbol: SymbolType) -> MapBuilder<C, SymbolString, Open> {
        MapBuilder {
            code: PhantomData,
            symbol: SymbolString(symbol),
            fill: self.fill,
            replace: self.replace,
            _marker: PhantomData,
        }
    }
    /// Sets the the symbol part to xkb codes (`Vec<u32>`)
    pub fn symbol_codes(self) -> MapBuilder<C, SymbolCodes, Open> {
        MapBuilder {
            code: PhantomData,
            symbol: SymbolCodes,
            fill: self.fill,
            replace: self.replace,
            _marker: PhantomData,
        }
    }
}

impl<F> MapBuilder<CodeEvdev, SymbolString, F> {
    /// This will cause values for undefined symbols to be filled with constant names from Evdev 
    /// (e.g. KEY_F23).
    ///
    /// `fill` determines how these names are transformed.
    pub fn fill(self, fill: Fill) -> MapBuilder<CodeEvdev, SymbolString, Fixed> {
        MapBuilder {
            code: PhantomData,
            symbol: self.symbol,
            fill,
            replace: self.replace,
            _marker: PhantomData,
        }
    }
}

impl<C, F> MapBuilder<C, SymbolString, F> {
    /// Allows to replace certain symbol strings by a map.
    /// 
    /// Multiple replacements can be defined, which are applied in order of calls to 
    /// `replace_symbol_by_map` and `replace_symbol_by_function` for each string.
    pub fn replace_symbol_by_map(self, replace: BTreeMap<String, String>) -> MapBuilder<C, SymbolString, Fixed> {
        let mut r = self.replace.clone();
        r.push(MapString(replace));
        MapBuilder {
            code: PhantomData,
            symbol: self.symbol,
            fill: self.fill,
            replace: r,
            _marker: PhantomData,
        }
    }

    ///  Allows to replace certain symbol strings by applying a function.
    /// 
    /// Multiple replacements can be defined, which are applied in order of calls to 
    /// `replace_symbol_by_map` and `replace_symbol_by_function` for each string.
    pub fn replace_symbol_by_function(self, replace: fn(String) -> String) -> MapBuilder<C, SymbolString, Fixed> {
        let mut r = self.replace.clone();
        r.push(CustomString(replace));
        MapBuilder {
            code: PhantomData,
            symbol: self.symbol,
            fill: self.fill,
            replace: r,
            _marker: PhantomData,
        }
    }
    
    /// Resets all replacements, previously defined by `replace_symbol_by_map` or 
    /// `replace_symbol_by_function`. 
    /// 
    /// This is meant to be used when multiple maps are generated from the same Keymap.
    pub fn reset_replace(self) -> MapBuilder<C, SymbolString, Fixed> {
        MapBuilder {
            code: PhantomData,
            symbol: self.symbol,
            fill: self.fill,
            replace: Vec::new(),
            _marker: PhantomData,
        }
    }

    fn replace_str(&self, mut s: String) -> String {
        for r in &self.replace {
            match r {
                CustomString(f) => s = f(s),
                MapString(map) => {
                    if let Some(replacement) = map.get(&s) {
                        s = replacement.clone();
                    }
                }
                MapChar(_) | CustomChar(_) => unreachable!()
            }
        }
        s
    }
}

impl<C, F> MapBuilder<C, SymbolUnicode, F> {
    /// Allows to replace certain symbol characters by a map.
    ///
    /// Multiple replacements can be defined, which are applied in order of calls to 
    /// `replace_symbol_by_map` and `replace_symbol_by_function` for each character.
    pub fn replace_symbol_by_map(self, replace: HashMap<char, char>) -> MapBuilder<C, SymbolUnicode, Fixed> {
        let mut r = self.replace.clone();
        r.push(MapChar(replace));
        MapBuilder {
            code: PhantomData,
            symbol: SymbolUnicode,
            fill: self.fill,
            replace: r,
            _marker: PhantomData,
        }
    }
    ///  Allows to replace certain symbol strings by applying a function.
    ///
    /// Multiple replacements can be defined, which are applied in order of calls to 
    /// `replace_symbol_by_map` and `replace_symbol_by_function` for each character.
    pub fn replace_symbol_by_function(self, replace: fn(char) -> char) -> MapBuilder<C, SymbolUnicode, Fixed> {
        let mut r = self.replace.clone();
        r.push(CustomChar(replace));
        MapBuilder {
            code: PhantomData,
            symbol: self.symbol,
            fill: self.fill,
            replace: r,
            _marker: PhantomData,
        }
    }

    /// Resets all replacements, previously defined by `replace_symbol_by_map` or 
    /// `replace_symbol_by_function`. 
    ///
    /// This is meant to be used when multiple maps are generated from the same Keymap.
    pub fn reset_replace(self) -> MapBuilder<C, SymbolUnicode, Fixed> {
        MapBuilder {
            code: PhantomData,
            symbol: self.symbol,
            fill: self.fill,
            replace: Vec::new(),
            _marker: PhantomData,
        }
    }
    
    fn replace_char(&self, mut c: char) -> char {
        for r in &self.replace {
            match r {
                CustomChar(f) => c = f(c),
                MapChar(map) => {
                    if let Some(replacement) = map.get(&c) {
                        c = replacement.clone();
                    }
                }
                MapString(_) | CustomString(_) => unreachable!()
            }
        }
        c
    }
}

pub enum BuildMaps {
    CodeToSymbol,
    SymbolToCode,
    Both,
}
// *** build for CodeEvdev
impl<F> MapBuilder<CodeEvdev, SymbolString, F> {
    /// Builds the translation maps from a [Keymap].
    /// 
    /// `keymap` is the [Keymap] from which to build. 
    /// `out` determines which maps to build (code to symbol, symbol to code or both)
    /// 
    /// Returns a tuple of maps. The first one translates codes to symbols, the second one does the
    /// reverse. If `out` specified to build only one map, the other one will be empty.
    pub fn build(
        &self,
        keymap: &Keymap,
        out: BuildMaps,
    ) -> (HashMap<u16, String>, BTreeMap<String, u16>) {
        let mut map = HashMap::new();
        let mut reverse = BTreeMap::new();
        
        for k in &keymap.keys {
            let symbol = match self.symbol.0 {
                SymbolType::KeyName => Some(k.keyname.clone()),
                SymbolType::Unicode => {
                    if let Some(u) = k.visible_unicode() {
                        Some(String::from(u))
                    } else {
                        None
                    }
                }
                SymbolType::SymbolName => {
                    if let Some(ref s) = k.symbol_name() {
                        Some(s.clone())
                    } else {
                        None
                    }
                }
                SymbolType::UnicodeSymbol => {
                    if let Some(u) = k.visible_unicode() {
                        Some(String::from(u))
                    } else if let Some(ref s) = k.symbol_name() {
                        Some(s.clone())
                    } else {
                        None
                    }
                },
                SymbolType::SymbolDisplay => {
                    Some(k.display())
                }
            };
            if let Some(symbol) = symbol {
                let symbol = self.replace_str(symbol);
                match out {
                    BuildMaps::CodeToSymbol => {
                        map.insert(k.evdev_code(), symbol);
                    }
                    BuildMaps::SymbolToCode => {
                        reverse.insert(symbol, k.evdev_code());
                    }
                    BuildMaps::Both => {
                        map.insert(k.evdev_code(), symbol.clone());
                        reverse.insert(symbol, k.evdev_code());
                    }
                };
            }
        }

        match &self.fill {
            Fill::None => {}
            fill => {
                for ev in EventCodeIterator::new(&EventType::EV_KEY) {
                    let code = event_code_to_int(&ev).1 as u16;
                    if !map.contains_key(&code) {
                        let symbol = {
                            let en = format!("{ev:?}");
                            match fill {
                                Fill::None => {
                                    panic!("")
                                }
                                Fill::Evdev(true) => {
                                    // the following should always work because the key names follow a
                                    // certain pattern and only use ansi characters
                                    en[7..en.len() - 1].to_string()
                                }
                                Fill::Evdev(false) => en,
                                Fill::EvdevCustom(reformat) => reformat(en),
                            }
                        };
                        let symbol = self.replace_str(symbol);
                        match out {
                            BuildMaps::CodeToSymbol => {
                                map.insert(code, symbol);
                            }
                            BuildMaps::SymbolToCode => {
                                reverse.insert(symbol, code);
                            }
                            BuildMaps::Both => {
                                map.insert(code, symbol.clone());
                                reverse.insert(symbol, code);
                            }
                        };
                    }
                }
            }
        }
        (map, reverse)
    }
}

impl<F> MapBuilder<CodeEvdev, SymbolUnicode, F> {
    /// Builds the translation maps from a [Keymap].
    ///
    /// `keymap` is the [Keymap] from which to build. 
    /// `out` determines which maps to build (code to symbol, symbol to code or both)
    ///
    /// Returns a tuple of maps. The first one translates codes to symbols, the second one does the
    /// reverse. If `out` specified to build only one map, the other one will be empty.
    pub fn build(
        &self,
        keymap: &Keymap,
        out: BuildMaps,
    ) -> (HashMap<u16, char>, HashMap<char, u16>) {
        let mut map = HashMap::new();
        let mut reverse = HashMap::new();
        for k in &keymap.keys {
            if let Some(u) = k.visible_unicode() {
                let symbol = self.replace_char(u);
                let code = k.evdev_code();
                match out {
                    BuildMaps::CodeToSymbol => {
                        map.insert(code, symbol);
                    }
                    BuildMaps::SymbolToCode => {
                        reverse.insert(symbol, code);
                    }
                    BuildMaps::Both => {
                        map.insert(code, symbol);
                        reverse.insert(symbol, code);
                    }
                };
            }
        }
        (map, reverse)
    }
}
impl<F> MapBuilder<CodeEvdev, SymbolCodes, F> {
    /// Builds the translation maps from a [Keymap].
    ///
    /// `keymap` is the [Keymap] from which to build. 
    /// `out` determines which maps to build (code to symbol, symbol to code or both)
    ///
    /// Returns a tuple of maps. The first one translates codes to symbols, the second one does the
    /// reverse. If `out` specified to build only one map, the other one will be empty.
    pub fn build(
        &self,
        keymap: &Keymap,
        out: BuildMaps,
    ) -> (HashMap<u16, Vec<u32>>, HashMap<Vec<u32>, u16>) {
        let mut map = HashMap::new();
        let mut reverse = HashMap::new();
        for k in &keymap.keys {
            let code = k.evdev_code();
            let symbol = k.keysyms().clone();
            match out {
                BuildMaps::CodeToSymbol => {
                    map.insert(code, symbol);
                }
                BuildMaps::SymbolToCode => {
                    reverse.insert(symbol, code);
                }
                BuildMaps::Both => {
                    map.insert(code, symbol.clone());
                    reverse.insert(symbol, code);
                }
            };
        }
        (map, reverse)
    }
}

// *** build for CodeXkb
impl<F> MapBuilder<CodeXkb, SymbolString, F> {
    /// Builds the translation maps from a [Keymap].
    ///
    /// `keymap` is the [Keymap] from which to build. 
    /// `out` determines which maps to build (code to symbol, symbol to code or both)
    ///
    /// Returns a tuple of maps. The first one translates codes to symbols, the second one does the
    /// reverse. If `out` specified to build only one map, the other one will be empty.
    pub fn build(
        &self,
        keymap: &Keymap,
        out: BuildMaps,
    ) -> (HashMap<u32, String>, BTreeMap<String, u32>) {
        let mut map = HashMap::new();
        let mut reverse = BTreeMap::new();
        for k in &keymap.keys {
            let symbol = match self.symbol.0 {
                SymbolType::KeyName => Some(k.keyname.clone()),
                SymbolType::Unicode => {
                    if let Some(u) = k.visible_unicode() {
                        Some(String::from(u))
                    } else {
                        None
                    }
                }
                SymbolType::SymbolName => {
                    if let Some(ref s) = k.symbol_name() {
                        Some(s.clone())
                    } else {
                        None
                    }
                }
                SymbolType::UnicodeSymbol => {
                    if let Some(u) = k.visible_unicode() {
                        Some(String::from(u))
                    } else if let Some(ref s) = k.symbol_name() {
                        Some(s.clone())
                    } else {
                        None
                    }
                },
                SymbolType::SymbolDisplay => {
                    Some(k.display())
                }
            };
            if let Some(symbol) = symbol {
                let code = k.keycode;
                let symbol = self.replace_str(symbol);
                match out {
                    BuildMaps::CodeToSymbol => {
                        map.insert(code, symbol);
                    }
                    BuildMaps::SymbolToCode => {
                        reverse.insert(symbol, code);
                    }
                    BuildMaps::Both => {
                        map.insert(code, symbol.clone());
                        reverse.insert(symbol, code);
                    }
                };
            }
        }

        (map, reverse)
    }
}

impl<F> MapBuilder<CodeXkb, SymbolUnicode, F> {
    /// Builds the translation maps from a [Keymap].
    ///
    /// `keymap` is the [Keymap] from which to build. 
    /// `out` determines which maps to build (code to symbol, symbol to code or both)
    ///
    /// Returns a tuple of maps. The first one translates codes to symbols, the second one does the
    /// reverse. If `out` specified to build only one map, the other one will be empty.
    pub fn build(
        &self,
        keymap: &Keymap,
        out: BuildMaps,
    ) -> (HashMap<u32, char>, HashMap<char, u32>) {
        let mut map = HashMap::new();
        let mut reverse = HashMap::new();
        for k in &keymap.keys {
            if let Some(u) = k.visible_unicode() {
                let symbol = self.replace_char(u);
                let code = k.keycode;
                match out {
                    BuildMaps::CodeToSymbol => {
                        map.insert(code, symbol);
                    }
                    BuildMaps::SymbolToCode => {
                        reverse.insert(symbol, code);
                    }
                    BuildMaps::Both => {
                        map.insert(code, symbol);
                        reverse.insert(symbol, code);
                    }
                };
            }
        }
        (map, reverse)
    }
}
impl<F> MapBuilder<CodeXkb, SymbolCodes, F> {
    /// Builds the translation maps from a [Keymap].
    ///
    /// `keymap` is the [Keymap] from which to build. 
    /// `out` determines which maps to build (code to symbol, symbol to code or both)
    ///
    /// Returns a tuple of maps. The first one translates codes to symbols, the second one does the
    /// reverse. If `out` specified to build only one map, the other one will be empty.
    pub fn build(
        &self,
        keymap: &Keymap,
        out: BuildMaps,
    ) -> (HashMap<u32, Vec<u32>>, HashMap<Vec<u32>, u32>) {
        let mut map = HashMap::new();
        let mut reverse = HashMap::new();
        for k in &keymap.keys {
            let code = k.keycode;
            let symbol = k.keysyms().clone();
            match out {
                BuildMaps::CodeToSymbol => {
                    map.insert(code, symbol);
                }
                BuildMaps::SymbolToCode => {
                    reverse.insert(symbol, code);
                }
                BuildMaps::Both => {
                    map.insert(code, symbol.clone());
                    reverse.insert(symbol, code);
                }
            };
            map.insert(k.keycode, k.keysyms().clone());
        }
        (map, reverse)
    }
}

// *** build for CodeXkbHw

impl<F> MapBuilder<CodeXkbHw, SymbolString, F> {
    /// Builds the translation maps from a [Keymap].
    ///
    /// `keymap` is the [Keymap] from which to build. 
    /// `out` determines which maps to build (code to symbol, symbol to code or both)
    ///
    /// Returns a tuple of maps. The first one translates codes to symbols, the second one does the
    /// reverse. If `out` specified to build only one map, the other one will be empty.
    pub fn build(
        &self,
        keymap: &Keymap,
        out: BuildMaps,
    ) -> (BTreeMap<String, String>, BTreeMap<String, String>) {
        let mut map = BTreeMap::new();
        let mut reverse = BTreeMap::new();
        for k in &keymap.keys {
            let symbol = match self.symbol.0 {
                SymbolType::KeyName => Some(k.keyname.clone()),
                SymbolType::Unicode => {
                    if let Some(u) = k.visible_unicode() {
                        Some(String::from(u))
                    } else {
                        None
                    }
                }
                SymbolType::SymbolName => {
                    if let Some(ref s) = k.symbol_name() {
                        Some(s.clone())
                    } else {
                        None
                    }
                }
                SymbolType::UnicodeSymbol => {
                    if let Some(u) = k.visible_unicode() {
                        Some(String::from(u))
                    } else if let Some(ref s) = k.symbol_name() {
                        Some(s.clone())
                    } else {
                        None
                    }
                },
                SymbolType::SymbolDisplay => {
                    Some(k.display())
                }
            };
            if let Some(symbol) = symbol {
                let symbol = self.replace_str(symbol);
                let code = k.keyname.clone();
                match out {
                    BuildMaps::CodeToSymbol => {
                        map.insert(code, symbol);
                    }
                    BuildMaps::SymbolToCode => {
                        reverse.insert(symbol, code);
                    }
                    BuildMaps::Both => {
                        map.insert(code.clone(), symbol.clone());
                        reverse.insert(symbol, code);
                    }
                };
            }
        }
        (map, reverse)
    }
}
impl<F> MapBuilder<CodeXkbHw, SymbolUnicode, F> {
    /// Builds the translation maps from a [Keymap].
    ///
    /// `keymap` is the [Keymap] from which to build. 
    /// `out` determines which maps to build (code to symbol, symbol to code or both)
    ///
    /// Returns a tuple of maps. The first one translates codes to symbols, the second one does the
    /// reverse. If `out` specified to build only one map, the other one will be empty.
    pub fn build(
        &self,
        keymap: &Keymap,
        out: BuildMaps,
    ) -> (BTreeMap<String, char>, HashMap<char, String>) {
        let mut map = BTreeMap::new();
        let mut reverse = HashMap::new();
        for k in &keymap.keys {
            if let Some(u) = k.visible_unicode() {
                let symbol = self.replace_char(u);
                let code = k.keyname.clone();
                match out {
                    BuildMaps::CodeToSymbol => {
                        map.insert(code, symbol);
                    }
                    BuildMaps::SymbolToCode => {
                        reverse.insert(symbol, code);
                    }
                    BuildMaps::Both => {
                        map.insert(code.clone(), symbol);
                        reverse.insert(symbol, code);
                    }
                };
            }
        }
        (map, reverse)
    }
}
impl<F> MapBuilder<CodeXkbHw, SymbolCodes, F> {
    /// Builds the translation maps from a [Keymap].
    ///
    /// `keymap` is the [Keymap] from which to build. 
    /// `out` determines which maps to build (code to symbol, symbol to code or both)
    ///
    /// Returns a tuple of maps. The first one translates codes to symbols, the second one does the
    /// reverse. If `out` specified to build only one map, the other one will be empty.
    pub fn build(
        &self,
        keymap: &Keymap,
        out: BuildMaps,
    ) -> (BTreeMap<String, Vec<u32>>, HashMap<Vec<u32>, String>) {
        let mut map = BTreeMap::new();
        let mut reverse = HashMap::new();
        for k in &keymap.keys {
            let code = k.keyname.clone();
            let symbol = k.keysyms().clone();
            match out {
                BuildMaps::CodeToSymbol => {
                    map.insert(code, symbol);
                }
                BuildMaps::SymbolToCode => {
                    reverse.insert(symbol, code);
                }
                BuildMaps::Both => {
                    map.insert(code.clone(), symbol.clone());
                    reverse.insert(symbol, code);
                }
            };
        }
        (map, reverse)
    }
}

#[cfg(test)]
mod test {
    use crate::map_builder::{BuildMaps, Fill, MapBuilder, SymbolType};
    use crate::Keymap;
    use std::collections::BTreeMap;

    // Tests EVDEV codes <-> Anything and using string replace with (Map | Map + Function)
    #[test]
    fn test_builder_evdev() {
        let keymap =
            Keymap::from_rmlvo(Some("evdev"), Some("pc105"), Some("us"), Some("dvp"), None, false)
                .unwrap();

        let mut replace: BTreeMap<String, String> = BTreeMap::new();
        replace.insert("&".to_string(), "\\ampersand".to_string());

        let builder_str = MapBuilder::default()
            .code_evdev()
            .symbol(SymbolType::UnicodeSymbol)
            .fill(Fill::Evdev(true))
            .replace_symbol_by_map(replace);

        let (to, from) = builder_str.build(&keymap, BuildMaps::Both);

        assert_eq!(to[&5], "}"); // KEY_4
        assert_eq!(to[&23], "c"); // KEY_I
        assert_eq!(to[&2], "\\ampersand"); // KEY_1
        assert_eq!(to[&1], "Escape"); // KEY_ESC
        assert_eq!(to[&0x161], "KEY_SELECT");
        assert_eq!(to[&74], "-");

        assert_eq!(from[&"}".to_string()], 5); // KEY_4
        assert_eq!(from[&"c".to_string()], 23); // KEY_I
        assert_eq!(from[&"\\ampersand".to_string()], 2); // KEY_1
        assert_eq!(from[&"Escape".to_string()], 1); // KEY_ESCAPE
        assert_eq!(from[&"KEY_SELECT".to_string()], 0x161); // KEY_SELECT

        let (to, from) = builder_str
            .fill(Fill::EvdevCustom(|s: String| {
                s[11..s.len() - 1].to_lowercase()
            }))
            .replace_symbol_by_function(|s| s.to_lowercase())
            .build(&keymap, BuildMaps::Both);
        assert_eq!(to[&1], "escape"); // KEY_ESC
        assert_eq!(to[&2], "\\ampersand"); // KEY_1
        assert_eq!(to[&0x13a], "select"); // BTN_SELECT
        assert_eq!(to[&0x161], "select"); // KEY_SELECT
        assert_eq!(from[&"select".to_string()], 0x161); // KEY_SELECT

        // builder to display
        let builder_display = MapBuilder::default()
          .code_evdev()
          .symbol(SymbolType::SymbolDisplay)
          .fill(Fill::Evdev(true));

        let (to, from) = builder_display.build(&keymap, BuildMaps::Both);

        assert_eq!(to[&5], "}"); // KEY_4
        assert_eq!(to[&23], "c"); // KEY_I
        assert_eq!(to[&2], "&"); // KEY_1
        assert_eq!(to[&1], "Escape"); // KEY_ESC
        assert_eq!(to[&0x161], "KEY_SELECT");
        assert_eq!(to[&74], "KP_Subtract");

        assert_eq!(from[&"}".to_string()], 5); // KEY_4
        assert_eq!(from[&"c".to_string()], 23); // KEY_I
        assert_eq!(from[&"&".to_string()], 2); // KEY_1
        assert_eq!(from[&"Escape".to_string()], 1); // KEY_1
        assert_eq!(from[&"KEY_SELECT".to_string()], 0x161); // KEY_SELECT
        // to unicode only
        let builder_char = MapBuilder::default()
          .code_evdev()
          .symbol_unicode();

        let (to, from) = builder_char.build(&keymap, BuildMaps::Both);
        assert_eq!(to.get(&1), None); // KEY_ESC
        assert_eq!(to[&2], '&'); // KEY_1
        assert_eq!(from[&'b'], 49); // KEY_N

        let builder_symbols = MapBuilder::default()
          .code_evdev()
          .symbol_codes();

        let (to, from) = builder_symbols.build(&keymap, BuildMaps::Both);
        assert_eq!(to[&1], vec![65307]); // KEY_ESC
        assert_eq!(to[&2], vec![38]); // KEY_1
        assert_eq!(from[&vec![98]], 49); // KEY_N
    }

    // Tests XKB codes <-> Anything and using string replace with (Map | Function) and reset_replace
    #[test]
    fn test_builder_xkb() {
        let keymap =
          Keymap::from_rmlvo(Some("evdev"), Some("pc105"), Some("us"), Some("dvp"), None, false)
            .unwrap();

        let mut replace: BTreeMap<String, String> = BTreeMap::new();
        replace.insert("&".to_string(), "\\ampersand".to_string());

        let builder_str = MapBuilder::default()
          .code_xkb()
          .symbol(SymbolType::Unicode)
          .replace_symbol_by_map(replace);

        let (to, from) = builder_str.build(&keymap, BuildMaps::Both);

        assert_eq!(to[&13], "}"); // KEY_4
        assert_eq!(to[&31], "c"); // KEY_I
        assert_eq!(to[&10], "\\ampersand"); // KEY_1
        assert_eq!(to.get(&9), None); // KEY_ESC
        assert_eq!(to.get(&0x161), None);

        assert_eq!(from[&"}".to_string()], 13); // KEY_4
        assert_eq!(from[&"c".to_string()], 31); // KEY_I
        assert_eq!(from[&"\\ampersand".to_string()], 10); // KEY_1
        assert_eq!(from.get(&"KEY_SELECT".to_string()), None); // KEY_SELECT

        let (to, from) = builder_str
          .reset_replace()
          .replace_symbol_by_function(|s| s.to_lowercase())
          .build(&keymap, BuildMaps::Both);
        assert_eq!(to.get(&9), None); // KEY_ESC
        assert_eq!(to[&10], "&"); // KEY_1
        assert_eq!(from[&"b".to_string()], 57); // KEY_SELECT

        // to unicode only
        let builder_char = MapBuilder::default()
          .code_xkb()
          .symbol_unicode();

        let (to, from) = builder_char.build(&keymap, BuildMaps::Both);
        assert_eq!(to.get(&9), None); // KEY_ESC
        assert_eq!(to[&10], '&'); // KEY_1
        assert_eq!(from[&'b'], 57); // KEY_N

        let builder_symbols = MapBuilder::default()
          .code_xkb()
          .symbol_codes();

        let (to, from) = builder_symbols.build(&keymap, BuildMaps::Both);
        assert_eq!(to.get(&1), None); // KEY_ESC
        assert_eq!(to[&10], vec![38]); // KEY_1
        assert_eq!(from[&vec![98]], 57); // KEY_N
    }

    // tests XKB-Hardware Codes <-> Anything
    #[test]
    fn test_builder_xkb_hw() {
        let keymap =
          Keymap::from_rmlvo(Some("evdev"), Some("pc105"), Some("us"), Some("dvp"), None, false)
            .unwrap();

        let builder_str = MapBuilder::default()
          .code_xkb_hw()
          .symbol(SymbolType::SymbolName)
          .replace_symbol_by_function(|s| s.to_uppercase());

        let (to, from) = builder_str.build(&keymap, BuildMaps::Both);

        assert_eq!(to["AE04"], "BRACERIGHT"); // KEY_4
        assert_eq!(to["AD08"], "C"); // KEY_I
        assert_eq!(to["AE01"], "AMPERSAND"); // KEY_1
        assert_eq!(to["ESC"], "ESCAPE"); // KEY_ESC
        assert_eq!(to.get("SUPR"), None); // SUPR - xkb symbol used for either (Left|Right) modifier?

        assert_eq!(from["BRACERIGHT"], "AE04"); // KEY_4
        assert_eq!(from["C"], "AD08"); // KEY_I
        assert_eq!(from["AMPERSAND"], "AE01"); // KEY_1
        assert_eq!(from.get("not_a_key"), None); // KEY_SELECT

        // to unicode only
        let builder_char = MapBuilder::default()
          .code_xkb_hw()
          .symbol_unicode();

        let (to, from) = builder_char.build(&keymap, BuildMaps::Both);
        assert_eq!(to.get("ESC"), None); // KEY_ESC
        assert_eq!(to["AE01"], '&'); // KEY_1
        assert_eq!(from[&'b'], "AB06"); // KEY_N

        let builder_symbols = MapBuilder::default()
          .code_xkb_hw()
          .symbol_codes();

        let (to, from) = builder_symbols.build(&keymap, BuildMaps::Both);
        assert_eq!(to.get("ESC"), Some(vec![65307]).as_ref()); // KEY_ESC
        assert_eq!(to["AE01"], vec![38]); // KEY_1
        assert_eq!(from[&vec![98]], "AB06"); // KEY_N
    }
}