// Rev.1 2000,09,24
import java.io.*;
import java.util.*;

/**
 * テキストファイルを読んで、JIS＆MIMEエンコードしてファイルに書き出す。
 * @author Hiroyuki Murata
 */
class MimeEnc {

    static final String base64 =
     "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    static final String mimehead = "=?ISO-2022-JP?B?";
    static final byte[] SI  = {0x1b, (byte)'$', (byte)'B'};
    static final byte[] SO  = {0x1b, (byte)'(', (byte)'B'};
    static final byte[] SO2 = {0x1b, (byte)'('};

    /**
     * コンストラクタ（ファイル読み書き）
     */
    MimeEnc(String infile, String outfile) {
        try {
            BufferedReader br = new BufferedReader(new FileReader(infile));
            BufferedWriter bw = new BufferedWriter(new FileWriter(outfile));

            String line;
            while ((line = br.readLine()) != null) {
                bw.write(mimeenc(line));
                bw.newLine();
            }

            bw.close();
            br.close();

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * JISバイト配列（ASCII含む）をMIMEエンコード
     */
    String mimeenc(String line) { // MIMEエンコード
        StringBuffer sbuf = new StringBuffer(100);
        byte[] jis = null;
        try {
            jis = line.getBytes("JIS");
        } catch (UnsupportedEncodingException e) {
        }

        // バグよけ(１)。 末尾のSOが欠落したら補う。
        if (lastIndexOf(jis,SI) > lastIndexOf(jis,SO2)) {
            //debug("append SO");
            byte[] jis2 = new byte[jis.length + 3];
            int i = 0;
            for (; i<jis.length; i++)
                jis2[i] = jis[i];
            for (int j=0; j<SO.length; j++)
                jis2[i++] = SO[j];
            jis = jis2;
        }

        // バグよけ(２)。 末尾のSOが過剰だったら削除。
        if (
            jis.length >= 6 &&
            lastIndexOf(jis, SO2) == jis.length-3 &&
            matchBytes(jis, jis.length-6, SO2) == SO2.length
        ) {
            //debug("delete SO");
            byte[] jis2 = new byte[jis.length - 3];
            for (int i=0; i<jis2.length; i++)
                jis2[i] = jis[i];
            jis = jis2;
        }

        int start; // ASCII部分はstart,stopの役割が逆転
        int stop  = 0;
        for (;;) {
            boolean last = (start = indexOf(jis, stop, SI)) < 0;
            appendSpc(sbuf, jis, stop);
            append(sbuf, jis, stop, last ? jis.length : start);
            if (last)
                break;
            stop = indexOf(jis, start+3, SO2);
            if (stop < 0) {
                stop = jis.length + 3;
            } else {
                stop += 3;
            }
            String out64 = encode64(jis, start, stop);
            appendSpc(sbuf, jis, start);
            sbuf.append(checkLength("=?ISO-2022-JP?B?" + out64 + "?="));
            //sbuf.append("=?ISO-2022-JP?B?");
            //sbuf.append(out64);
            //sbuf.append("?=");
        }
        //return checkLength(sbuf.toString());
        return sbuf.toString();
    }

    /** 長すぎるencoded-wordを分割（再帰呼び出しあり） */
    String checkLength(String mimei) {
        if (mimei.length() > 75) {
            String mime1 = mimei.substring(0, 68) + "GyhC?= ";
            String mime2 = "=?ISO-2022-JP?B?GyRC" + mimei.substring(68);
            return mime1 + checkLength(mime2);
        } else {
            return mimei;
        }
    }

    /**
     * JISバイト配列（ASCII含まない）をbase64エンコード
     */
    String encode64(byte[] jis, int start, int stop) {
        int ilen = stop - start;
        int[] cs = new int[(ilen + 2) / 3 * 3]; // 個数を３の倍数に切り上げ
        int j = start;
        for (int i=0; i<ilen; i++) {
            try {
                cs[i] = jis[j++] & 0xff;
            } catch (IndexOutOfBoundsException e) { // SOがない場合
                cs[i] = SO[j - jis.length - 1];
            }
        }

        char[] c4 = new char[4];
        StringBuffer sbuf = new StringBuffer(100);

        for (int i=0; i<ilen; i+=3) {
            c4[0] = base64.charAt(                 cs[i  ]>>2         );
            c4[1] = base64.charAt(((cs[i  ]<<4) | (cs[i+1]>>4)) & 0x3f);
            c4[2] = base64.charAt(((cs[i+1]<<2) | (cs[i+2]>>6)) & 0x3f);
            c4[3] = base64.charAt(  cs[i+2]                     & 0x3f);
            if (ilen <= (i+2)) {
                if (ilen < (i+2))
                    c4[2] = '=';
                c4[3] = '=';
            }
            sbuf.append(c4);
        }
        return sbuf.toString();
    }

    /**
     * バイト配列を検索
     * <p>
     * @param src   検索されるバイト配列
     * @param start 検索開始箇所
     * @param match 検索パターンのバイト配列
     * @return 検出した位置。見つからない場合は -1。
     */
    int indexOf(byte[] src, int start, byte[] match) {
        int imax = src.length - match.length;
        for (int i=start; i<=imax; i++) {
            if (matchBytes(src, i, match) == match.length)
                return i;
        }
        return -1;
    }

    /**
     * バイト配列を末尾から検索
     * <p>
     * @param src   検索されるバイト配列
     * @param match 検索パターンのバイト配列
     * @return 検出した位置。見つからない場合は -1。
     */
    int lastIndexOf(byte[] src, byte[] match) {
        int imax = src.length - match.length;
        for (int i=imax; i>=0; i--) {
            if (matchBytes(src, i, match) == match.length)
                return i;
        }
        return -1;
    }

    /**
     * バイト配列の指定箇所から何バイト一致するか
     * <p>
     * @param src   照合されるバイト配列
     * @param start 照合開始箇所
     * @param match 照合パターンのバイト配列
     * @return 一致したバイト数
     */
    int matchBytes(byte[] src, int start, byte[] match) {
        int i = 0;
        int j = start;
        try {
            for (; i<match.length; i++) {
                if (src[j++] != match[i])
                    break;
            }
            return i;
        } catch (IndexOutOfBoundsException e) {
            return i - 1;
        }
    }

    /** StringBufferにバイト配列の部分を追加 */
    void append(StringBuffer sb, byte[] bs, int start, int stop) {
        for (int i=start; i<stop; i++)
            sb.append((char)(bs[i] & 0xff));
    }

    /** 空白文字がなければStringBufferにスペース追加 */
    void appendSpc(StringBuffer sbuf, byte[] jis, int start) {
        try {
            int c1 = (int)jis[start-1] & 0xff;
            int c2 = (int)jis[start  ] & 0xff;
            if (c1 > 0x20 && (c2 > 0x20 || c2 == 0x1b)) {
                sbuf.append(" ");
            }
        } catch (IndexOutOfBoundsException e) {
        }
    }

    //------------------------------------------------------
    /** デバッグ用文字列表示 */
    static void debug(String str) {
        System.out.println(str);
    }
    /** デバッグ用バイト配列表示 */
    static void debug(byte[] word) {
        for (int i=0; i<word.length; i++) {
            int ci = (int)word[i] & 0xff | 0x100;
            System.out.print(" " + Integer.toString(ci,16).substring(1));
        }
        System.out.println("");
    }

    //------------------------------------------------------
    /**
     * 起動
     */
    public static void main(String[] args) {
        if (args.length != 2) {
            System.out.println("Usage: java MimeEnc inputfile outputfile");
        } else {
            new MimeEnc(args[0], args[1]);
        }
    }
}