/*
 * Copyright (C) 2011 Colin Mackie.
 * This software is distributed under the terms of the GNU General Public License.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

using System;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Security.Cryptography;
using System.Runtime.InteropServices;
using System.Text;
using System.Text.RegularExpressions;
using System.Xml;
using System.Xml.Serialization;

namespace WinAuth
{
	/// <summary>
	/// Class that implements conversion to Base32 RFC3548
	/// </summary>

	public class Base32
	{
		/// <summary>
		/// Default base32 character set as per RFC 4648/3548
		/// </summary>
		private static string DefaultAlphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";

		/// <summary>
		/// Lookup for the number of zero bits on the right (e.g. 0100 = 2)
		/// </summary>
		private static readonly int[] NumberTrailingZerosLookup =
		{
				32, 0, 1, 26, 2, 23, 27, 0, 3, 16, 24, 30, 28, 11, 0, 13, 4, 7, 17,
				0, 25, 22, 31, 15, 29, 10, 12, 6, 0, 21, 14, 9, 5, 20, 8, 19, 18
		};

		/// <summary>
		/// Singleton instance
		/// </summary>
		private static readonly Base32 _instance = new Base32(DefaultAlphabet);

		/// <summary>
		/// Get an instance of a Base32 object, either the standard singleton or for a custom alphabet
		/// </summary>
		/// <param name="alphabet"></param>
		/// <returns></returns>
		public static Base32 getInstance(string alphabet = null)
		{
			return (alphabet == null ? _instance : new Base32(alphabet));
		}

		/// <summary>
		/// array of alaphabet chars
		/// </summary>
		private char[] _digits;

		/// <summary>
		/// bit mask used
		/// </summary>
		private int _mask;

		/// <summary>
		/// shifting value
		/// </summary>
		private int _shift;

		/// <summary>
		/// map of chars to position
		/// </summary>
		private Dictionary<char, int> _map;

		/// <summary>
		/// Create a new Base32 object with a specified alphabet
		/// </summary>
		/// <param name="alphabet"></param>
		protected Base32(string alphabet)
		{
			// initialise the decoder and precalculate the char map
			_digits = alphabet.ToCharArray();
			_mask = _digits.Length - 1;
			_shift = NumberOfTrailingZeros(_digits.Length);
			_map = new Dictionary<char, int>();
			for (int i = 0; i < _digits.Length; i++)
			{
				_map.Add(_digits[i], i);
			}
		}

		/// <summary>
		/// Calculate the number of zero trailing bits on the right (e.g. 0100 = 2)
		/// http://graphics.stanford.edu/~seander/bithacks.html#ZerosOnRightModLookup
		/// </summary>
		/// <param name="i"></param>
		/// <returns></returns>
		private static int NumberOfTrailingZeros(int i)
		{
			return NumberTrailingZerosLookup[(i & -i) % 37];
		}

		public byte[] Decode(string encoded)
		{
			// remove whitespace and any separators
			encoded = Regex.Replace(encoded, @"[\s-]+", "");

			// Google implementation ignores padding
			encoded = Regex.Replace(encoded, @"[=]*$", "");

			// convert as uppercase
			encoded = encoded.ToUpper(System.Globalization.CultureInfo.InvariantCulture);

			// handle zero case
			if (encoded.Length == 0)
			{
				return new byte[0];
			}

			int encodedLength = encoded.Length;
			int outLength = encodedLength * _shift / 8;
			byte[] result = new byte[outLength];
			int buffer = 0;
			int next = 0;
			int bitsLeft = 0;
			foreach (char c in encoded.ToCharArray())
			{
				if (_map.ContainsKey(c) == false)
				{
					throw new Base32DecodingException("Illegal character: " + c);
				}
				buffer <<= _shift;
				buffer |= _map[c] & _mask;
				bitsLeft += _shift;
				if (bitsLeft >= 8)
				{
					result[next++] = (byte)(buffer >> (bitsLeft - 8));
					bitsLeft -= 8;
				}
			}
			// We'll ignore leftover bits for now.
			//
			// if (next != outLength || bitsLeft >= SHIFT) {
			//  throw new DecodingException("Bits left: " + bitsLeft);
			// }

			return result;
		}

		public string Encode(byte[] data)
		{
			if (data.Length == 0)
			{
				return string.Empty;
			}

/*
			// _shift is the number of bits per output character, so the length of the
			// output is the length of the input multiplied by 8/_shift, rounded up.
			if (data.Length >= (1 << 28))
			{
				// The computation below will fail, so don't do it.
				throw new IllegalArgumentException();
			}

			// calculate result length
			int outputLength = (data.Length * 8 + _shift - 1) / _shift;
			StringBuilder result = new StringBuilder(outputLength);
*/

			StringBuilder result = new StringBuilder();

			// encode data and map chars into result buffer
			int buffer = data[0];
			int next = 1;
			int bitsLeft = 8;
			while (bitsLeft > 0 || next < data.Length)
			{
				if (bitsLeft < _shift)
				{
					if (next < data.Length)
					{
						buffer <<= 8;
						buffer |= (data[next++] & 0xff);
						bitsLeft += 8;
					}
					else
					{
						int pad = _shift - bitsLeft;
						buffer <<= pad;
						bitsLeft += pad;
					}
				}
				int index = _mask & (buffer >> (bitsLeft - _shift));
				bitsLeft -= _shift;
				result.Append(_digits[index]);
			}

			return result.ToString();
		}
	}

	class Base32DecodingException : ApplicationException
	{
		public Base32DecodingException(string msg)
			: base(msg)
		{
		}
	}

}