package com.basic.security.utils;

import android.app.AlertDialog;
import android.content.Context;
import android.content.ContextWrapper;
import android.content.DialogInterface;
import android.content.res.Configuration;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.hardware.Camera;
import android.hardware.SensorManager;
import android.util.AttributeSet;
import android.view.OrientationEventListener;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.ViewGroup;

import com.basic.security.base.BaseApplication;
import com.basic.security.utils.socket.CameraYuvSocketServer;
import com.basic.security.utils.socket.OfficeSocketServer;
import com.basic.security.utils.socket.RelaySocketServer;
import com.basic.security.utils.socket.SnapshotYuvSocketServer;
import com.basic.security.utils.socket.YuvSocketServer;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.nio.ByteBuffer;
import java.util.List;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Preview extends SurfaceView implements SurfaceHolder.Callback {
    public static int rotation = 0;
    public static Preview rgbPreview, grayPreview;
    public static int orientation1 = 0;
    public static ArrayBlockingQueue<byte[]> YUVQueue = new ArrayBlockingQueue<byte[]>(10);
    public static long lastTimeOnPreviewFrame = System.currentTimeMillis();
    static ExecutorService rgbExecutorService = Executors.newSingleThreadExecutor();
    static ExecutorService grayExecutorService = Executors.newSingleThreadExecutor();
    static long grayCameraDataLastTimeUpdate = 0;
    static byte[] grayCameraData;
    private static AvcEncoder avcCodec = new AvcEncoder();
    public int rotationToSend;
    Context mContext;
    SurfaceHolder mHolder;
    Camera mCamera;
    ProcessImageAndDrawResults mDraw;
    boolean mFinished;
    BitmapHolder bitmapHolder = new BitmapHolder();
    MyThread rgbThread = new MyThread(); // java.lang.IllegalThreadStateException 异常解决方法:将Thread方法改为Runnable实现
    MyThread grayThread = new MyThread();
    DetectListener detectListener;
    ByteBuffer buf1;
    private int rgb_gray_camera;

    public Preview(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    public Preview(Context context, ProcessImageAndDrawResults draw) {
        super(context);
        mContext = context;
        mDraw = draw;
        mHolder = getHolder();
        mHolder.addCallback(this);
        mHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
    }

    /**
     * Converts YUV420 NV21 to RGB8888
     *
     * @param data   byte array on YUV420 NV21 format.
     * @param width  pixels width
     * @param height pixels height
     * @return a RGB8888 pixels int array. Where each int is a pixels ARGB.
     */
    public static int[] convertYUV420_NV21toRGB8888(byte[] data, int width, int height) {
        int size = width * height;
        int offset = size;
        int[] pixels = new int[size];
        int u, v, y1, y2, y3, y4;

        // i percorre os Y and the final pixels
        // k percorre os pixles U e V
        for (int i = 0, k = 0; i < size; i += 2, k += 2) {
            y1 = data[i] & 0xff;
            y2 = data[i + 1] & 0xff;
            y3 = data[width + i] & 0xff;
            y4 = data[width + i + 1] & 0xff;

            u = data[offset + k] & 0xff;
            v = data[offset + k + 1] & 0xff;
            u = u - 128;
            v = v - 128;

            pixels[i] = convertYUVtoRGB(y1, u, v);
            pixels[i + 1] = convertYUVtoRGB(y2, u, v);
            pixels[width + i] = convertYUVtoRGB(y3, u, v);
            pixels[width + i + 1] = convertYUVtoRGB(y4, u, v);

            if (i != 0 && (i + 2) % width == 0)
                i += width;
        }

        return pixels;
    }

    private static int convertYUVtoRGB(int y, int u, int v) {
        int r, g, b;

        r = y + (int) (1.402f * v);
        g = y - (int) (0.344f * u + 0.714f * v);
        b = y + (int) (1.772f * u);
        r = r > 255 ? 255 : r < 0 ? 0 : r;
        g = g > 255 ? 255 : g < 0 ? 0 : g;
        b = b > 255 ? 255 : b < 0 ? 0 : b;
        return 0xff000000 | (b << 16) | (g << 8) | r;
    }

    public void reset() {
        surfaceCreated(mHolder);
        surfaceChanged(mHolder, 0, 0, 0);
    }

    public void putYUVData(byte[] buffer, int length) {
        if (YUVQueue.size() >= 10) {
            YUVQueue.poll();
        }
        YUVQueue.add(buffer);
    }

    @Override
    public void surfaceCreated(final SurfaceHolder holder) {
        mFinished = false;
        try {
            mCamera = Camera.open(rgb_gray_camera);
            Camera.Parameters parameters = mCamera.getParameters();
            parameters.setPreviewSize(640, 480);
            mCamera.setParameters(parameters);
            mCamera.setPreviewDisplay(holder);
            mCamera.setPreviewCallback(new Camera.PreviewCallback() {
                public void onPreviewFrame(byte[] data, Camera camera) {
                    try {
                        lastTimeOnPreviewFrame = System.currentTimeMillis();
                        if (rgb_gray_camera == Constants.RGB_CAMERA) {
                            YuvSocketServer.AcceptedClient.addCameraData(data);
                            CameraYuvSocketServer.setCameraData(data);
                            SnapshotYuvSocketServer.SnapshotYuvAcceptedClient.addCameraData(data);
                            if (BaseApplication.getApplication().activity != null
                                    && BaseApplication.getApplication().activity.shouldDetectFace()) {
                                if (!rgbThread.isRunning) {
                                    if (Constants.USE_GRAY_CAMERA) {
                                        byte[] grayBgrData = getMostMatchGrayBgrData();
                                        if (grayBgrData != null) {
                                            try {
                                                if (Constants.isHuaWeiPad) {
                                                    grayThread.onPreviewFrame(grayBgrData, camera, Constants.GRAY_CAMERA);
                                                    grayExecutorService.execute(grayThread); // 华为平板
                                                } else {
                                                    grayThread.start();
                                                }
                                            } catch (Exception e) {
                                                grayThread.isRunning = false;
                                                e.printStackTrace();
                                            }
                                        }
                                    }
                                    rgbThread.isRunning = true;
                                    rgbThread.onPreviewFrame(data, camera, Constants.RGB_CAMERA);
                                    if (Constants.isHuaWeiPad) {
                                        rgbExecutorService.execute(rgbThread); // 华为平板
                                    } else {
                                        rgbExecutorService.execute(rgbThread);
                                    }
                                }
                            }
                        } else {
                            updateGrayBgrData(data);
                        }
                    } catch (Exception e) {
                        rgbThread.isRunning = false;
                        e.printStackTrace();
                    }
                }
            });
            mCamera.startPreview();
            OrientationEventListener mOrientationListener = new OrientationEventListener(FaceId.activity,
                    SensorManager.SENSOR_DELAY_NORMAL) {
                public void onOrientationChanged(int orientation) {
//                    Log.d("OrientationDetector","当前的传感器方向为"+orientation);
                    if (orientation == ORIENTATION_UNKNOWN) return;
                    Camera.CameraInfo info =
                            new Camera.CameraInfo();
                    Camera.getCameraInfo(0, info);
                    orientation = (orientation + 45) / 90 * 90;
                    if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
                        Preview.rotation = (info.orientation - orientation + 360) % 360;
                    } else {  // back-facing camera
                        Preview.rotation = (info.orientation + orientation) % 360;
                    }
                    orientation1 = orientation;
                }
            };
            if (mOrientationListener.canDetectOrientation()) {
                mOrientationListener.enable();
            } else {
                mOrientationListener.disable();
            }
        } catch (Exception exception) {
            AlertDialog.Builder builder = new AlertDialog.Builder(mContext);
            builder.setMessage("Cannot open camera")
                    .setPositiveButton("Ok", new DialogInterface.OnClickListener() {
                        @Override
                        public void onClick(DialogInterface dialogInterface, int i) {
                            android.os.Process.killProcess(android.os.Process.myPid());
                        }
                    })
                    .show();
            if (mCamera != null) {
                mCamera.release();
                mCamera = null;
            }
        }
    }

    public void updateGrayBgrData(byte[] data) {
        grayCameraData = data;
        grayCameraDataLastTimeUpdate = System.currentTimeMillis();
    }

    public byte[] getMostMatchGrayBgrData() {
        long internal = (System.currentTimeMillis() - grayCameraDataLastTimeUpdate);
//        System.out.println("internal="+internal);
        if (internal < 1000 && grayCameraData != null) {
            return grayCameraData;
        }
        return null;
    }

    public void surfaceDestroyed(SurfaceHolder holder) {
        mFinished = true;
        if (mCamera != null) {
            mCamera.setPreviewCallback(null);
            mCamera.stopPreview();
            mCamera.release();
            mCamera = null;
        }
    }

    public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {

        if (mCamera == null) return;
        Camera.Parameters parameters = mCamera.getParameters();
        if (this.getResources().getConfiguration().orientation != Configuration.ORIENTATION_LANDSCAPE) {
            parameters.set("orientation", "portrait");
            mCamera.setDisplayOrientation(90);
            mDraw.rotated = true;
        } else {
            parameters.set("orientation", "landscape");
            mCamera.setDisplayOrientation(0);
        }
        List<Camera.Size> supportedSizes = parameters.getSupportedPreviewSizes();
        int width = 0;
        int height = 0;
        for (Camera.Size s : supportedSizes) {
            if ((width - 640) * (width - 640) + (height - 480) * (height - 480) >
                    (s.width - 640) * (s.width - 640) + (s.height - 480) * (s.height - 480)) {
                width = s.width;
                height = s.height;
            }
        }
        try {
            if (width * height > 0) {
                parameters.setPreviewSize(width, height);
            }
            parameters.setSceneMode(Camera.Parameters.SCENE_MODE_PORTRAIT);
            parameters.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO);
            mCamera.setParameters(parameters);
        } catch (Exception ex) {
//            ex.printStackTrace();
        }
        parameters = mCamera.getParameters();
        Camera.Size previewSize = parameters.getPreviewSize();
        makeResizeForCameraAspect(1.0f / ((1.0f * previewSize.width) / previewSize.height));
    }

    private void makeResizeForCameraAspect(float cameraAspectRatio) {
        ViewGroup.LayoutParams layoutParams = this.getLayoutParams();
        int matchParentWidth = this.getWidth();
        int newHeight = (int) (matchParentWidth / cameraAspectRatio);
        if (newHeight != layoutParams.height) {
            layoutParams.height = newHeight;
            layoutParams.width = matchParentWidth;
            this.setLayoutParams(layoutParams);
            this.invalidate();
        }
    }

    public void init(Context context, int rgb_gray_camera, DetectListener detectListener) {
        if (rgb_gray_camera == Constants.RGB_CAMERA) {
            Preview.rgbPreview = this;
//            YuvSocketServer.startYuvSocketServer();
            CameraYuvSocketServer.startServer();
            SnapshotYuvSocketServer.startYuvSocketServer();
            RelaySocketServer.startSocketServer();
            OfficeSocketServer.startSocketServer();
        }
        if (rgb_gray_camera == Constants.GRAY_CAMERA) {
            Preview.grayPreview = this;
        }
        this.detectListener = detectListener;
        mContext = context;
        mDraw = new ProcessImageAndDrawResults(rgb_gray_camera);
        this.rgb_gray_camera = rgb_gray_camera;
        mHolder = getHolder();
        mHolder.addCallback(this);
        mHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
    }

    class MyThread extends Thread {
        public boolean isRunning = false;
        RotateUtil rotateUtil = new RotateUtil();
        BgrUtils bgrUtils = new BgrUtils();
        ByteArrayOutputStream jpgBaos = new ByteArrayOutputStream();

        byte[] data;
        byte[] originalCameraData;
        Camera camera;
        int rgb_gray_camera;
        RenderScriptHelper renderScriptHelper = new RenderScriptHelper();
        Camera.Parameters params;
        private byte[] mTempI420 = null;
        private byte[] mTempNv21 = null;
        private byte[] mMaxJpeg = null;

        public void onPreviewFrame(byte[] data, Camera camera, int rgb_gray_camera) {
            originalCameraData = data;
            this.rgb_gray_camera = rgb_gray_camera;
            if (this.data == null || this.data.length != data.length) {
                this.data = new byte[data.length];
            }
//            this.data = data;
            long begin = System.currentTimeMillis();
            if (BaseApplication.getApplication().activity.needCopyCameraData()) {
                System.arraycopy(data, 0, this.data, 0, data.length);
            } else {
                this.data = data;
            }
//            System.out.println("onPreviewFrame = "+(System.currentTimeMillis() - begin));
            this.camera = camera;
        }

        @Override
        public void run() {
            try {
                isRunning = true;
                ProcessImageAndDrawResults mDraw;
                if (rgb_gray_camera == Constants.GRAY_CAMERA) {
                    ThreadUtil.printThreadInfo("GRAY_CAMERA");
                    mDraw = grayPreview.mDraw;
                } else {
                    ThreadUtil.printThreadInfo("RGB_CAMERA");
                    mDraw = rgbPreview.mDraw;
                }
                mDraw.originalCameraData = originalCameraData;
                mDraw.setRgb_gray_camera(rgb_gray_camera);
                if (params == null) {
                    params = camera.getParameters();
                }
                int orientation = orientation1;
                int rotation = Preview.rotation;
                rotation = 360 - rotation;
                if (Constants.isHuaWeiPad) {
                    rotation = 270;// 华为平板270
                } else {
                    rotation = 90;
                }
                rotation = Constants.rotation;
                if (Constants.simulate_camera) {
                    rotation = 0;
                }
                if (rotation == 360 || rotation == 0) {
                    mDraw.mImageWidth = params.getPreviewSize().width;
                    mDraw.mImageHeight = params.getPreviewSize().height;
                }
                if (rotation == 270) {
                    data = rotateUtil.rotateYUV420Degree270(data, params.getPreviewSize().width, params.getPreviewSize().height);
                    mDraw.mImageWidth = params.getPreviewSize().height;
                    mDraw.mImageHeight = params.getPreviewSize().width;
                }
                if (rotation == 180) {
                    data = rotateUtil.rotateYUV420Degree180(data, params.getPreviewSize().width, params.getPreviewSize().height);
                    mDraw.mImageWidth = params.getPreviewSize().width;
                    mDraw.mImageHeight = params.getPreviewSize().height;
                }
                if (rotation == 90) {
                    data = rotateUtil.rotateYUV420Degree90(data, params.getPreviewSize().width, params.getPreviewSize().height);
                    mDraw.mImageWidth = params.getPreviewSize().height;
                    mDraw.mImageHeight = params.getPreviewSize().width;
                }
                Preview.this.rotationToSend = rotation;
                if (!Constants.useNv21ToBgr) {
                    long begin = System.currentTimeMillis();
                    Bitmap frameBitmap = renderScriptHelper.getBitmapFromFrameData(data, mDraw.mImageWidth, mDraw.mImageHeight);
                    String outputFileName = "";
                    byte[] bgrArray = null;

                    try {
                        String name = "";
                        String filesPath = new ContextWrapper(FaceId.activity).getFilesDir().getAbsolutePath();
                        byte[] jpgByteArray = null;
                        if (rgb_gray_camera == Constants.RGB_CAMERA) {
                            name = "image_rgb.jpg";
                            outputFileName = "rgb.jpg";
                            File targetFile = new File(filesPath, outputFileName);
                            if (Constants.showCapturedImages) {
                                jpgBaos.reset();
                                frameBitmap.compress(Bitmap.CompressFormat.JPEG, 100, jpgBaos);
                                jpgByteArray = jpgBaos.toByteArray();
                            }
                            bgrArray = bgrUtils.getPixelsBGR(frameBitmap);
                            if (!Constants.useBgrArray) {
                                FileOutputStream outputStream = new FileOutputStream(targetFile);
                                outputStream.write(bgrArray);
                                outputStream.close();
                            }
                        } else {
                            outputFileName = "gray.jpg";
                            name = "image_gray.jpg";
                            Bitmap bitmap = BitmapFactory.decodeByteArray(jpgBaos.toByteArray(), 0, jpgBaos.size());
                            bitmapHolder.storeBitmap(bitmap);
                            bitmapHolder.flipBitmapHorizontal();
                            bitmap = bitmapHolder.getBitmapAndFree();
                            jpgBaos.reset();
                            bitmap.compress(Bitmap.CompressFormat.JPEG, 100, jpgBaos);


                            jpgByteArray = jpgBaos.toByteArray();
                            File targetFile = new File(filesPath, outputFileName);
                            FileOutputStream outputStream = new FileOutputStream(targetFile);
                            bgrArray = bgrUtils.getPixelsBGR(BitmapFactory.decodeByteArray(jpgByteArray, 0, jpgBaos.size()));
                            outputStream.write(bgrArray);
                            outputStream.close();
                        }
                        if (Constants.showCapturedImages) {
                            if (jpgByteArray != null) {
                                FileOutputStream output = new FileOutputStream(new File(new ContextWrapper(getContext()).getFilesDir().getAbsolutePath(), name));
                                output.write(jpgByteArray);
                                output.flush();
                                output.close();
                            }
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    if ((mDraw == null) || mFinished)
                        return;
                    if (mDraw.mYUVData == null) {
                        mDraw.mRGBData = new byte[3 * mDraw.mImageWidth * mDraw.mImageHeight];
                        mDraw.mYUVData = new byte[data.length];
                    }
                    mDraw.start(frameBitmap, bgrArray, data);
                } else {
                    mDraw.start1(data);
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                isRunning = false;
            }
        }
    }

}