/// Convert cp437 encoded string to [`String`].
use crate::error::Error;

pub fn cp437_char_to_char(input: u8) -> char {
    char::from_u32(match input {
        0x00..=0x7f => input as u32,
        0x80 => 0x00c7,
        0x81 => 0x00fc,
        0x82 => 0x00e9,
        0x83 => 0x00e2,
        0x84 => 0x00e4,
        0x85 => 0x00e0,
        0x86 => 0x00e5,
        0x87 => 0x00e7,
        0x88 => 0x00ea,
        0x89 => 0x00eb,
        0x8a => 0x00e8,
        0x8b => 0x00ef,
        0x8c => 0x00ee,
        0x8d => 0x00ec,
        0x8e => 0x00c4,
        0x8f => 0x00c5,
        0x90 => 0x00c9,
        0x91 => 0x00e6,
        0x92 => 0x00c6,
        0x93 => 0x00f4,
        0x94 => 0x00f6,
        0x95 => 0x00f2,
        0x96 => 0x00fb,
        0x97 => 0x00f9,
        0x98 => 0x00ff,
        0x99 => 0x00d6,
        0x9a => 0x00dc,
        0x9b => 0x00a2,
        0x9c => 0x00a3,
        0x9d => 0x00a5,
        0x9e => 0x20a7,
        0x9f => 0x0192,
        0xa0 => 0x00e1,
        0xa1 => 0x00ed,
        0xa2 => 0x00f3,
        0xa3 => 0x00fa,
        0xa4 => 0x00f1,
        0xa5 => 0x00d1,
        0xa6 => 0x00aa,
        0xa7 => 0x00ba,
        0xa8 => 0x00bf,
        0xa9 => 0x2310,
        0xaa => 0x00ac,
        0xab => 0x00bd,
        0xac => 0x00bc,
        0xad => 0x00a1,
        0xae => 0x00ab,
        0xaf => 0x00bb,
        0xb0 => 0x2591,
        0xb1 => 0x2592,
        0xb2 => 0x2593,
        0xb3 => 0x2502,
        0xb4 => 0x2524,
        0xb5 => 0x2561,
        0xb6 => 0x2562,
        0xb7 => 0x2556,
        0xb8 => 0x2555,
        0xb9 => 0x2563,
        0xba => 0x2551,
        0xbb => 0x2557,
        0xbc => 0x255d,
        0xbd => 0x255c,
        0xbe => 0x255b,
        0xbf => 0x2510,
        0xc0 => 0x2514,
        0xc1 => 0x2534,
        0xc2 => 0x252c,
        0xc3 => 0x251c,
        0xc4 => 0x2500,
        0xc5 => 0x253c,
        0xc6 => 0x255e,
        0xc7 => 0x255f,
        0xc8 => 0x255a,
        0xc9 => 0x2554,
        0xca => 0x2569,
        0xcb => 0x2566,
        0xcc => 0x2560,
        0xcd => 0x2550,
        0xce => 0x256c,
        0xcf => 0x2567,
        0xd0 => 0x2568,
        0xd1 => 0x2564,
        0xd2 => 0x2565,
        0xd3 => 0x2559,
        0xd4 => 0x2558,
        0xd5 => 0x2552,
        0xd6 => 0x2553,
        0xd7 => 0x256b,
        0xd8 => 0x256a,
        0xd9 => 0x2518,
        0xda => 0x250c,
        0xdb => 0x2588,
        0xdc => 0x2584,
        0xdd => 0x258c,
        0xde => 0x2590,
        0xdf => 0x2580,
        0xe0 => 0x03b1,
        0xe1 => 0x00df,
        0xe2 => 0x0393,
        0xe3 => 0x03c0,
        0xe4 => 0x03a3,
        0xe5 => 0x03c3,
        0xe6 => 0x00b5,
        0xe7 => 0x03c4,
        0xe8 => 0x03a6,
        0xe9 => 0x0398,
        0xea => 0x03a9,
        0xeb => 0x03b4,
        0xec => 0x221e,
        0xed => 0x03c6,
        0xee => 0x03b5,
        0xef => 0x2229,
        0xf0 => 0x2261,
        0xf1 => 0x00b1,
        0xf2 => 0x2265,
        0xf3 => 0x2264,
        0xf4 => 0x2320,
        0xf5 => 0x2321,
        0xf6 => 0x00f7,
        0xf7 => 0x2248,
        0xf8 => 0x00b0,
        0xf9 => 0x2219,
        0xfa => 0x00b7,
        0xfb => 0x221a,
        0xfc => 0x207f,
        0xfd => 0x00b2,
        0xfe => 0x25a0,
        0xff => 0x00a0,
    })
    .unwrap()
}

pub fn cp437_to_string(input: &[u8]) -> String {
    input.iter().cloned().map(cp437_char_to_char).collect()
}

