package main;

import java.util.HashMap;
import java.util.Map;
import java.util.Random;

/**
 * 處理進位制的工具類
 **/
public class RadixUtil {

    private final static String NAME = RadixUtil.class.getName();

    /**
     * 產生進位制的數字
     **/
    public final static char[] DIGIT = {//
            'A', 'B', 'C', 'D'
 
, 'E', 'F', 'G', 'H', 'I', 'J', //
            'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', //
            'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', //
            'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', //
            'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', //
            'y'
 
, 'z', '0', '1', '2', '3', '4', '5', '6', '7', //
            '8', '9' //
    };

    public final static Map<Character, Integer> digitMap = new HashMap<Character, Integer>();

    static {
        for (int i = 0; i < DIGIT.length; i++) {
            digitMap.put(Character.valueOf(DIGIT[i]), Integer.valueOf(i));
        }
    }

    /**
     * 支援的最大進位制數
     */
 

    public static final int MAX_RADIX = DIGIT.length;

    /**
     * 支援的最小進位制數
     */
    public static final int MIN_RADIX = 2;

    /**
     * 最多一次返回32個字元
     **/
    public static final int SIZE = 32;

    public static final long MAX_4_LETTER = letterToLong("ZZZZ");

    public static final long MAX_3_LETTER = letterToLong("ZZZ");

    /**
     * 獲得0的個數
     **/
    public static String obtainZero(int num) {
        return obtainChar(num, DIGIT[0]);
    }

    /**
     * 獲得0的個數
     **/
    public static String obtainZero0(int num) {
        return obtainChar(num, '0');
    }

    /**
     * 獲得特殊字元的個數
     **/
    public static String obtainChar(int num, char c) {
        if (num < 0) {
            return "";
        }
        StringBuilder sb = new StringBuilder();
        while (num-- > 0) {
            sb.append(c);
        }
        return sb.toString();
    }

    /**
     * 獲得long型資料的最大長度
     **/
    public static int obtainMaxLengOfLong() {
        return longToString(Long.MAX_VALUE).length();
    }

    /**
     * 只用26個大寫字母
     **/
    public static String longToLetter(long i) {
        return longToLetter(i, 0);
    }

    public static String longToLetter(long i, int length) {
        return longToString(i, 26, length);
    }

    /**
     * 用系統提供的欄位長度
     **/
    public static String longToString(long i) {
        return longToString(i, 0);
    }

    public static String longToString(long i, int length) {
        return longToString(i, MAX_RADIX, length);
    }

    /**
     * 將長整型數值轉換為指定的進位制數（最大支援62進位制）
     */
    public static String longToString(long i, int radix, int length) {
        if (radix < MIN_RADIX || radix > MAX_RADIX) {
            radix = 10;
        }
        if (radix == 10) {
            return Long.toString(i);
        }

        StringBuilder sb = new StringBuilder(SIZE);
        boolean negative = (i < 0);
        if (negative) {
            i = -i;
        }

        while (i >= radix) {
            sb.append(DIGIT[(int) (i % radix)]);
            i = i / radix;
        }
        sb.append(DIGIT[(int) (i)]);
        if (negative) {
            sb.append("-");
        }
        if (length <= 0 || sb.length() >= length) {
            return sb.reverse().toString();
        } else {
            return obtainZero(length - sb.length()) + sb.reverse().toString();
        }
    }

    /**
     * 將字串轉換為長整型數字
     */
    public static long stringToLong(String s) {
        return stringToLong(s, MAX_RADIX);
    }

    public static long letterToLong(String s) {
        return stringToLong(s, 26);
    }

    /**
     * 將字串轉換為長整型數字
     */
    public static long stringToLong(String s, int radix) {
        if (s == null) {
            throw new NumberFormatException("null");
        }
        if (radix < MIN_RADIX) {
            throw new NumberFormatException("radix " + radix + " less than " + NAME + ".MIN_RADIX");
        }
        if (radix > MAX_RADIX) {
            throw new NumberFormatException("radix " + radix + " greater than " + NAME + ".MAX_RADIX");
        }
        // 返回結果
        long result = 0;
        char[] ss = s.toCharArray();
        // 計算階乘
        long factorial = 1;
        for (int i = (ss.length - 1); i >= 0; i--) {
            char c = ss[i];
            Integer v = digitMap.get(Character.valueOf(c));
            if (v != null) {
                result += v.intValue() * factorial;
                factorial *= radix;
            } else if (c == '-') {
                result = -result;
            } else {
                throw new NumberFormatException("char " + c + " not in " + NAME + ".DIGIT");
            }
        }
        return result;
    }

