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);
    }
}

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Cosmic Scroll Reveal</title>
  <style>
    :root {
      --bg: #000;
      --star: #fff;
      --planet1: #4a90e2;
      --planet2: #800080;
      --planet3: #ffa500;
      --sun: #ff4500;
    }

    body {
      margin: 0;
      padding: 0;
      background-color: var(--bg);
      overflow-x: hidden;
      font-family: 'Courier New', monospace;
      color: var(--star);
      line-height: 1.6;
      height: 200vh;
    }

    .container {
      position: relative;
      height: 100vh;
      width: 100%;
    }

    .sky {
      position: absolute;
      width: 100%;
      height: 100%;
      background: radial-gradient(circle at 30% 50%, rgba(255, 255, 255, 0.1) 0%, transparent 50%),
                  radial-gradient(circle at 70% 30%, rgba(255, 255, 255, 0.1) 0%, transparent 50%);
      pointer-events: none;
    }

    .star {
      position: absolute;
      width: 4px;
      height: 4px;
      background-color: var(--star);
      border-radius: 50%;
      opacity: 0;
      animation: flicker 2s infinite ease-in-out;
      pointer-events: none;
    }

    .planet {
      position: absolute;
      border-radius: 50%;
      opacity: 0;
      transform-origin: center;
    }

    .planet-1 {
      width: 60px;
      height: 60px;
      background-color: var(--planet1);
      box-shadow: 0 0 20px 5px var(--planet1);
    }

    .planet-2 {
      width: 80px;
      height: 80px;
      background-color: var(--planet2);
      box-shadow: 0 0 30px 10px var(--planet2);
    }

    .planet-3 {
      width: 40px;
      height: 40px;
      background-color: var(--planet3);
      box-shadow: 0 0 15px 5px var(--planet3);
    }

    .sun {
      position: absolute;
      width: 120px;
      height: 120px;
      background: radial-gradient(circle, var(--sun) 0%, rgba(255, 100, 0, 0.5) 50%, transparent 100%);
      border-radius: 50%;
      opacity: 0;
      animation: pulse 4s infinite ease-in-out;
    }

    .message {
      position: fixed;
      top: 20px;
      left: 50%;
      transform: translateX(-50%);
      text-align: center;
      z-index: 10;
      opacity: 0;
      transition: opacity 0.5s ease;
    }

    .message.show {
      opacity: 1;
    }

    .blink {
      animation: blink 1s infinite;
    }

    @keyframes flicker {
      0%, 19%, 21%, 23%, 25%, 54%, 56%, 100% { opacity: 0; }
      20%, 22%, 24%, 55% { opacity: 0.7; }
    }

    @keyframes pulse {
      0% { transform: scale(1); opacity: 0.5; }
      50% { transform: scale(1.1); opacity: 1; }
      100% { transform: scale(1); opacity: 0.5; }
    }

    @keyframes blink {
      0%, 50% { opacity: 1; }
      25%, 75% { opacity: 0; }
    }
  </style>
