// ===++===
//
//    OrtizOL
//
// ===--===
/*============================================================
//
// Clase: CodificadorBase64.cs
//
// Propósito: Demostrar las capacidadese del esquema de
// codificación Base64.
//
============================================================*/

using System;
using System.Text;

namespace Recetas.Ch02
{
    internal class CodificadorBase64
    {
        ///<summary>
        /// Punto de entrada a la aplicación
        ///</summary>
        public static void Main()
        {
            // arreglo de datos binarios
            byte[] datosBinarios = { 0x04, 0x43, 0x5F, 0xFF, 0x0, 0xF0, 0x2D, 0x62, 0x78, 
                0x22, 0x15, 0x51, 0x5A, 0xD6, 0x0C, 0x59, 0x36, 0x63, 0xBD, 0xC2, 0xD5, 
                0x0F, 0x8C, 0xF5, 0xCA, 0x0C};
            
            // Asegura la divisilidad entre 4.
            char[] datosEnBase64 = new char[(int)(Math.Ceiling((double) datosBinarios.Length / 3) * 4)];
            
            // Presenta resultados en la salida estándar
            Console.WriteLine("\nCodificación de datos binarios:");
            Convert.ToBase64CharArray(datosBinarios, 0, datosBinarios.Length, datosEnBase64, 0);
            Console.WriteLine(new String(datosEnBase64));
            Console.WriteLine("Decodificación de datos binarios:");
            Console.WriteLine(BitConverter.ToString(Convert.FromBase64CharArray(datosEnBase64, 0, datosEnBase64.Length)));
            
            // Codificación de una cadena de caracteres
            Console.WriteLine("\n\nCodificación de cadena caracteres:");
            Console.WriteLine("{0} (Cadena caracteres) -> {1} (Base64)", "\"Experiencias Construcción Software (xCSw)\"\n", CadenaCaracteresABase64("Experiencias Construcción Software (xCSw)"));
            Console.WriteLine("Decodificación de cadena caracteres:");
            Console.WriteLine("{0} (Base64) -> \"{1}\" (cadena de caracteres)", "RQB4AHAAZQByAGkAZQBuAGMAaQBhAHMAIABDAG8AbgBzAHQAcgB1AGMAYwBpAPMAbgAgAFMAbwBmAHQAdwBhAHIAZQAgACgAeABDAFMAdwApAA==", Base64ACadenaCaracteres("RQB4AHAAZQByAGkAZQBuAGMAaQBhAHMAIABDAG8AbgBzAHQAcgB1AGMAYwBpAPMAbgAgAFMAbwBmAHQAdwBhAHIAZQAgACgAeABDAFMAdwApAA=="));
            
            // Codificación de un número decimal
            Console.WriteLine("\n\nCodificación de un número decimal:");
            Console.WriteLine("{0} (decimal) -> \"{1}\" (Base64)\n", 3.14159265358979M, DecimalABase64(3.14159265358979M));
            Console.WriteLine("Decodificación de un número decimal:");
            Console.WriteLine("\"{0}\" (Base64) -> {1}\n (decimal)", "gyRq57kdAQAAAAAAAAAOAA==", Base64ADecimal("gyRq57kdAQAAAAAAAAAOAA=="));
            
            // Codificación de un número decimal
            Console.WriteLine("\nCodificación de un número entero:");
            Console.WriteLine("{0} (entero) -> \"{1}\" (Base64)\n", 1313, EnteroABase64(13213));
            Console.WriteLine("Decodificación de un número entero:");
            Console.WriteLine("\"{0}\" (Base64) -> {1} (entero)", "nTMAAA==", Base64AEntero("nTMAAA=="));
        }
        
        ///<summary>
        /// Codifica una cadena de caracteres usando Base64
        ///<summary>
        ///<param name="cadena">Cadena de caracteres a codificar</param>
        ///<returns>La cadena de caracteres codificada con Base64.<returns>
        public static string CadenaCaracteresABase64(string cadena)
        {
            // Obtención binaria de la cadena
            byte[] bytesCadena = Encoding.Unicode.GetBytes(cadena);
            
            // Codificación usando Base64
            return Convert.ToBase64String(bytesCadena);
        }
        
        ///<summary>
        /// Decodificación de una cadena de caracteres
        ///<summary>
        ///<param name="cadena">Cadena basada en Base64 a decodificar</param>
        ///<returns>Cadena de caracteres decodificada.<returns>
        public static string Base64ACadenaCaracteres(string cadena)
        {
            // Representación binaria de la cadena basada en Base64
            byte[] bytes = Convert.FromBase64String(cadena);
            
            // Decodificación
            return Encoding.Unicode.GetString(bytes);
        }
        
        ///<summary>
        /// Codificación número decimal usando Base64
        ///<summary>
        ///<param name="valor">Valor numérico punto flotante</param>
        ///<returns>Número punto flotante codificado en Base64.<returns>
        public static string DecimalABase64(decimal valor)
        {
            // Representación binaria del número decimal
            byte[] bytes = DecimalAArregloBytes(valor);
            
            // Codificación
            return Convert.ToBase64String(bytes);
        }
        
        ///<summary>
        /// Decodificación de un número decimal a Base64
        ///<summary>
        ///<param name="cadena">Cadena que representa el número decimal codificado en Base64</param>
        ///<returns>Número decimal decodificado.<returns>
        public static decimal Base64ADecimal(string cadena)
        {
            // Decodificación
            byte[] bytes = Convert.FromBase64String(cadena);
            
            // Cadena decodificada en decimal
            return ArregloBytesADecimal(bytes);
        }
        
        ///<summary>
        /// Codificación número entero usando Base64
        ///<summary>
        ///<param name="valor">Valor numérico entero.</param>
        ///<returns>Número entero codificado en Base64.<returns>
        public static string EnteroABase64(int valor)
        {
            // Representación binaria
            byte[] bytes = BitConverter.GetBytes(valor);
            
            // Codificación
            return Convert.ToBase64String(bytes);
        }
        
        ///<summary>
        /// Decodificación de un número entero a Base64
        ///<summary>
        ///<param name="cadena">Cadena que representa el número entero codificado en Base64</param>
        ///<returns>Número entero decodificado.<returns>
        public static int Base64AEntero(string cadena)
        {
            // Decodificación
            byte[] bytes = Convert.FromBase64String(cadena);
            
            // Entero
            return BitConverter.ToInt32(bytes, 0);
        }
        
        ///<summary>
        /// Crea un arreglo de bytes a partir de un valor numérico de punto flotante
        ///<summary>
        ///<param name="valor">Valor numérico punto flotante</param>
        ///<returns>Arreglo de bytes que representa el valor numérico.<returns>
        public static byte[] DecimalAArregloBytes(decimal valor)
        {
            using (System.IO.MemoryStream ms = new System.IO.MemoryStream())
            {
                using (System.IO.BinaryWriter bw = new System.IO.BinaryWriter(ms))
                {
                    // Escribe el valor punto flotante sobre el BinaryWriter
                    bw.Write(valor);
                    
                    return ms.ToArray();
                }
            }
        }
        
        ///<summary>
        /// Convierte un arreglo de bytes a un valor punto flotante
        ///<summary>
        ///<param name="bytes">Arreglo de bytes</param>
        ///<returns>Valor punto flotante.<returns>
        public static decimal ArregloBytesADecimal(byte[] bytes)
        {
            using(System.IO.MemoryStream ms = new System.IO.MemoryStream(bytes))
            {
                using(System.IO.BinaryReader br = new System.IO.BinaryReader(ms))
                {
                    return br.ReadDecimal();
                }
            }
        }
    }
}