#![warn(missing_docs)]
//! # Emote Mapper
//!
//! `emote_mapper` is a collection of utilities to create and use emote maps from [`twitchmote`](https://github.com/ModProg/twitchmote)

use serde::*;
use serde_with::{serde_as, TryFromInto};
use thiserror::Error;

use serde::*;
use serde_with::{serde_as, TryFromInto};
use thiserror::Error;

/// The EmoteMapper holds a Map of emote names and code points
/// It can be used for:
/// - using an emote map stored as csv to map emotes
/// - storing an emote map as csv

    fn default() -> Self {
        Self {
            map: Default::default(),
            emote_width: 3,
        }
    }

    fn default() -> Self { Self { map: Default::default(), emote_width: 3 } }

    /// The emote width used for `to_string` and `replace_all`
    ///
    /// **NOTE:** This depends both on the emote and the primary font used by the terminal

    pub fn to_char(&self, emote_name: &str) -> Option<char> {
        self.map.get(emote_name).copied().map(char::from)
    }

    /// Returns the char representing the `emote_name`
    pub fn to_char(&self, emote_name: &str) -> Option<char> { self.map.get(emote_name).copied().map(char::from) }

    /// Returns a string with the char representing the `emote_name` padded to `emte_width`

        self.to_char(emote_name)
            .map(|c| format!("{}{}", c, " ".repeat(self.emote_width - 1)))

        self.to_char(emote_name).map(|c| format!("{}{}", c, " ".repeat(self.emote_width - 1)))

    /// Replaces all emotes in the `message` given

            self.to_string(w.get(0).unwrap().as_str())
                .unwrap_or_else(|| w.get(0).unwrap().as_str().to_owned())

            self.to_string(w.get(0).unwrap().as_str()).unwrap_or_else(|| w.get(0).unwrap().as_str().to_owned())

    /// Creates an EmoteMapper from a Reader containing csv data

        let mut rdr = csv::ReaderBuilder::new()
            .has_headers(false)
            .trim(Trim::All)
            .from_reader(rdr);

        let mut rdr = csv::ReaderBuilder::new().has_headers(false).trim(Trim::All).from_reader(rdr);

        Ok(EmoteMapper {
            map,
            ..EmoteMapper::default()
        })

        Ok(EmoteMapper { map, ..EmoteMapper::default() })

    pub fn from_path(p: &Path) -> Result<Self, EmoteMapperError> {
        Self::from_reader(File::open(p).map_err(IOError)?)
    }

    /// Creates an EmoteMapper from a File containing csv data
    pub fn from_path(p: &Path) -> Result<Self, EmoteMapperError> { Self::from_reader(File::open(p).map_err(IOError)?) }

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        Self::from_reader(s.as_bytes())
    }

    /// Creates an EmoteMapper from a String containing csv data
    fn from_str(s: &str) -> Result<Self, Self::Err> { Self::from_reader(s.as_bytes()) }

    /// Writes the EmoteMapper as csv to a Writer

        let mut wtr = csv::WriterBuilder::new()
            .has_headers(false)
            .from_writer(wtr);

        let mut wtr = csv::WriterBuilder::new().has_headers(false).from_writer(wtr);

    }
    pub fn to_path(self, p: &Path) -> Result<(), EmoteMapperError> {
        self.to_writer(File::open(p).map_err(IOError)?)

    /// Stores the EmoteMapper as csv in a File
    pub fn to_path(self, p: &Path) -> Result<(), EmoteMapperError> { self.to_writer(File::open(p).map_err(IOError)?) }

    /// The EmoteMapper as CSV

            val.to_writer(unsafe { s.as_mut_vec() })
                .expect("Writing to String should not fail");

            val.to_writer(unsafe { s.as_mut_vec() }).expect("Writing to String should not fail");

    fn from((name, code_point): (String, CodePoint)) -> Self {
        Mapping { name, code_point }
    }

    fn from((name, code_point): (String, CodePoint)) -> Self { Mapping { name, code_point } }

#[allow(missing_docs)]

    fn from(cp: CodePoint) -> Self {
        cp.0
    }

    fn from(cp: CodePoint) -> Self { cp.0 }

    fn fmt(&self, f: &mut __private::Formatter<'_>) -> std::fmt::Result {
        char::from(*self).fmt(f)
    }

    fn fmt(&self, f: &mut __private::Formatter<'_>) -> std::fmt::Result { char::from(*self).fmt(f) }

    fn from(val: CodePoint) -> Self {
        format!("{:X}", val.0 as u32)
    }

    fn from(val: CodePoint) -> Self { format!("{:X}", val.0 as u32) }

            char::from_u32(
                u32::from_str_radix(&s, 16).map_err(|_| InvalidCodepoint(s.to_string()))?,
            )
            .ok_or_else(|| InvalidCodepoint(s.to_string()))?,

            char::from_u32(u32::from_str_radix(&s, 16).map_err(|_| InvalidCodepoint(s.to_string()))?)
                .ok_or_else(|| InvalidCodepoint(s.to_string()))?,

    let em = EmoteMapper::from_path(&PathBuf::from("examples/twitch_emotes.csv"))
        .unwrap()
        .emote_width(2);

    let em = EmoteMapper::from_path(&PathBuf::from("examples/twitch_emotes.csv")).unwrap().emote_width(2);

    let messages = vec![
        "modproHi, how are you doing?",
        "<3, great",
        "tggleBoss Kappa xD",
    ];

    let messages = vec!["modproHi, how are you doing?", "<3, great", "tggleBoss Kappa xD"];