</head>
<body>
  <div class="container">
    <div class="sky"></div>

    <!-- Stars -->
    <div class="star" style="top: 10%; left: 15%;"></div>
    <div class="star" style="top: 20%; left: 80%;"></div>
    <div class="star" style="top: 35%; left: 10%;"></div>
    <div class="star" style="top: 45%; left: 90%;"></div>
    <div class="star" style="top: 60%; left: 20%;"></div>
    <div class="star" style="top: 70%; left: 75%;"></div>
    <div class="star" style="top: 85%; left: 15%;"></div>
    <div class="star" style="top: 90%; left: 85%;"></div>

    <!-- Planets -->
    <div class="planet planet-1" id="planet1" style="top: 50%; left: 20%;"></div>
    <div class="planet planet-2" id="planet2" style="top: 60%; left: 70%;"></div>
    <div class="planet planet-3" id="planet3" style="top: 40%; left: 60%;"></div>

    <!-- Sun -->
    <div class="sun" id="sun" style="top: 70%; left: 40%;"></div>

    <!-- Message -->
    <div class="message" id="message">
      <div>Scroll to explore the cosmos</div>
      <div class="blink">⚠️ ACTIVATE THE UNIVERSE ⚠️</div>
    </div>
  </div>

  <script>
    document.addEventListener('DOMContentLoaded', function() {
      const observer = new IntersectionObserver((entries) => {
        entries.forEach(entry => {
          if (entry.isIntersecting) {
            const element = entry.target;

            if (element.classList.contains('star')) {
              element.style.opacity = '1';
              element.style.animationDuration = `${Math.random() * 1 + 1}s`;
            } else if (element.classList.contains('planet')) {
              element.style.opacity = '1';
              element.style.animation = `orbit ${Math.random() * 5 + 5}s linear infinite`;
            } else if (element.id === 'sun') {
              element.style.opacity = '1';
              element.style.animation = 'pulse 4s infinite ease-in-out';
            }
          }
        });
      }, {
        threshold: 0.1
      });

      // Observe all elements
      document.querySelectorAll('.star, .planet, #sun').forEach(el => {
        observer.observe(el);
      });

      // Message visibility
      const message = document.getElementById('message');
      const messageObserver = new IntersectionObserver((entries) => {
        if (entries[0].isIntersecting) {
          message.classList.add('show');
        } else {
          message.classList.remove('show');
        }
      });

      messageObserver.observe(message);

      // Add orbit animation for planets
      const style = document.createElement('style');
      style.textContent = `
        @keyframes orbit {
          0% { transform: rotate(0deg) translateY(0px); }
          100% { transform: rotate(360deg) translateY(0px); }
        }
        @keyframes supernova {
          0% { transform: scale(1); }
          50% { transform: scale(1.5); opacity: 0.8; }
          100% { transform: scale(1); opacity: 0; }
        }
      `;
      document.head.appendChild(style);

      // Add event listeners for planets
      document.getElementById('planet1').addEventListener('click', () => {
        const supernova = document.createElement('div');
        supernova.style.position = 'fixed';
        supernova.style.width = '200px';
        supernova.style.height = '200px';
        supernova.style.borderRadius = '50%';
        supernova.style.background = 'radial-gradient(circle, #4a90e2 0%, rgba(74, 144, 226, 0.5) 50%, transparent 100%)';
        supernova.style.opacity = '0';
        supernova.style.zIndex = '100';
        supernova.style.animation = 'supernova 1s ease-out forwards';
        supernova.style.pointerEvents = 'none';
        document.body.appendChild(supernova);

        const rect = document.getElementById('planet1').getBoundingClientRect();
        supernova.style.left = `${rect.left + rect.width/2 - supernova.offsetWidth/2}px`;
        supernova.style.top = `${rect.top + rect.height/2 - supernova.offsetHeight/2}px`;

        setTimeout(() => supernova.remove(), 1000);
      });

      document.getElementById('planet2').addEventListener('click', () => {
        const supernova = document.createElement('div');
        supernova.style.position = 'fixed';
        supernova.style.width = '250px';
        supernova.style.height = '250px';
        supernova.style.borderRadius = '50%';
        supernova.style.background = 'radial-gradient(circle, #800080 0%, rgba(128, 0, 128, 0.5) 50%, transparent 100%)';
        supernova.style.opacity = '0';
        supernova.style.zIndex = '100';
        supernova.style.animation = 'supernova 1s ease-out forwards';
        supernova.style.pointerEvents = 'none';
        document.body.appendChild(supernova);

        const rect = document.getElementById('planet2').getBoundingClientRect();
        supernova.style.left = `${rect.left + rect.width/2 - supernova.offsetWidth/2}px`;
        supernova.style.top = `${rect.top + rect.height/2 - supernova.offsetHeight/2}px`;

        setTimeout(() => supernova.remove(), 1000);
      });
    });
  </script>
</body>
</html>