package com.basic.security.fragment;

import android.content.pm.PackageManager;
import android.graphics.Outline;
import android.os.Bundle;
import android.os.SystemClock;
import android.support.annotation.NonNull;
import android.support.v4.content.ContextCompat;
import android.view.LayoutInflater;
import android.view.TextureView;
import android.view.View;
import android.view.ViewGroup;
import android.view.ViewOutlineProvider;
import android.widget.ImageView;
import android.widget.RelativeLayout;

import com.basic.security.base.BaseApplication;
import com.basic.security.base.BaseFragment;
import com.basic.security.manager.DetectResultManager;
import com.basic.security.manager.FacePositionManager;
import com.basic.security.manager.GuestManager;
import com.basic.security.manager.RecognizeManager;
import com.basic.security.manager.SystemInitManager;
import com.basic.security.utils.Constants;
import com.basic.security.utils.DetectedResult;
import com.basic.security.utils.FaceId;
import com.basic.security.utils.FacePosition;
import com.basic.security.utils.LayoutUtil;
import com.basic.security.utils.ResolutionAdaptation;
import com.basic.security.utils.StyleBuilder;
import com.basic.security.utils.socket.outdoor.OutdoorGuestSocketServer;
import com.basic.security.widget.H264Player;
import com.basic.security.widget.Preview;
import com.basic.security.widget.RecognizeFaceInfoView;

import org.androidannotations.annotations.AfterViews;
import org.androidannotations.annotations.Click;
import org.androidannotations.annotations.EFragment;
import org.androidannotations.annotations.UiThread;
import org.androidannotations.annotations.ViewById;

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

@EFragment
public class CameraFragment extends BaseFragment {
    public static final int CAMERA_OK = 1024;
    public static DetectedResult lastDetectedResult = null;
    public static boolean drawFaceRectFinished = true;
    static CfCompareFeatureThread CfCompareFeatureThread = new CfCompareFeatureThread();
    static DetectedResult detectedResult = null;
    public final LinkedList<DetectedResult> detectedResultQueue = new LinkedList();
    @ViewById
    public View overlay;
    @ViewById
    public View nic_back_person_manager;
    @ViewById
    public View topBackground2_guest_mode, topBlurView2_guest_mode;
    @ViewById
    public TextureView textureView;
    @ViewById
    public H264Player h264Player;
    @ViewById
    public ImageView camera2;
    @ViewById
    public View camera2_separator, textureViewParent;
    @ViewById
    public Preview rgb_camera, gray_camera;
    @ViewById
    public RelativeLayout faceOuterBorderViewParent;
    public List<RecognizeFaceInfoView> recognizeFaceInfoViewList = new ArrayList<>();
    public long lastTimeDetectedFaceInCamera;
    long prevDrawTime = System.currentTimeMillis();
    private boolean initCamera = false;