    public static byte[] stringToBytes(String s) {
        return stringToBytes(s, MAX_RADIX);
    }

    /**
     * 將string轉換成byte陣列
     */
    public static byte[] stringToBytes(String s, int radix) {
        if (s == null) {
            throw new NullPointerException(NAME + "parameter s is null");
        }
        // 二進位制的陣列
        StringBuilder binary = new StringBuilder(s.getBytes().length * 8);
        long t;
        String te = null;
        // 定長,照著這個長度切割
        int llength = obtainMaxLengOfLong();
        // 長度
        // 最後一位是標記，最後一段的長度的
        int length = s.length() - 1;
        // 最後一段的長度
        int lastLength = (int) stringToLong(s.substring(length, s.length()), radix);
        // 下標
        int start = 0;
        int end = llength;
        while (end < length) {
            // 轉換成long
            t = stringToLong(s.substring(start, end), radix);
            // 轉換成二進位制string
            te = Long.toBinaryString(t);
            // 補齊0
            te = obtainZero0(radix - te.length()) + te;
            binary.append(te);
            start = end;
            end = start + llength;
        }
        // 最後一段
        if (start < length) {
            t = stringToLong(s.substring(start, length), radix);
            te = Long.toBinaryString(t);
            te = obtainZero0(lastLength - te.length()) + te;
            binary.append(te);
        }
        // 將二進位制轉換成byte資料
        // 返回的結果
        length = binary.length();
        byte[] result = new byte[length / Byte.SIZE];
        int i = 0;
        start = 0;
        end = Byte.SIZE;
        while (end < length) {
            result[i++] = parseByte(binary.substring(start, end), 2);
            start = end;
            end = start + Byte.SIZE;
        }
        // 最後一段
        if (start < length) {
            result[i++] = parseByte(binary.substring(start, length), 2);
        }
        return result;
    }

    public static String bytesToString(byte[] bs) {
        return bytesToString(bs, MAX_RADIX);
    }

    /**
     * 將byte陣列轉換成string
     */
    public static String bytesToString(byte[] bs, int radix) {
        // 最終的結果
        StringBuilder result = new StringBuilder(bs.length);
        // 二進位制的陣列
        StringBuilder binary = new StringBuilder(bs.length * 8);
        // 臨時儲存
        String t = null;
        for (int n = 0; n < bs.length; n++) {
            byte b = bs[n];
            // 將byte轉化成 二進位制的string
            t = Integer.toBinaryString(Byte.toUnsignedInt(b));
            // 獲得完成8位的二進位制的string
            binary.append(obtainZero0(Byte.SIZE - t.length()) + t);
        }
        // 長度
        int length = binary.length();
        // 下標
        int start = 0;
        int end = radix;
        while (end < length) {
            t = longToString(Long.valueOf(binary.substring(start, end), 2), radix);
            result.append(obtainZero(obtainMaxLengOfLong() - t.length()) + t);
            start = end;
            end = start + radix;
        }
        // 最後不必設定成定長
        if (start < length) {
            t = longToString(Long.valueOf(binary.substring(start, length), 2), radix);
            result.append(t);
            result.append(longToString(length - start, radix));
        } else {
            result.append(longToString(0, radix));
        }
        return result.toString();
    }

    public static byte parseByte(String s, int radix) throws NumberFormatException {
        if (s == null) {
            throw new NumberFormatException("s is null");
        }
        if (s.length() < 8) {
            return Byte.parseByte(s, radix);
        }
        boolean nagetive = false;
        if (s.charAt(0) == '1') {
            s = '0' + s.substring(1, s.length());
            nagetive = true;
        }
        int i = Integer.parseInt(s, radix);
        if (nagetive) {
            i = -i;
        }
        if (i < Byte.MIN_VALUE || i > Byte.MAX_VALUE)
            throw new NumberFormatException("Value out of range. Value:\"" + s + "\" Radix:" + radix);
        return (byte) i;
    }

    public static void main(String[] args) {
        System.out.println(MAX_3_LETTER);
        System.out.println(MAX_4_LETTER);
        System.out.println(letterToLong("ZZZZZ"));
        System.out.println(letterToLong("ZZZZZZ"));
        System.out.println(letterToLong("ZZZZZZZ"));
        System.out.println(letterToLong("ZZZZZZZZ"));
        System.out.println(letterToLong("ZZZZZZZZZ"));
        for (long j = 0L; j < 1000L; j++) {
            String r = longToLetter(new Random().nextInt((int) MAX_4_LETTER), 4);
            String s = r + longToLetter(j);
            long b = letterToLong(s.substring(4, s.length()));
            System.out.println(j + "    " + r + "    " + s + "    " + b);
        }
    }

}