package com.alfeye.a1camera;

import android.graphics.Point;
import android.graphics.Rect;
import android.hardware.Camera;

import java.util.ArrayList;
import java.util.List;

/**
 * Camera1 人脸补光
 * <p>
 * Created by DELL on 2019/4/9.
 */

public class FaceBrightnessAdjustUtil {
    //默认 补光阈值
    private int threshold = 100;
    private Rect mRect;
    private boolean enabled = true;

    public FaceBrightnessAdjustUtil() {
    }


    /**
     * 设置 人脸补光 位移阈值
     *
     * @param threshold 补光区域位移 阈值。大于此阈值才进行补光
     */
    public void setFaceBrightnessAdjustThreshold(int threshold) {
        this.threshold = threshold;
    }

    /**
     * 使能 人脸补光
     *
     * @param enabled
     */
    public void setEnFaceBrightnessAdjust(boolean enabled) {
        this.enabled = enabled;
    }

    /**
     * 执行 自动补光
     *
     * @param camera        Camera1摄像头
     * @param previewWidth  预览宽度
     * @param previewHeight 预览高度
     * @param rect          补光区域
     * @param rotate270     旋转补光区域  （旋转为竖屏坐标）
     */
    public void runAutoFaceBrightnessAdjust(Camera camera, int previewWidth, int previewHeight, Rect rect, boolean rotate270) {
        if (camera != null && enabled) {
            try {
                Camera.Parameters parameters = camera.getParameters();
                List<Camera.Area> meteringAreas = new ArrayList<>();
                if (rect != null) {
                    if (rotate270) {
                        rect = rotateDeg270(rect, previewWidth, previewHeight);
                    }
                    Point pointLeftTop = rotateDeg90(previewWidth, previewHeight, rect.left, rect.top);
                    Point pointRightBottom = rotateDeg90(previewWidth, previewHeight, rect.right, rect.bottom);

                    int left = Math.min(pointRightBottom.x, pointLeftTop.x);
                    int top = Math.min(pointLeftTop.y, pointRightBottom.y);
                    int right = Math.max(pointRightBottom.x, pointLeftTop.x);
                    int bottom = Math.max(pointLeftTop.y, pointRightBottom.y);

                    Rect aRect = new Rect(left, top, right, bottom);
                    meteringAreas.add(new Camera.Area(aRect, 800));

                    if (mRect != null) {
                        if (Math.abs(mRect.left - aRect.left) > threshold ||
                                Math.abs(mRect.top - aRect.top) > threshold ||
                                Math.abs(mRect.right - aRect.right) > threshold ||
                                Math.abs(mRect.bottom - aRect.bottom) > threshold) {
                            parameters.setMeteringAreas(meteringAreas);
                            parameters.setFocusAreas(meteringAreas);
                            camera.setParameters(parameters);
                            mRect = aRect;
                        }
                    } else {
                        parameters.setMeteringAreas(meteringAreas);
                        parameters.setFocusAreas(meteringAreas);
                        camera.setParameters(parameters);
                        mRect = aRect;
                    }
                } else {
                    Rect aRect = new Rect(0, 0, 1, 1);
                    meteringAreas.add(new Camera.Area(aRect, 800));
                    parameters.setMeteringAreas(meteringAreas);
                    parameters.setFocusAreas(meteringAreas);
                    camera.setParameters(parameters);
                    mRect = null;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    private Point rotateDeg90(int previewWidth, int previewHeight, int x, int y) {
        Point point = new Point();
        int height = Math.max(previewWidth, previewHeight);
        int width = Math.min(previewWidth, previewHeight);

        point.x = (int) (1920 * (1 - (float) y / height));
        point.y = (int) (1080 * (1 - (float) x / width));

        if (point.x < 0) {
            point.x = 0;
        }
        if (point.y < 0) {
            point.y = 0;
        }
        return point;
    }

    /**
     * 矩形框的坐标旋转270度<br>
     * rotate the coordinate of rectangle with 270 degree
     *
     * @param rect   需要旋转的原始矩形框<br>
     *               the origin rectangle which need to rotate
     * @param width  图片的宽度<br>
     *               width of image
     * @param height 图片的高度<br>
     *               height of image
     * @return 旋转之后的矩形框<br>
     * rotated rectangle
     */
    private Rect rotateDeg270(Rect rect, int width, int height) {
        Rect newRect = new Rect();
        int left = rect.left;
        newRect.left = rect.top;
        newRect.top = width - rect.right;
        newRect.right = rect.bottom;
        newRect.bottom = width - left;
        return newRect;
    }

}