A!leys Galerie

#!/usr/bin/env python3
"""
NeonCipher - File Encryption Utility with ASCII Art Visualization
"""

import os
import sys
import argparse
import hashlib
import json
import time
from typing import Tuple, Optional, List
import terminal_colors  # Using a hypothetical package for dark mode colors

# ASCII Art Animation for encryption/decryption
ASCII_ANIMATIONS = {
    'encryption': [
        "  __  __  __  __  __  ",
        " / / / / / / / / / / ",
        "/ / / / / / / / / / /",
        "/ / / / / / / / / / /",
        "-------I-------I------"
    ],
    'decryption': [
        "  __  __  __  __  __  ",
        " / / / / / / / / / / ",
        "/ / / / / / / / / / /",
        "/ / / / / / / / / / /",
        "  -------O-----O-----"
    ]
}

def dark_mode_colors():
    """Return dark mode terminal colors for ASCII art"""
    return {
        'reset': terminal_colors.dark.RESET,
        'cyan': terminal_colors.dark.CYAN,
        'yellow': terminal_colors.dark.YELLOW,
        'green': terminal_colors.dark.GREEN,
        'blue': terminal_colors.dark.BLUE,
        'magenta': terminal_colors.dark.MAGENTA
    }

def visualize_operation(operation: str, duration: float) -> None:
    """Visualize encryption/decryption with animated ASCII art"""
    colors = dark_mode_colors()
    frames = ASCII_ANIMATIONS[operation]
    width = len(frames[0])

    for i in range(len(frames)):
        # Colorize the ASCII art
        colored_frame = (
            f"{colors['cyan']}{frames[i][:width//2]}{colors['reset']}"
            f"{colors['yellow']}{frames[i][width//2:]}{colors['reset']}"
        )
        print(f"\r{colored_frame}", end="", flush=True)
        time.sleep(duration / len(frames))

    print()  # New line after animation

def generate_key(password: str) -> str:
    """Generate a consistent encryption key from password using SHA-256"""
    return hashlib.sha256(password.encode()).hexdigest()

def xor_encrypt_decrypt(data: bytes, key: str) -> bytes:
    """XOR encryption/decryption using the key"""
    key_bytes = key.encode()
    return bytes([data[i] ^ key_bytes[i % len(key_bytes)] for i in range(len(data))])

def process_file(filepath: str, operation: str, key: str) -> Tuple[str, str]:
    """Process file for encryption or decryption"""
    start_time = time.time()

    if operation == 'encrypt':
        with open(filepath, 'rb') as f:
            data = f.read()
        encrypted = xor_encrypt_decrypt(data, key)
        encrypted_str = encrypted.hex()
        encrypted_file = filepath + '.neoncipher'
        with open(encrypted_file, 'w') as f:
            f.write(encrypted_str)
        return encrypted_file, f"Encrypted {os.path.basename(filepath)} to {encrypted_file}"
    else:
        encrypted_file = filepath
        if not encrypted_file.endswith('.neoncipher'):
            encrypted_file = filepath + '.neoncipher'
        if not os.path.exists(encrypted_file):
            raise FileNotFoundError(f"Encrypted file {encrypted_file} not found")

        with open(encrypted_file, 'r') as f:
            encrypted_str = f.read()
        encrypted = bytes.fromhex(encrypted_str)
        decrypted = xor_encrypt_decrypt(encrypted, key)
        with open(filepath, 'wb') as f:
            f.write(decrypted)
        return filepath, f"Decrypted to {os.path.basename(filepath)}"

def main():
    """Main function with argument parsing and execution"""
    parser = argparse.ArgumentParser(
        description="NeonCipher - File encryption with ASCII art visualization",
        formatter_class=argparse.ArgumentDefaultsHelpFormatter
    )
    parser.add_argument('file', help='File to encrypt or decrypt')
    parser.add_argument('--password', required=True, help='Encryption password')
    parser.add_argument('--operation', choices=['encrypt', 'decrypt'], default='encrypt',
                       help='Operation to perform')
    parser.add_argument('--dark', action='store_true', help='Enable dark mode ASCII art')
    args = parser.parse_args()

    try:
        key = generate_key(args.password)
        operation = args.operation
        print(f"Starting {operation.capitalize()}...")
        visualize_operation(operation, 2.0)
        result_file, message = process_file(args.file, operation, key)
        print(message)
        if operation == 'encrypt':
            print(f"Encryption complete. Password: '{args.password}'")
        else:
            print(f"Decryption complete. Password: '{args.password}'")

    except Exception as e:
        print(f"\nError: {str(e)}")
        sys.exit(1)

if __name__ == "__main__":
    main()