package com.basic.security.widget;

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

import com.basic.security.base.BaseApplication;
import com.basic.security.utils.BgrUtils;
import com.basic.security.utils.Constants;
import com.basic.security.utils.DetectListener;
import com.basic.security.utils.FaceId;
import com.basic.security.utils.ProcessImageAndDrawResults;
import com.basic.security.utils.RenderScriptHelper;
import com.basic.security.utils.RotateUtil;
import com.basic.security.utils.socket.RelaySocketServer;
import com.basic.security.utils.socket.outdoor.OutdoorGuestSocketServer;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.util.List;

public class Preview extends PreviewBase {
    Preview.MyThread rgbThread = new Preview.MyThread();
    Preview.MyThread grayThread = new Preview.MyThread();

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

    public void setMeasuredDimension1(int measuredWidth, int measuredHeight) {
        setMeasuredDimension(measuredWidth, measuredHeight);
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
//        ViewAttributeManager.onMeasure(this, widthMeasureSpec, heightMeasureSpec);
    }

    @Override
    protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
        super.onLayout(changed, left, top, right, bottom);
    }

    public void reset() {
        if (mCamera != null) {
            try {
                mCamera.release();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        surfaceCreated(mHolder);
        surfaceChanged(mHolder, 0, 0, 0);
    }

    public void surfaceCreated(final SurfaceHolder holder) {
//        System1.out.println("Preview.surfaceCreated rgb_gray_camera="+rgb_gray_camera);
//        if (1 == 1) {
//            return;
//        }
        mFinished = false;
        try {
            mCamera = Camera.open(rgb_gray_camera);
            Camera.Parameters parameters = mCamera.getParameters();
            parameters.setPreviewSize(640, 480);
            mCamera.setParameters(parameters);
            mCamera.setPreviewDisplay(holder);
            resetCamera = true;
            mCamera.setPreviewCallback((data, camera) -> {
                lastTimeOnPreviewFrame = System.currentTimeMillis();
                if (Constants.indoorOutdoorInOne) {
                    if (rgb_gray_camera == Constants.RGB_CAMERA) {
                        if (secondDisplayRunnable.isNotRunning()) {
                            if (data == null) {
                                return;
                            }
                            secondDisplayRunnable.isRunning = true;
                            secondDisplayRunnable.setFrame(data, mDraw);
                            BaseApplication.getApplication().executorService.execute(secondDisplayRunnable);
                        }
                    }
                }
                try {
                    if (rgb_gray_camera == Constants.RGB_CAMERA) {
                        OutdoorGuestSocketServer.setCameraData(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 {
                                            System1.out.println("Preview.surfaceCreated grayThread");
                                            grayThread.onPreviewFrame(grayBgrData, camera, Constants.GRAY_CAMERA);
                                            grayExecutorService.execute(grayThread);
                                        } catch (Exception e) {
                                            grayThread.isRunning = false;
                                            e.printStackTrace();
                                        }
                                    }
                                }
                                rgbThread.isRunning = true;
                                rgbThread.onPreviewFrame(data, camera, Constants.RGB_CAMERA);
                                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) {
                    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 {
                        Preview.rotation = (info.orientation + orientation) % 360;
                    }
                    orientation1 = orientation;
                }
            };
            if (mOrientationListener.canDetectOrientation()) {
                mOrientationListener.enable();
            } else {
                mOrientationListener.disable();
            }
        } catch (Exception exception) {
            System1.out.println("Preview.surfaceCreated " + exception.getMessage());
            if (mCamera != null) {
                mCamera.release();
                mCamera = null;
            }
            mFinished = true;
        }
    }

    public void updateGrayBgrData(byte[] data) {
//        System1.out.println("Preview.updateGrayBgrData " + data);
        grayCameraData = data;
        grayCameraDataLastTimeUpdate = System.currentTimeMillis();
    }

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

    public void surfaceDestroyed(SurfaceHolder holder) {
//        if (1 == 1) {
//            return;
//        }
        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 (mFinished) {
            return;
        }
//        if (1 == 1) {
//            return;
//        }
        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_LANDSCAPE);
            parameters.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO);
            mCamera.setParameters(parameters);
        } catch (Exception ex) {
//            System1.out.println("Preview.surfaceChanged " + ex.getMessage());
        }
        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 && Constants.indoorOutdoorInOne) {
            init1(context, rgb_gray_camera, detectListener);
            return;
        }
