package com.basic.security.utils.yuv.pull.client;

import android.graphics.Bitmap;

import com.basic.security.utils.RenderScriptHelper;
import com.basic.security.utils.RotateUtil;

import java.io.ByteArrayOutputStream;
import java.util.LinkedList;

public class BufferManager extends Thread {
    private static final int MAX_BUFFER_COUNT = 4;
    private final int mFrameLength;
    ByteArrayOutputStream jpgBaos = new ByteArrayOutputStream();
    RotateUtil rotateUtil = new RotateUtil();
    byte[] jpgByteArray;
    RenderScriptHelper renderScriptHelper = new RenderScriptHelper();
    private ImageBuffer[] mBufferQueue;
    private int mFillCount = 0;
    private int mRemained = 0;
    private int mWidth, mHeight;
    private LinkedList<byte[]> mYUVQueue = new LinkedList<byte[]>();
    private DataListener mListener;

    public BufferManager(int frameLength, int width, int height) {
        mWidth = width;
        mHeight = height;
        mFrameLength = frameLength;
        mBufferQueue = new ImageBuffer[MAX_BUFFER_COUNT];
        for (int i = 0; i < MAX_BUFFER_COUNT; ++i) {
            mBufferQueue[i] = new ImageBuffer(mFrameLength, width, height);
        }
    }

    public void fillBuffer(byte[] data, int len) {
        mFillCount = mFillCount % MAX_BUFFER_COUNT;
        if (mRemained != 0) {
            if (mRemained < len) {
                mBufferQueue[mFillCount].fillBuffer(data, 0, mRemained, mYUVQueue);
                ++mFillCount;
                if (mFillCount == MAX_BUFFER_COUNT)
                    mFillCount = 0;
                mBufferQueue[mFillCount].fillBuffer(data, mRemained, len - mRemained, mYUVQueue);
                mRemained = mFrameLength - len + mRemained;
            } else if (mRemained == len) {
                mBufferQueue[mFillCount].fillBuffer(data, 0, mRemained, mYUVQueue);
                mRemained = 0;
                ++mFillCount;
                if (mFillCount == MAX_BUFFER_COUNT)
                    mFillCount = 0;
            } else {
                mBufferQueue[mFillCount].fillBuffer(data, 0, len, mYUVQueue);
                mRemained = mRemained - len;
            }
        } else {
            mBufferQueue[mFillCount].fillBuffer(data, 0, len, mYUVQueue);

            if (len < mFrameLength) {
                mRemained = mFrameLength - len;
            } else {
                ++mFillCount;
                if (mFillCount == MAX_BUFFER_COUNT)
                    mFillCount = 0;
            }
        }
    }

    public void setOnDataListener(DataListener listener) {
        mListener = listener;
        start();
    }

    public void close() {
        interrupt();
        try {
            join();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        super.run();
        long lastTimeShowImage = System.currentTimeMillis();
        while (!Thread.currentThread().isInterrupted()) {
            byte[] data = null;
            synchronized (mYUVQueue) {
                data = mYUVQueue.poll();

                if (data != null) {
                    data = rotateUtil.rotateYUV420Degree90(data, mWidth, mHeight);
                    int mWidth1 = mHeight;
                    int mHeight1 = mWidth;


                    long begin = System.currentTimeMillis();
                    Bitmap bufferedImage = renderScriptHelper.getBitmapFromFrameData(data, mWidth1, mHeight1);

//                    YuvImage im = new YuvImage(data, ImageFormat.NV21, mWidth1,
//                            mHeight1, null);
//                    Rect r = new Rect(0,0,mWidth1,mHeight1);
//                    jpgBaos.reset();
//                    im.compressToJpeg(r, 100, jpgBaos);
//                    jpgByteArray = jpgBaos.toByteArray();
//
//    				long t = System.currentTimeMillis();
//    				Bitmap bufferedImage = null;
//					bufferedImage = BitmapFactory.decodeByteArray(jpgByteArray, 0, jpgByteArray.length);

//                    System.out.println("taken="+(System.currentTimeMillis() - begin));
                    mListener.onDirty(bufferedImage);
                    System.out.println("上次显示图片的时间间隔:" + (System.currentTimeMillis() - lastTimeShowImage));
                    lastTimeShowImage = System.currentTimeMillis();
                }

            }
        }
    }
}