A!leys Galerie

use std::io::{self, Write};
use std::process::exit;
use clap::{App, Arg};
use base64::{encode, decode as base64_decode};
use hex::encode as hex_encode;
use hex::decode as hex_decode;

fn main() {
    let matches = App::new("PixelPeg")
        .version("1.0.0")
        .author("Ailey")
        .about("Base64/hex encoder-decoder with pixel-art output")
        .arg(
            Arg::with_name("input")
                .required(true)
                .help("Input string to encode or decode")
        )
        .arg(
            Arg::with_name("mode")
                .short("m")
                .long("mode")
                .value_name("MODE")
                .help("Operation mode: encode (default), decode, pixel")
                .possible_value("encode")
                .possible_value("decode")
                .possible_value("pixel")
                .default_value("encode")
        )
        .arg(
            Arg::with_name("format")
                .short("f")
                .long("format")
                .value_name("FORMAT")
                .help("Output format: hex (default), base64")
                .possible_value("hex")
                .possible_value("base64")
                .default_value("hex")
        )
        .get_matches();

    let input = matches.value_of("input").unwrap();
    let mode = matches.value_of("mode").unwrap();
    let format = matches.value_of("format").unwrap();

    match mode {
        "encode" => {
            let encoded = match format {
                "hex" => hex_encode(input.as_bytes()),
                "base64" => encode(input.as_bytes()),
                _ => unreachable!(),
            };
            println!("[+] Encoded: {}", encoded);
            println!("Pixel Art:");
            draw_pixel_art(&encoded);
        },
        "decode" => {
            let decoded = match format {
                "hex" => String::from_utf8(hex_decode(input).unwrap_or_else(|_| {
                    eprintln!("Error: Invalid hex input");
                    exit(1);
                })).unwrap_or_else(|_| {
                    eprintln!("Error: Invalid UTF-8");
                    exit(1);
                })),
                "base64" => String::from_utf8(base64_decode(input).unwrap_or_else(|_| {
                    eprintln!("Error: Invalid base64 input");
                    exit(1);
                })).unwrap_or_else(|_| {
                    eprintln!("Error: Invalid UTF-8");
                    exit(1);
                }),
                _ => unreachable!(),
            };
            println!("[+] Decoded: {}", decoded);
        },
        "pixel" => {
            // Generate a small pixel art from the input string
            let pixel_art = generate_pixel_art(input);
            println!("{}", pixel_art);
        },
        _ => unreachable!(),
    }
}

fn draw_pixel_art(s: &str) {
    let chars: Vec<char> = s.chars().collect();
    let width = 16;
    let height = 16;

    for y in 0..height {
        for x in 0..width {
            let idx = (y * width + x) as usize;
            if idx < chars.len() {
                if chars[idx].is_ascii_alphanumeric() {
                    print!("██");
                } else {
                    print!("  ");
                }
            } else {
                print!("  ");
            }
        }
        println!();
    }
}

fn generate_pixel_art(input: &str) -> String {
    let mut output = String::new();

    for (i, c) in input.chars().enumerate() {
        match c {
            'a'..='z' => output.push_str("  ██  \n ████ \n  ██  "),
            'A'..='Z' => output.push_str("██████\n██    █\n██    █\n██    █\n██████"),
            '0'..='9' => output.push_str(" ███ \n█   █\n█   █\n█   █\n ███ "),
            _ => output.push_str("  ██  \n ████ \n  ██  "),
        }

        if i % 4 == 0 {
            output.push('\n');
        }
    }

    output
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_encode_hex() {
        let input = "hello";
        let expected = "68656c6c6f";
        assert_eq!(hex_encode(input.as_bytes()), expected);
    }

    #[test]
    fn test_encode_base64() {
        let input = "hello";
        let expected = "aGVsbG8=";
        assert_eq!(encode(input.as_bytes()), expected);
    }

    #[test]
    fn test_decode_hex() {
        let input = "68656c6c6f";
        let expected = "hello";
        assert_eq!(String::from_utf8(hex_decode(input).unwrap()).unwrap(), expected);
    }

    #[test]
    fn test_decode_base64() {
        let input = "aGVsbG8=";
        let expected = "hello";
        assert_eq!(String::from_utf8(base64_decode(input).unwrap()).unwrap(), expected);
    }
}