package net.sumaris.core.util.crypto;
   
   /*
    * #%L
    * Duniter4j :: Core API
    * %%
    * Copyright (C) 2014 - 2015 EIS
    * %%
    * 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/gpl-3.0.html>.
   * #L%
   */
  
  
  import java.io.UnsupportedEncodingException;
  import java.security.MessageDigest;
  import java.security.NoSuchAlgorithmException;
  
  /**
   * <p>Base58 is a way to encode Bitcoin addresses as numbers and letters. Note that this is not the same base58 as used by
   * Flickr, which you may see reference to around the internet.</p>
   *
   * <p>You may instead wish to work with {@link VersionedChecksummedBytes}, which adds support for testing the prefix
   * and suffix bytes commonly found in addresses.</p>
   *
   * <p>Satoshi says: why base-58 instead of standard base-64 encoding?<p>
   *
   * <ul>
   * <li>Don't want 0OIl characters that look the same in some fonts and
   *     could be used to create visually identical looking account numbers.</li>
   * <li>A string with non-alphanumeric characters is not as easily accepted as an account number.</li>
   * <li>E-mail usually won't line-break if there's no punctuation to break at.</li>
   * <li>Doubleclicking selects the whole number as one word if it's all alphanumeric.</li>
   * </ul>
   */
  public class Base58 {
      public static final char[] ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz".toCharArray();
      private static final MessageDigest digest;
      static {
          try {
              digest = MessageDigest.getInstance("SHA-256");
          } catch (NoSuchAlgorithmException e) {
              throw new RuntimeException(e);  // Can't happen.
          }
      }
      private static final int[] INDEXES = new int[128];
      static {
          for (int i = 0; i < INDEXES.length; i++) {
              INDEXES[i] = -1;
          }
          for (int i = 0; i < ALPHABET.length; i++) {
              INDEXES[ALPHABET[i]] = i;
          }
      }
  
      /** Encodes the given bytes in base58. No checksum is appended. */
      public static String encode(byte[] input) {
          if (input.length == 0) {
              return "";
          }       
          input = copyOfRange(input, 0, input.length);
          // Count leading zeroes.
          int zeroCount = 0;
          while (zeroCount < input.length && input[zeroCount] == 0) {
              ++zeroCount;
          }
          // The actual encoding.
          byte[] temp = new byte[input.length * 2];
          int j = temp.length;
  
          int startAt = zeroCount;
          while (startAt < input.length) {
              byte mod = divmod58(input, startAt);
              if (input[startAt] == 0) {
                  ++startAt;
              }
              temp[--j] = (byte) ALPHABET[mod];
          }
  
          // Strip extra '1' if there are some after decoding.
          while (j < temp.length && temp[j] == ALPHABET[0]) {
              ++j;
          }
          // Add as many leading '1' as there were leading zeros.
          while (--zeroCount >= 0) {
              temp[--j] = (byte) ALPHABET[0];
          }
  
         byte[] output = copyOfRange(temp, j, temp.length);
         try {
             return new String(output, "US-ASCII");
         } catch (UnsupportedEncodingException e) {
             throw new RuntimeException(e);  // Cannot happen.
         }
     }
 
     public static byte[] decode(String input) throws AddressFormatException {
         if (input.length() == 0) {
             return new byte[0];
         }
         byte[] input58 = new byte[input.length()];
         // Transform the String to a base58 byte sequence
         for (int i = 0; i < input.length(); ++i) {
             char c = input.charAt(i);
 
             int digit58 = -1;
             if (c >= 0 && c < 128) {
                 digit58 = INDEXES[c];
             }
             if (digit58 < 0) {
                 throw new AddressFormatException("Illegal character " + c + " at " + i);
             }
 
             input58[i] = (byte) digit58;
         }
         // Count leading zeroes
         int zeroCount = 0;
         while (zeroCount < input58.length && input58[zeroCount] == 0) {
             ++zeroCount;
         }
         // The encoding
         byte[] temp = new byte[input.length()];
         int j = temp.length;
 
         int startAt = zeroCount;
         while (startAt < input58.length) {
             byte mod = divmod256(input58, startAt);
             if (input58[startAt] == 0) {
                 ++startAt;
             }
 
             temp[--j] = mod;
         }
         // Do no add extra leading zeroes, move j to first non null byte.
         while (j < temp.length && temp[j] == 0) {
             ++j;
         }
 
         return copyOfRange(temp, j - zeroCount, temp.length);
     }
     
     //
     // number -> number / 58, returns number % 58
     //
     private static byte divmod58(byte[] number, int startAt) {
         int remainder = 0;
         for (int i = startAt; i < number.length; i++) {
             int digit256 = (int) number[i] & 0xFF;
             int temp = remainder * 256 + digit256;
 
             number[i] = (byte) (temp / 58);
 
             remainder = temp % 58;
         }
 
         return (byte) remainder;
     }
 
     //
     // number -> number / 256, returns number % 256
     //
     private static byte divmod256(byte[] number58, int startAt) {
         int remainder = 0;
         for (int i = startAt; i < number58.length; i++) {
             int digit58 = (int) number58[i] & 0xFF;
             int temp = remainder * 58 + digit58;
 
             number58[i] = (byte) (temp / 256);
 
             remainder = temp % 256;
         }
 
         return (byte) remainder;
     }
 
     private static byte[] copyOfRange(byte[] source, int from, int to) {
         byte[] range = new byte[to - from];
         System.arraycopy(source, from, range, 0, range.length);
 
         return range;
     }
 }