#ifndef CASICFACEINTERFACE_H
#define CASICFACEINTERFACE_H

#include "opencv2/opencv.hpp"
#include "seeta/FaceDetector.h"
#include "seeta/FaceLandmarker.h"
#include "seeta/QualityAssessor.h"
#include "seeta/QualityOfBrightness.h"
#include "seeta/QualityOfClarity.h"
#include "seeta/QualityOfIntegrity.h"
#include "seeta/QualityOfResolution.h"
#include "seeta/QualityOfPoseEx.h"
#include "seeta/FaceAntiSpoofing.h"
#include "seeta/FaceRecognizer.h"

#include "CasicFaceInfo.h"

static auto red = CV_RGB(255, 0, 0);
static auto green = CV_RGB(0, 255, 0);
static auto blue = CV_RGB(0, 0, 255);

namespace casic {
    namespace face {
        class CasicFaceInterface
        {
        public:
            ~CasicFaceInterface();
            CasicFaceInterface(const CasicFaceInterface&)=delete;
            CasicFaceInterface& operator=(const CasicFaceInterface&)=delete;

            static CasicFaceInterface& getInstance() {
                static CasicFaceInterface instance;
                return instance;
            }

            void setDetectorModelPath(std::string detectorModelPath);
            void setMarkPts5ModelPath(std::string markPts5ModelPath);
            void setPoseModelPath(std::string poseModelPath);
            void setFas1stModelPath(std::string fas1stModelPath);
            void setFas2ndModelPath(std::string fas2ndModelPath);
            void setRecognizerModelPath(std::string recognizerModelPath);

            void setAntiThreshold(float clarity, float reality);

            CasicFaceInfo faceDetect(cv::Mat frame);
            CasicFaceInfo faceQuality(CasicFaceInfo faceInfo);
            CasicFaceInfo faceAntiSpoofing(CasicFaceInfo faceInfo);
            CasicFaceInfo faceFeatureExtract(CasicFaceInfo faceInfo);
            float faceSimCalculate(float* feature, float* otherFeature);

            cv::Rect faceDetectByCVCascade(cv::Mat frame);
            cv::Rect faceDetectByCVCascade(cv::Mat frame, int minFaceSize);

            cv::Rect eyeDetectByCVCascade(cv::Mat frame);
            cv::Rect eyeGlassesDetectByCVCascade(cv::Mat frame);
            std::vector<cv::Rect> eyeDetectByCVCascade(cv::Mat frame, int minEyeSize);
            void setMinFaceSize(int minFaceSize);
            void setMinEyeSize(int minEyeSize);
        private:
            CasicFaceInterface();

            int deviceId = 0;
            seeta::ModelSetting::Device device = seeta::ModelSetting::AUTO;

            float clarity = 0.3f;
            float reality = 0.3f;

            std::string cvFaceCascadeName = "./model/haarcascade_frontalface_default.xml";
            std::string cvEyeCascadeName = "./model/haarcascade_eye.xml";
            std::string cvEyeGlassesCascadeName = "./model/haarcascade_eye_tree_eyeglasses.xml";
            int minFaceSize = 320;
            int maxFaceSize = 720;
            int minEyeSize = 50;
            int maxEyeSize = 400;

            std::string detectorModelPath = "./model/face_detector.csta";
            std::string markPts5ModelPath = "./model/face_landmarker_pts5.csta";
            std::string poseModelPath = "./model/pose_estimation.csta";
            std::string fas1stModelPath = "./model/fas_first.csta";
            std::string fas2ndModelPath = "./model/fas_second.csta";
            std::string recognizerModelPath = "./model/face_recognizer.csta";

            seeta::FaceDetector * detector = nullptr;
            seeta::FaceLandmarker * marker = nullptr;
            seeta::QualityOfPoseEx * poseEx = nullptr;
            seeta::FaceAntiSpoofing * processor = nullptr;
            seeta::FaceRecognizer * recognizer = nullptr;

            cv::CascadeClassifier * cascade;
            cv::CascadeClassifier * eyeCascade;
            cv::CascadeClassifier * eyeGlassesCascade;
        };
    }
}


#endif // CASICFACEINTERFACE_H