    public void clearAllFaceRectWhenTimeout() {
        BaseApplication.getApplication().executorService.execute(() -> {
            while (true) {
                if (com.basic.security.utils.Constants.showLog) {
                    try {
                        SystemClock.sleep(400);
                        if (System.currentTimeMillis() - lastTimeDetectedFaceInCamera > (Constants.USE_GRAY_CAMERA ? 500 : 400)) {
                            hideAllFaceRects();
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        });
    }

    @UiThread
    public void hideAllFaceRects() {
        try {
            for (RecognizeFaceInfoView recognizeFaceInfoView : recognizeFaceInfoViewList) {
                recognizeFaceInfoView.setVisibility(View.INVISIBLE);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        if (Constants.indoorOutdoorInOne) {
            if (mainActivity().secondaryDisplay != null) {
                mainActivity().secondaryDisplay.hideAllFaceRects();
            }
        }
    }

    @UiThread
    public void drawFaceRect(DetectedResult detectedResult) {
        try {
            lastDetectedResult = detectedResult;
            drawFaceRectFinished = false;
            prevDrawTime = System.currentTimeMillis();
            if (faceOuterBorderViewParent == null || detectedResult == null) {
                drawFaceRectFinished = true;
                return;
            }
            for (RecognizeFaceInfoView recognizeFaceInfoView : recognizeFaceInfoViewList) {
                recognizeFaceInfoView.setVisibility(View.INVISIBLE);
            }
            int i = 0;
            if (Constants.indoorOutdoorInOne) {
                if (mainActivity().secondaryDisplay != null) {
                    mainActivity().secondaryDisplay.drawFaceRect(detectedResult);
                }
            }
            for (FacePosition facePosition : detectedResult.facePositions) {
                RecognizeFaceInfoView recognizeFaceInfoView = null;
                if (recognizeFaceInfoViewList.size() - 1 < i) {
                    recognizeFaceInfoView = new RecognizeFaceInfoView(getContext());
                    recognizeFaceInfoViewList.add(recognizeFaceInfoView);
                    if (Constants.indoorOutdoorInOne) {
                        faceOuterBorderViewParent.addView(recognizeFaceInfoView, 4);
                    } else {
                        faceOuterBorderViewParent.addView(recognizeFaceInfoView, 3);
                    }
                } else {
                    recognizeFaceInfoView = recognizeFaceInfoViewList.get(i);
                }
                if (Constants.indoorOutdoorInOne) {
                    if (textureViewParent != null) {
                        recognizeFaceInfoView.showAtPosition(facePosition, textureViewParent.getHeight(),
                                textureViewParent.getWidth(),
                                detectedResult.width,
                                detectedResult.height
                        );
                    }
                } else {
                    recognizeFaceInfoView.showAtPosition(facePosition, rgb_camera.getHeight(),
                            rgb_camera.getWidth(),
                            detectedResult.width,
                            detectedResult.height
                    );
                }
                i++;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            drawFaceRectFinished = true;
        }
    }

    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        return inflater.inflate(ResolutionAdaptation.fragment_camera(), container, false);
    }

    public void addDetectedResult(DetectedResult detectedResult) {
        if (!CfCompareFeatureThread.isRunning) {
            CameraFragment.detectedResult = detectedResult;
            BaseApplication.getApplication().executorService.execute(CfCompareFeatureThread);
        }
    }

    @Click
    public void nic_back_person_manager() {
        SystemInitManager.showSecondDisplay(mainActivity());
        mainActivity().fragment_menu.person_manage1();
    }

    public void showCameraInGuestMode() {
    }

    public void showCameraInGuestMode(boolean showBorder) {
        if (Constants.indoorOutdoorInOne) {
            try {
                if (showBorder) {
                    LayoutUtil.applyStyle(faceOuterBorderViewParent, StyleBuilder.newStyleBuild().marginTop(20).marginRight(0).marginBottom(161).marginLeft(20).buildStyle());
                    hideOverlay();
                    topBlurView2_guest_mode.setVisibility(View.VISIBLE);
                    topBackground2_guest_mode.setVisibility(View.VISIBLE);
                } else {
                    overlay.setVisibility(View.VISIBLE);
                    topBlurView2_guest_mode.setVisibility(View.INVISIBLE);
                    topBackground2_guest_mode.setVisibility(View.INVISIBLE);
                    cameraExitGuestMode();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }


    @UiThread
    public void showOverlay() {
        if (overlay != null) {
            overlay.setVisibility(View.VISIBLE);
        }
        if (nic_back_person_manager != null) {
            nic_back_person_manager.setVisibility(View.GONE);
        }
        if (Constants.indoorOutdoorInOne) {
            showCameraInGuestMode();
        }
    }

    @UiThread
    public void hideOverlay() {
        if (Constants.indoorOutdoorInOne) {
            showCameraInGuestMode();
        }
        if (overlay != null) {
            overlay.setVisibility(View.INVISIBLE);
        }
        if (nic_back_person_manager != null) {
            if (
                    mainActivity().currentFragment == mainActivity().fragment_su_logged_ic_wait_face ||
                            mainActivity().currentFragment == mainActivity().fragment_su_logged_ic_wait_idcard ||
                            mainActivity().currentFragment == mainActivity().fragment_su_logged_nic_wait_face ||
                            mainActivity().currentFragment == mainActivity().fragment_su_logged_nic_wait_detail ||
                            mainActivity().currentFragment == mainActivity().fragment_su_logged_ic_compare_success
                    ) {
                nic_back_person_manager.setVisibility(View.VISIBLE);
            } else {
                nic_back_person_manager.setVisibility(View.GONE);
            }
        }
    }

    @AfterViews
    public void afterViews() {
        h264Player.setVisibility(View.GONE);
        if (ContextCompat.checkSelfPermission(mainActivity(), android.Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
            requestPermissions(new String[]{android.Manifest.permission.CAMERA}, CAMERA_OK);
        } else {
            openCamera();
        }
        if (Constants.indoorOutdoorInOne) {
            camera2.setClipToOutline(true);
            camera2.setOutlineProvider(new ViewOutlineProvider() {
                public void getOutline(View view, Outline outline) {
                    outline.setRoundRect(0, 0, view.getWidth(), view.getHeight(), getResources().getDimension(com.basic.security.utils.RUtils.R_dimen_corner_radius));
                }
            });
        }
    }

    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        switch (requestCode) {
            case CAMERA_OK:
                openCamera();
                resetCamera();
                break;
            default:
                break;
        }
    }

    public void resetCamera() {
        rgb_camera.resetCamera = false;
        rgb_camera.reset();
    }

    private void openCamera() {
        rgb_camera.setOutlineProvider(new ViewOutlineProvider() {
            public void getOutline(View view, Outline outline) {
                outline.setRoundRect(0, 0, view.getWidth(), view.getHeight(), getActivity().getResources().getDimension(com.basic.security.utils.RUtils.R_dimen_corner_radius));
            }
        });
        rgb_camera.setClipToOutline(true);
        if (Constants.indoorOutdoorInOne) {
            textureView.setOutlineProvider(new ViewOutlineProvider() {
                public void getOutline(View view, Outline outline) {
                    outline.setRoundRect(0, 0, view.getWidth(), view.getHeight(), getActivity().getResources().getDimension(com.basic.security.utils.RUtils.R_dimen_corner_radius));
                }
            });
            textureView.setClipToOutline(true);
            textureView.setSurfaceTextureListener(rgb_camera);
        }
        if (getActivity() == null) {
            return;
        }
        FaceId.initSdk(getActivity(), rgb_camera, gray_camera, detectedResult -> {
            if (detectedResult.facePositions.size() > 0) {
                if (mainActivity().currentFragment == mainActivity().fragment_su_auto_wait_face
                        || mainActivity().currentFragment == mainActivity().fragment_admin_face_login
                        || mainActivity().currentFragment == mainActivity().fragment_su_logged_ic_wait_face
                        || mainActivity().currentFragment == mainActivity().fragment_su_logged_nic_wait_face) {
                    mainActivity().refreshCurrentFragmentShowTime();
                }
                lastTimeDetectedFaceInCamera = System.currentTimeMillis();
                addDetectedResult(detectedResult);
            }
        });
        RecognizeManager.processRecognizeResult();
        clearAllFaceRectWhenTimeout();
    }

    @UiThread
    public void cameraEnterGuestMode() {
        if (GuestManager.twoCameras()) {
            camera2.setVisibility(View.VISIBLE);
            camera2_separator.setVisibility(View.VISIBLE);
            LayoutUtil.applyStyle(faceOuterBorderViewParent, StyleBuilder.newStyleBuild().marginTop(20).marginRight(0).marginBottom(300).marginLeft(20).buildStyle());
        } else {
            if (Constants.indoorOutdoorInOne) {
                camera2.setVisibility(View.GONE);
                camera2_separator.setVisibility(View.GONE);
                LayoutUtil.applyStyle(faceOuterBorderViewParent, StyleBuilder.newStyleBuild().marginTop(20).marginRight(0).marginBottom(161).marginLeft(20).buildStyle());
            }
        }
    }

    @UiThread
    public void cameraExitGuestMode() {
        LayoutUtil.applyStyle(faceOuterBorderViewParent, StyleBuilder.newStyleBuild().marginTop(0).marginRight(0).marginBottom(0).marginLeft(0).buildStyle());
        camera2.setVisibility(View.GONE);
        camera2_separator.setVisibility(View.GONE);
    }

    static class CfCompareFeatureThread implements Runnable {
        public boolean isRunning = false;

        @Override
        public void run() {
            try {
                if (detectedResult != null) {
                    if (detectedResult.shouldExtractFeature) {
                        for (FacePosition facePosition : detectedResult.facePositions) {
                            facePosition.readFaceFeature();
                            FacePositionManager.processFaceFeature(facePosition);
                        }
                        DetectResultManager.setDetectResult(detectedResult);
                        OutdoorGuestSocketServer.setDetectedResult(detectedResult);
                    } else if (drawFaceRectFinished) {
                        BaseApplication.getApplication().activity.fragment_camera.drawFaceRect(detectedResult);
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            isRunning = false;
        }
    }
}