package com.example.datalibrary.gatecamera;

import android.graphics.SurfaceTexture;
import android.hardware.Camera;
import android.util.Log;
import android.util.SparseIntArray;
import android.view.Surface;
import android.view.SurfaceHolder;
import android.view.TextureView;
import android.view.ViewGroup;
import android.view.ViewParent;

import com.example.datalibrary.callback.CameraDataCallback;
import com.example.datalibrary.gl.view.GLFaceSurfaceView;
import com.example.datalibrary.gl.view.GlMantleSurfacView;

import java.io.IOException;
import java.util.List;

/**
 * Time: 2019/1/24
 * Author: v_chaixiaogang
 * Description:
 */
public class CameraPreviewManager implements SurfaceHolder.Callback , TextureView.SurfaceTextureListener {

    private static final String TAG = "camera_preview";


    GLFaceSurfaceView surfaceView;
    boolean mPreviewed = false;

    public static final int CAMERA_FACING_BACK = 0;

    public static final int CAMERA_FACING_FRONT = 1;

    public static final int CAMERA_USB = 2;

    /**
     * 当前相机的ID。
     */
    private int cameraFacing = CAMERA_FACING_BACK;

    private int previewWidth;
    private int previewHeight;

    private int videoWidth;
    private int videoHeight;

    private int surfaceWidth;
    private int surfaceHeight;

    private Camera mCamera;

    private int displayOrientation = 0;

    private int videoDirection;

    private GlMantleSurfacView mTextureView;
    private SurfaceTexture mSurfaceTexture;
    private int mirrorVideoRGB;
    public void setmCameraDataCallback(CameraDataCallback mCameraDataCallback) {
        this.mCameraDataCallback = mCameraDataCallback;
    }

    public void destroy() {

    }

    private CameraDataCallback mCameraDataCallback;
    private static volatile CameraPreviewManager instance = null;

    private static final SparseIntArray ORIENTATIONS = new SparseIntArray();

    static {

        ORIENTATIONS.append(Surface.ROTATION_0, 0);
        ORIENTATIONS.append(Surface.ROTATION_90, 90);
        ORIENTATIONS.append(Surface.ROTATION_180, 180);
        ORIENTATIONS.append(Surface.ROTATION_270, 270);
    }

    public static CameraPreviewManager getInstance() {
        synchronized (CameraPreviewManager.class) {
            if (instance == null) {
                instance = new CameraPreviewManager();
            }
        }
        return instance;
    }

    public int getCameraFacing() {
        return cameraFacing;
    }

    public void setCameraFacing(int cameraFacing) {
        this.cameraFacing = cameraFacing;
    }

    public int getDisplayOrientation() {
        return displayOrientation;
    }

    public void setDisplayOrientation(int displayOrientation) {
        this.displayOrientation = displayOrientation;
    }

    @Override
    public void surfaceCreated(SurfaceHolder surfaceHolder) {

    }

    @Override
    public void surfaceChanged(SurfaceHolder surfaceHolder, int i, final int width, final int height) {
        if (surfaceView != null){
            surfaceWidth = width;
            surfaceHeight = height;
            surfaceView.surfaceChanged(surfaceHolder);

            openCamera();
        }
    }
    /**
     * 开启预览
     * @param textureView
     */
    public void startPreview(GlMantleSurfacView textureView, int videoDirection ,
                             int width, int height) {
        Log.e(TAG, "开启预览模式");
        mTextureView = textureView;
        if (textureView.getGlFaceSurfaceView() != null){
            surfaceView = textureView.getGlFaceSurfaceView();
            this.previewWidth = width;
            this.previewHeight = height;
            this.videoDirection = videoDirection;
        }else {
            this.previewWidth = width;
            this.previewHeight = height;
            this.videoDirection = videoDirection;
            this.mirrorVideoRGB = textureView.getMirrorRGB();
            mSurfaceTexture = mTextureView.getTextureView().getSurfaceTexture();
            mTextureView.getTextureView().setSurfaceTextureListener(this);
        }
    }
    @Override
    public void surfaceDestroyed(SurfaceHolder surfaceHolder) {
        if (surfaceView != null){
            //System.out.println("==内存==>surfaceDestroyed");
            surfaceView.surfaceDestroyed();
        }
    }

