package com.basic.security.widget;

import android.content.Context;
import android.content.res.Configuration;
import android.graphics.Matrix;
import android.graphics.SurfaceTexture;
import android.hardware.Camera;
import android.util.AttributeSet;
import android.util.Log;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.TextureView;

import com.basic.security.base.BaseApplication;
import com.basic.security.utils.BitmapHolder;
import com.basic.security.utils.Constants;
import com.basic.security.utils.DetectListener;
import com.basic.security.utils.ProcessImageAndDrawResults;
import com.basic.security.utils.socket.outdoor.OutdoorGuestSocketServer;

import java.io.IOException;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public abstract class PreviewBase extends SurfaceView implements SurfaceHolder.Callback, TextureView.SurfaceTextureListener {
    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();
    public static Preview.SecondDisplayRunnable secondDisplayRunnable = new Preview.SecondDisplayRunnable();
    static ExecutorService rgbExecutorService = Executors.newSingleThreadExecutor();
    static ExecutorService grayExecutorService = Executors.newSingleThreadExecutor();
    static long grayCameraDataLastTimeUpdate = 0;
    static byte[] grayCameraData;
    public int rotationToSend;
    public Camera mCamera;
    public boolean resetCamera = false;
    public int rgb_gray_camera;
    Context mContext;
    SurfaceHolder mHolder;
    ProcessImageAndDrawResults mDraw;
    boolean mFinished;
    BitmapHolder bitmapHolder = new BitmapHolder();
    DetectListener detectListener;

    public PreviewBase(Context context) {
        super(context);
    }

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

    public PreviewBase(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
    }

    public PreviewBase(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
        super(context, attrs, defStyleAttr, defStyleRes);
    }

    @Override
    public void onSurfaceTextureAvailable(SurfaceTexture surfaceTexture, int width, int height) {
//        System1.out.println("PreviewBase.onSurfaceTextureAvailable");
        mFinished = false;
        try {
            mCamera = Camera.open(rgb_gray_camera);
            Camera.Parameters parameters = mCamera.getParameters();
            parameters.setPreviewSize(640, 480);
            if (null == mCamera) {
                System1.out.println("Preview.onSurfaceTextureAvailable no front facing camera ");
            }
        /*
           This doesn't work
           setCameraDisplayOrientation(info, mCamera);
         */
            //make portrait
            if (this.getResources().getConfiguration().orientation != Configuration.ORIENTATION_LANDSCAPE) {
                mCamera.setDisplayOrientation(90);
            } else {
                mCamera.setDisplayOrientation(0);
            }
            //mCamera.setDisplayOrientation(0);
            //create a matrix to invert the x-plane
            if (Constants.indoorOutdoorInOne) {
                Matrix matrix = new Matrix();
                matrix.setScale(-1, 1);
                //move it back to in view otherwise it'll be off to the left.
                matrix.postTranslate(width, 0);
                BaseApplication.getApplication().activity.fragment_camera.textureView.setTransform(matrix);
            }
            /* Tell the camera to write onto our textureView mTextureView */
            mCamera.setPreviewTexture(surfaceTexture);
            mCamera.setPreviewCallback((data, camera) -> {
//                System1.out.println("PreviewBase.onSurfaceTextureAvailable setPreviewCallback");
                lastTimeOnPreviewFrame = System.currentTimeMillis();
                if (Constants.indoorOutdoorInOne) {
                    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);
//                        System1.out.println("PreviewBase.onSurfaceTextureAvailable 0");
                        if (BaseApplication.getApplication().activity != null
                                && BaseApplication.getApplication().activity.shouldDetectFace()) {
//                            System1.out.println("PreviewBase.onSurfaceTextureAvailable 1");
                            if (!((Preview) PreviewBase.this).rgbThread.isRunning) {
                                if (Constants.USE_GRAY_CAMERA) {
                                    byte[] grayBgrData = ((Preview) PreviewBase.this).getMostMatchGrayBgrData();
//                                    System1.out.println("PreviewBase.onSurfaceTextureAvailable 2 grayBgrData="+grayBgrData);
                                    if (grayBgrData != null) {
                                        try {
                                            ((Preview) PreviewBase.this).grayThread.onPreviewFrame(grayBgrData, camera, Constants.GRAY_CAMERA);
                                            grayExecutorService.execute(((Preview) PreviewBase.this).grayThread);
                                        } catch (Exception e) {
                                            ((Preview) PreviewBase.this).grayThread.isRunning = false;
                                            e.printStackTrace();
                                        }
                                    }
                                }
                                ((Preview) PreviewBase.this).rgbThread.isRunning = true;
                                ((Preview) PreviewBase.this).rgbThread.onPreviewFrame(data, camera, Constants.RGB_CAMERA);
//                                System1.out.println("PreviewBase.onSurfaceTextureAvailable rgbExecutorService.execute(((Preview) PreviewBase.this).rgbThread)");
                                rgbExecutorService.execute(((Preview) PreviewBase.this).rgbThread);
                            }
                        }
                    } else {
                        ((Preview) PreviewBase.this).updateGrayBgrData(data);
                    }
                } catch (Exception e) {
                    ((Preview) PreviewBase.this).rgbThread.isRunning = false;
                    e.printStackTrace();
                }
            });
            mCamera.startPreview();
        } catch (IOException ioe) {
            Log.e("camera-reverse", ioe.getMessage());
            mCamera = null;
            mFinished = true;
        }
    }

    @Override
    public void onSurfaceTextureSizeChanged(SurfaceTexture surfaceTexture, int width, int height) {
//        System1.out.println("PreviewBase.onSurfaceTextureSizeChanged");
        Matrix matrix = new Matrix();
        matrix.setScale(-1, 1);
        //move it back to in view otherwise it'll be off to the left.
        matrix.postTranslate(width, 0);
        BaseApplication.getApplication().activity.fragment_camera.textureView.setTransform(matrix);
        /* Tell the camera to write onto our textureView mTextureView */
        try {
            mCamera.setPreviewTexture(surfaceTexture);
        } catch (IOException e) {
            e.printStackTrace();
            mCamera = null;
            mFinished = true;

        }
    }

    @Override
    public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
//        System1.out.println("PreviewBase.onSurfaceTextureDestroyed");
        mFinished = true;
        if (null != mCamera) {
            mCamera.stopPreview();
            mCamera.release();
            mCamera = null;
        }
        return true;
    }

    @Override
    public void onSurfaceTextureUpdated(SurfaceTexture surface) {
//        System1.out.println("PreviewBase.onSurfaceTextureUpdated");
    }
}