//        System1.out.println("Preview.init " + rgb_gray_camera);
        if (rgb_gray_camera == Constants.RGB_CAMERA) {
            Preview.rgbPreview = this;
            RelaySocketServer.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);
    }

    public void init1(Context context, int rgb_gray_camera, DetectListener detectListener) {
        if (rgb_gray_camera == Constants.RGB_CAMERA) {
            Preview.rgbPreview = this;
            RelaySocketServer.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);
    }

    public static class SecondDisplayRunnable implements Runnable {
        public boolean isRunning = false;
        public long lastRunningTime = System.currentTimeMillis();
        public byte[] data;
        public ProcessImageAndDrawResults mDraw;
        RenderScriptHelper renderScriptHelper = new RenderScriptHelper();

        public void setFrame(byte[] data, ProcessImageAndDrawResults mDraw) {
            if (this.data == null || this.data.length != data.length) {
                this.data = new byte[data.length];
            }
            System.arraycopy(data, 0, this.data, 0, data.length);
            this.mDraw = mDraw;
        }

        ///** Convert I420 (YYYYYYYY:UU:VV) to NV21 (YYYYYYYYY:VUVU) */
        @Override
        public void run() {
            secondDisplayRunnable.lastRunningTime = System.currentTimeMillis();
            if (data != null && mDraw != null) {
                try {
                    if (Constants.indoorOutdoorInOne) {
//                        RotateUtil.mirror(data, mDraw.mImageWidth, mDraw.mImageHeight);
                    }
//                    System1.out.println("SecondDisplayRunnable.run 0 ");
//                    int yuvStrides[] = {mDraw.mImageWidth, mDraw.mImageWidth/2, mDraw.mImageWidth/2};
//                    VideoRenderer.I420Frame i420Frame = new VideoRenderer.I420Frame(mDraw.mImageWidth, mDraw.mImageHeight, yuvStrides,
//                            RotateUtil.nv21ToI420(data, mDraw.mImageWidth, mDraw.mImageHeight));
//                    if ( BaseApplication.getApplication().activity.secondaryDisplay != null) {
////                        System1.out.println("SecondDisplayRunnable.run 1 " + BaseApplication.getApplication().activity.secondaryDisplay);
//                        if(BaseApplication.getApplication().activity.secondaryDisplay.yuvImageRenderer != null) {
////                            System1.out.println("SecondDisplayRunnable.run 2 " + BaseApplication.getApplication().activity.secondaryDisplay.yuvImageRenderer);
//                            BaseApplication.getApplication().activity.secondaryDisplay.yuvImageRenderer.setSize(mDraw.mImageWidth, mDraw.mImageHeight);
//                            BaseApplication.getApplication().activity.secondaryDisplay.yuvImageRenderer.renderFrame(i420Frame);
//                        }
//                    }
                    Bitmap frameBitmap = null;
                    frameBitmap = renderScriptHelper.getBitmapFromFrameData(data, mDraw.mImageWidth, mDraw.mImageHeight);
////                    Matrix mtx = new Matrix();
////                    mtx.preScale(-1.0f, 1.0f);
////                    Bitmap newImage = Bitmap.createBitmap(frameBitmap, 0, 0, frameBitmap.getWidth(), frameBitmap.getHeight(), mtx, true);
                    BaseApplication.getApplication().activity.updateCameraImagesInSecondDisplay(frameBitmap);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }

        public boolean isNotRunning() {
            if (System.currentTimeMillis() - lastRunningTime < 1000.0 / 18) {
                return false;
            }
            return System.currentTimeMillis() - lastRunningTime > 1 * 1000 || !isRunning;
        }
    }

    class MyThread implements Runnable {
        public boolean isRunning = false;
        RotateUtil rotateUtil = new RotateUtil();
        BgrUtils bgrUtils = new BgrUtils();
        ByteArrayOutputStream jpgBaos = new ByteArrayOutputStream();
        byte[] data;
        Camera camera;
        int rgb_gray_camera;
        RenderScriptHelper renderScriptHelper = new RenderScriptHelper();
        Camera.Parameters params;

        public void onPreviewFrame(byte[] data, Camera camera, int rgb_gray_camera) {
            this.rgb_gray_camera = rgb_gray_camera;
            if (this.data == null) {
                this.data = new byte[data.length];
            }
            if (BaseApplication.getApplication().activity.needCopyCameraData()) {
                System.arraycopy(data, 0, this.data, 0, data.length);
            } else {
                this.data = data;
            }
            this.data = data;
            this.camera = camera;
        }

        public void run() {
            ProcessImageAndDrawResults mDraw;
            if (rgb_gray_camera == Constants.GRAY_CAMERA) {
                mDraw = grayPreview.mDraw;
            } else {
                mDraw = rgbPreview.mDraw;
            }
            mDraw.originalCameraData = this.data;
            isRunning = true;
            mDraw.setRgb_gray_camera(rgb_gray_camera);
            if (params == null) {
                params = camera.getParameters();
            }
            int rotation = Constants.rotation;
            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();
//                byte[] dataBGR = new byte[640*480*3];
//                dataBGR = FaceId.instance.yuv420p2rgb24(data, dataBGR,480, 640);
//                System1.out.println("MyThread.run " + (System.currentTimeMillis() - begin));
//                YuvImage im = new YuvImage(data, ImageFormat.NV21, mDraw.mImageWidth,
//                        mDraw.mImageHeight, null);
//                Rect r = new Rect(0, 0, mDraw.mImageWidth, mDraw.mImageHeight);
//                jpgBaos.reset();
//                im.compressToJpeg(r, params.getJpegQuality(), jpgBaos);
                String outputFileName = "";
                Bitmap frameBitmap = renderScriptHelper.getBitmapFromFrameData(data, mDraw.mImageWidth, mDraw.mImageHeight);// Bitmap.createBitmap(640, 480, Bitmap.Config.RGB_565);
                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);
//                        jpgByteArray = jpgBaos.toByteArray();
//                        frameBitmap = BitmapFactory.decodeByteArray(jpgByteArray, 0, jpgBaos.size());
                        jpgBaos.reset();
                        frameBitmap.compress(Bitmap.CompressFormat.JPEG, 100, jpgBaos);
                        mDraw.frameJpgByteArray = jpgBaos.toByteArray();
                        jpgByteArray = mDraw.frameJpgByteArray;
                        mDraw.frameBitmap = frameBitmap;
                        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";
                        jpgBaos.reset();
                        frameBitmap.compress(Bitmap.CompressFormat.JPEG, 100, jpgBaos);
                        mDraw.frameJpgByteArray = jpgBaos.toByteArray();
                        jpgByteArray = mDraw.frameJpgByteArray;
                        mDraw.frameBitmap = frameBitmap;
                        bgrArray = bgrUtils.getPixelsBGR(frameBitmap);
//                        Bitmap bitmap = BitmapFactory.decodeByteArray(jpgBaos.toByteArray(), 0, jpgBaos.size());
//                        bitmapHolder.storeBitmap(bitmap);
//                        bitmapHolder.flipBitmapHorizontal();
//                        bitmap = bitmapHolder.getBitmapAndFree();
//                        jpgBaos.reset();
//                        if (bitmap == null) {
//                            System1.out.println("MyThread.run bitmap=" + bitmap);
//                            isRunning = false;
//                            return;
//                        }
//                        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();
                    }
                    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 (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);
            }
            isRunning = false;
        }
    }
}