    /**
     * 关闭预览
     */
    public void stopPreview() {
        if (mCamera != null) {
            try {
                mCamera.setPreviewCallback(null);
                mCamera.stopPreview();
                mPreviewed = false;
                mCamera.release();
                mCamera = null;
            } catch (Exception e) {
                Log.e("qing", "camera destory error");
                e.printStackTrace();

            }
        }
    }
    public static interface ErrInfoCallBack{
        void err(String errInfo);
    }

    public int[] initCamera(ErrInfoCallBack callBack){
        try {
            if (mCamera == null) {
                mCamera = Camera.open(cameraFacing);
                Log.e(TAG, "initCamera---open camera");
            }
            // 摄像头图像预览角度
            int cameraRotation = videoDirection;
            mCamera.setDisplayOrientation(cameraRotation);
            if (mTextureView != null){
                if (cameraRotation == 90 || cameraRotation == 270) {
                    if (mirrorVideoRGB == 1) {
                        mTextureView.setRotationY(180);
                    } else {
                        mTextureView.setRotationY(0);
                    }
                    // 旋转90度或者270，需要调整宽高
                    mTextureView.setPreviewSize(previewHeight, previewWidth);
                } else {
                    if (mirrorVideoRGB == 1) {
                        mTextureView.setRotationY(180);
                    } else {
                        mTextureView.setRotationY(0);
                    }
                    mTextureView.setPreviewSize(previewWidth, previewHeight);
                }
            }
            Camera.Parameters params = mCamera.getParameters();
            List<Camera.Size> sizeList = params.getSupportedPreviewSizes(); // 获取所有支持的camera尺寸
            final Camera.Size optionSize = getOptimalPreviewSize(sizeList, previewWidth,
                    previewHeight); // 获取一个最为适配的camera.size
            if (optionSize.width == previewWidth && optionSize.height == previewHeight) {
                videoWidth = previewWidth;
                videoHeight = previewHeight;
            } else {
                videoWidth = optionSize.width;
                videoHeight = optionSize.height;
            }
            params.setPreviewSize(videoWidth, videoHeight);

            mCamera.setParameters(params);
            if (mTextureView != null){
                try {
                    mCamera.setPreviewCallback(new Camera.PreviewCallback() {
                        @Override
                        public void onPreviewFrame(byte[] bytes, Camera camera) {
                            if (mCameraDataCallback != null) {
                                mCameraDataCallback.onGetCameraData(bytes, camera,
                                        videoWidth, videoHeight);
                            }
                        }
                    });
                    mCamera.setPreviewTexture(mSurfaceTexture);

                    mCamera.startPreview();

                } catch (Exception e) {
                    e.printStackTrace();
                    if(callBack!=null){
                        callBack.err("开启相机报错 (2)==>"+e.getMessage());
                    }
                    Log.e(TAG, e.getMessage());
                }
            }
            if (surfaceView != null){
                surfaceView.getHolder().addCallback(this);
                surfaceView.setWillNotDraw(false);
            }

        }catch (Exception e){
            e.printStackTrace();
            if(callBack!=null){
                callBack.err("开启相机报错 (1)==>"+e.getMessage());
            }
        }
        return new int[]{videoWidth , videoHeight};
    }
    /**
     * 开启摄像头
     */
    public void openCamera() {

        try {
            try {
                mCamera.setPreviewTexture(surfaceView.getFramebuffer());
                mCamera.setPreviewCallback(new Camera.PreviewCallback() {
                    @Override
                    public void onPreviewFrame(byte[] bytes, Camera camera) {
                        if (mCameraDataCallback != null) {
                            mCameraDataCallback.onGetCameraData(bytes, camera,
                                    videoWidth, videoHeight);
                        }
                    }
                });
                mCamera.startPreview();

                surfaceView.initFrame(surfaceWidth , surfaceHeight);
                if (videoDirection == 90 || videoDirection == 270){
                    surfaceView.setSize(videoHeight , videoWidth);
                }else {
                    surfaceView.setSize(videoWidth , videoHeight);

                }
            } catch (Exception e) {
                e.printStackTrace();
                Log.e(TAG, e.getMessage());
            }
        } catch (RuntimeException e) {
            Log.e(TAG, e.getMessage());
        }
    }