pub fn char_to_cp437_char(input: char) -> Result<u8, Error> {
    let input: u32 = input.into();
    match input {
        0x00..=0x7f => Ok(input as u8),
        0x00c7 => Ok(0x80),
        0x00fc => Ok(0x81),
        0x00e9 => Ok(0x82),
        0x00e2 => Ok(0x83),
        0x00e4 => Ok(0x84),
        0x00e0 => Ok(0x85),
        0x00e5 => Ok(0x86),
        0x00e7 => Ok(0x87),
        0x00ea => Ok(0x88),
        0x00eb => Ok(0x89),
        0x00e8 => Ok(0x8a),
        0x00ef => Ok(0x8b),
        0x00ee => Ok(0x8c),
        0x00ec => Ok(0x8d),
        0x00c4 => Ok(0x8e),
        0x00c5 => Ok(0x8f),
        0x00c9 => Ok(0x90),
        0x00e6 => Ok(0x91),
        0x00c6 => Ok(0x92),
        0x00f4 => Ok(0x93),
        0x00f6 => Ok(0x94),
        0x00f2 => Ok(0x95),
        0x00fb => Ok(0x96),
        0x00f9 => Ok(0x97),
        0x00ff => Ok(0x98),
        0x00d6 => Ok(0x99),
        0x00dc => Ok(0x9a),
        0x00a2 => Ok(0x9b),
        0x00a3 => Ok(0x9c),
        0x00a5 => Ok(0x9d),
        0x20a7 => Ok(0x9e),
        0x0192 => Ok(0x9f),
        0x00e1 => Ok(0xa0),
        0x00ed => Ok(0xa1),
        0x00f3 => Ok(0xa2),
        0x00fa => Ok(0xa3),
        0x00f1 => Ok(0xa4),
        0x00d1 => Ok(0xa5),
        0x00aa => Ok(0xa6),
        0x00ba => Ok(0xa7),
        0x00bf => Ok(0xa8),
        0x2310 => Ok(0xa9),
        0x00ac => Ok(0xaa),
        0x00bd => Ok(0xab),
        0x00bc => Ok(0xac),
        0x00a1 => Ok(0xad),
        0x00ab => Ok(0xae),
        0x00bb => Ok(0xaf),
        0x2591 => Ok(0xb0),
        0x2592 => Ok(0xb1),
        0x2593 => Ok(0xb2),
        0x2502 => Ok(0xb3),
        0x2524 => Ok(0xb4),
        0x2561 => Ok(0xb5),
        0x2562 => Ok(0xb6),
        0x2556 => Ok(0xb7),
        0x2555 => Ok(0xb8),
        0x2563 => Ok(0xb9),
        0x2551 => Ok(0xba),
        0x2557 => Ok(0xbb),
        0x255d => Ok(0xbc),
        0x255c => Ok(0xbd),
        0x255b => Ok(0xbe),
        0x2510 => Ok(0xbf),
        0x2514 => Ok(0xc0),
        0x2534 => Ok(0xc1),
        0x252c => Ok(0xc2),
        0x251c => Ok(0xc3),
        0x2500 => Ok(0xc4),
        0x253c => Ok(0xc5),
        0x255e => Ok(0xc6),
        0x255f => Ok(0xc7),
        0x255a => Ok(0xc8),
        0x2554 => Ok(0xc9),
        0x2569 => Ok(0xca),
        0x2566 => Ok(0xcb),
        0x2560 => Ok(0xcc),
        0x2550 => Ok(0xcd),
        0x256c => Ok(0xce),
        0x2567 => Ok(0xcf),
        0x2568 => Ok(0xd0),
        0x2564 => Ok(0xd1),
        0x2565 => Ok(0xd2),
        0x2559 => Ok(0xd3),
        0x2558 => Ok(0xd4),
        0x2552 => Ok(0xd5),
        0x2553 => Ok(0xd6),
        0x256b => Ok(0xd7),
        0x256a => Ok(0xd8),
        0x2518 => Ok(0xd9),
        0x250c => Ok(0xda),
        0x2588 => Ok(0xdb),
        0x2584 => Ok(0xdc),
        0x258c => Ok(0xdd),
        0x2590 => Ok(0xde),
        0x2580 => Ok(0xdf),
        0x03b1 => Ok(0xe0),
        0x00df => Ok(0xe1),
        0x0393 => Ok(0xe2),
        0x03c0 => Ok(0xe3),
        0x03a3 => Ok(0xe4),
        0x03c3 => Ok(0xe5),
        0x00b5 => Ok(0xe6),
        0x03c4 => Ok(0xe7),
        0x03a6 => Ok(0xe8),
        0x0398 => Ok(0xe9),
        0x03a9 => Ok(0xea),
        0x03b4 => Ok(0xeb),
        0x221e => Ok(0xec),
        0x03c6 => Ok(0xed),
        0x03b5 => Ok(0xee),
        0x2229 => Ok(0xef),
        0x2261 => Ok(0xf0),
        0x00b1 => Ok(0xf1),
        0x2265 => Ok(0xf2),
        0x2264 => Ok(0xf3),
        0x2320 => Ok(0xf4),
        0x2321 => Ok(0xf5),
        0x00f7 => Ok(0xf6),
        0x2248 => Ok(0xf7),
        0x00b0 => Ok(0xf8),
        0x2219 => Ok(0xf9),
        0x00b7 => Ok(0xfa),
        0x221a => Ok(0xfb),
        0x207f => Ok(0xfc),
        0x00b2 => Ok(0xfd),
        0x25a0 => Ok(0xfe),
        0x00a0 => Ok(0xff),
        _ => Err(Error::NotCp437),
    }
}

pub fn string_to_cp437(input: &str) -> Result<Vec<u8>, Error> {
    let mut bin = vec![];
    for cha in input.chars() {
        bin.push(char_to_cp437_char(cha)?);
    }
    Ok(bin)
}