package com.boonya.protocol.codec.self;
import java.nio.charset.CharacterCodingException;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import org.apache.mina.core.buffer.IoBuffer;
import org.apache.mina.core.session.IoSession;
import org.apache.mina.filter.codec.ProtocolDecoder;
import org.apache.mina.filter.codec.ProtocolDecoderOutput;
 
public class MyTextLineCodecDecoder implements ProtocolDecoder {

    private Charset charset; // 編碼格式
 
    private String delimiter; // 文字分隔符

    private IoBuffer delimBuf; // 文字分割符匹配的變數
 

    // 定義常量值，作為每個IoSession中儲存解碼任務的key值
    private static String CONTEXT = MyTextLineCodecDecoder.class.getName()+ ".context";

 
    // 建構函式，必須指定Charset和文字分隔符
    public MyTextLineCodecDecoder(Charset charset, String delimiter) {

        this.charset = charset;

        this.delimiter = delimiter;

    }


    public void decode(IoSession session, IoBuffer in, ProtocolDecoderOutput out)

            throws Exception {

        Context ctx = getContext(session);

        if (delimiter == null || "".equals(delimiter)) { // 如果文字換行符未指定，使用預設值

            delimiter = "\r\n";

        }

        if (charset == null) {

            charset = Charset.forName("utf-8");

        }

        decodeNormal(ctx, in, out);

    }

 

    // 從IoSession中獲取Context物件
    private Context getContext(IoSession session) {

        Context ctx;

        ctx = (Context) session.getAttribute(CONTEXT);

        if (ctx == null) {

            ctx = new Context();

            session.setAttribute(CONTEXT, ctx);

        }

        return ctx;

    }

 

    // 解碼
    private void decodeNormal(Context ctx, IoBuffer in,

            ProtocolDecoderOutput out) throws CharacterCodingException {

        // 取出未完成任務中已經匹配的文字換行符的個數

        int matchCount = ctx.getMatchCount();

 

        // 設定匹配文字換行符的IoBuffer變數

        if (delimBuf == null) {

            IoBuffer tmp = IoBuffer.allocate(2).setAutoExpand(true);

            tmp.putString(delimiter, charset.newEncoder());

            tmp.flip();

            delimBuf = tmp;

        }

        int oldPos = in.position(); // 解碼的IoBuffer中資料的原始資訊

        int oldLimit = in.limit();

        while (in.hasRemaining()) { // 變數解碼的IoBuffer

            byte b = in.get();

            if (delimBuf.get(matchCount) == b) { // 匹配第matchCount位換行符成功

                matchCount++;

                if (matchCount == delimBuf.limit()) { // 當前匹配到位元組個數與文字換行符位元組個數相同，匹配結束

                    int pos = in.position(); // 獲得當前匹配到的position（position前所有資料有效）
                    in.limit(pos);
                    in.position(oldPos); // position回到原始位置
 

                    ctx.append(in); // 追加到Context物件未完成資料後面

                    in.limit(oldLimit); // in中匹配結束後剩餘資料
                    in.position(pos);

 

                    IoBuffer buf = ctx.getBuf();
                    buf.flip();
                    buf.limit(buf.limit() - matchCount);// 去掉匹配資料中的文字換行符
                    try {
                        out.write(buf.getString(ctx.getDecoder())); // 輸出解碼內容
                    } finally {
                        buf.clear(); // 釋放快取空間

                    }

                    oldPos = pos;

                    matchCount = 0;

                }

            } else {

                // 如果matchCount==0，則繼續匹配

                // 如果matchCount>0，說明沒有匹配到文字換行符的中的前一個匹配成功位元組的下一個位元組，

                // 跳轉到匹配失敗字元處，並置matchCount=0，繼續匹配

                in.position(in.position() - matchCount);

                matchCount = 0; // 匹配成功後，matchCount置空

            }

        }
 
        // 把in中未解碼內容放回buf中
        in.position(oldPos);

        ctx.append(in);

        ctx.setMatchCount(matchCount);

    }

    public void dispose(IoSession session) throws Exception {


    }

    public void finishDecode(IoSession session, ProtocolDecoderOutput out)

            throws Exception {

    }


    // 內部類，儲存IoSession解碼時未完成的任務
    private class Context {

        private CharsetDecoder decoder;

        private IoBuffer buf; // 儲存真實解碼內容

        private int matchCount = 0; // 匹配到的文字換行符個數

 

        private Context() {

            decoder = charset.newDecoder();

            buf = IoBuffer.allocate(80).setAutoExpand(true);

        }

 

        // 重置
        @SuppressWarnings("unused")

        public void reset() {

            matchCount = 0;

            decoder.reset();

        }

 

        // 追加資料
        public void append(IoBuffer in) {

            getBuf().put(in);

        }

 
        // ======get/set方法=====================
        public CharsetDecoder getDecoder() {

            return decoder;

        }

 
        public IoBuffer getBuf() {

            return buf;

        }

 

        public int getMatchCount() {

            return matchCount;

        }

 

        public void setMatchCount(int matchCount) {

            this.matchCount = matchCount;

        }

    } // end class Context;

}