    private int getCameraDisplayOrientation(int degrees, int cameraId) {
        Camera.CameraInfo info = new Camera.CameraInfo();
        Camera.getCameraInfo(cameraId, info);
        int rotation = 0;
        if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
            rotation = (info.orientation + degrees) % 360;
            rotation = (360 - rotation) % 360;
        } else { // back-facing
            rotation = (info.orientation - degrees + 360) % 360;
        }
        return rotation;
    }


    /**
     * 解决预览变形问题
     *
     * @param sizes
     * @param w
     * @param h
     * @return
     */
    private Camera.Size getOptimalPreviewSize(List<Camera.Size> sizes, int w, int h) {
        final double aspectTolerance = 0.1;
        double targetRatio = (double) w / h;
        if (sizes == null) {
            return null;
        }
        Camera.Size optimalSize = null;
        double minDiff = Double.MAX_VALUE;

        int targetHeight = h;

        // Try to find an size match aspect ratio and size
        for (Camera.Size size : sizes) {

            double ratio = (double) size.width / size.height;
            if (Math.abs(ratio - targetRatio) > aspectTolerance) {
                continue;
            }
            if (Math.abs(size.height - targetHeight) < minDiff) {
                optimalSize = size;
                minDiff = Math.abs(size.height - targetHeight);
            }
        }

        // Cannot find the one match the aspect ratio, ignore the requirement
        if (optimalSize == null) {
            minDiff = Double.MAX_VALUE;
            for (Camera.Size size : sizes) {
                if (Math.abs(size.height - targetHeight) < minDiff) {
                    optimalSize = size;
                    minDiff = Math.abs(size.height - targetHeight);
                }
            }
        }
        return optimalSize;
    }

    @Override
    public void onSurfaceTextureAvailable(SurfaceTexture texture, int i, int i1) {
        try {
            if (mCamera != null && !mPreviewed) {
                mSurfaceTexture = texture;
                mCamera.setPreviewTexture(mSurfaceTexture);
                mCamera.startPreview();
                mPreviewed = true;
            }
        } catch (Exception exception) {
            Log.e("chaixiaogang", "IOException caused by setPreviewDisplay()", exception);
        }
    }

    @Override
    public void onSurfaceTextureSizeChanged(SurfaceTexture surfaceTexture, int i, int i1) {
        Log.e(TAG, "--surfaceTexture--TextureSizeChanged");
    }

    @Override
    public boolean onSurfaceTextureDestroyed(SurfaceTexture surfaceTexture) {
        if (mCamera != null) {
            mCamera.stopPreview();
            mPreviewed = false;
            mCamera.setPreviewCallback(null);
            mCamera.stopPreview();
            mCamera.release();
            mCamera = null;
        }
        mCameraDataCallback = null;
        //System.out.println("==内存==>onSurfaceTextureDestroyed");
        if(mSurfaceTexture!=null) {
            mSurfaceTexture.release();
            mSurfaceTexture = null;
        }
        if (surfaceView != null){
            surfaceView.surfaceDestroyed();
            surfaceView = null;
        }
        if(mTextureView!=null) {
            //System.out.println("==内存==>mTextureView");
            mTextureView.getTextureView().setSurfaceTextureListener(null);
            mTextureView.destroy();
            mTextureView = null;
        }
        return true;
    }

    @Override
    public void onSurfaceTextureUpdated(SurfaceTexture surfaceTexture) {
        Log.e(TAG, "--surfaceTexture--Updated");
    }
}