#ifndef ANSLIB_H
#define ANSLIB_H
#define ANSLIB_API __declspec(dllexport)
#define CUSTOM_API __declspec(dllexport)
#pragma once
#include <windows.h>
#include <opencv2/opencv.hpp>
#include <opencv2/core/cuda.hpp>
enum DetectionType {
	CLASSIFICATION = 0,
	DETECTION = 1,
	SEGMENTATION = 2,
	FACEDETECTOR = 3,
	FACERECOGNIZER = 4,
	LICENSEPLATE = 5,
	TEXTSCENSE = 6,
	KEYPOINT = 7,
	OBB = 8 // Oriented Bounding Box
};
enum ModelType {
    TENSORFLOW = 0,
    YOLOV4 = 1,
    YOLOV5 = 2,
    YOLOV8 = 3,
    TENSORRT = 4,
    OPENVINO = 5,
    FACEDETECT = 6,
    FACERECOGNIZE = 7,
    ALPR = 8,
    OCR = 9,
    ANOMALIB = 10,
    POSE = 11,
    SAM = 12,
    ODHUBMODEL = 13,
    YOLOV10RTOD = 14, // TensorRT Object Detection for Yolov10
    YOLOV10OVOD = 15, // OpenVINO Object Detection for Yolov10
    CUSTOMDETECTOR = 16, // Custom Detector
    YOLOV12 = 17, // YoloV12 standard for yolov12
    CUSTOMPY = 18, // Custom Python script model
    MOTIONDETECTOR = 19, // Motion Detector,
    ONNXCL = 20,
    ONNXPOSE = 21,
    RTPOSE = 22,
    ONNXSEG = 23,
    RTSEG = 24,
    ONNXOBB = 25,
    RTOBB = 26,
    MOVIENET = 27,
    ONNXSAM3 = 28,
    RTSAM3 = 29,
    ONNXYOLO = 30,
    RTYOLO = 31
};
enum TrackerType {
    BYTETRACK = 0,
    UCMC = 1,
    OCSORT = 2
};
namespace ANSCENTER {
    struct Point {
        int x, y;
    };
    struct ROIConfig {
        bool Rectangle;
        bool Polygon;
        bool Line;
        int MinItems;
        int MaxItems;
        std::string Name;
        std::string ROIMatch;
    };

    struct Parameter {
        std::string Name;
        std::string DataType;
        int NoOfDecimals;
        int MaxValue;
        int MinValue;
        std::string StartValue;
        std::vector<std::string> ListItems;
        std::string DefaultValue;
        std::string Value;
    };

    struct ROIValue {
        std::string ROIMatch;
        std::vector<Point> ROIPoints;
        std::string Option;
        std::string Name;
        int OriginalImageSize;
    };
    struct Params {
        std::vector<ROIConfig> ROI_Config;
        std::vector<std::string> ROI_Options;
        std::vector<Parameter> Parameters;
        std::vector<ROIValue> ROI_Values;
    };

    /* Example
    {
  "ROI_Config":[
    {
      "Rectangle":true,
      "Polygon":true,
      "Line":false,
      "MinItems":0,
      "MaxItems":3,
      "Name":"Traffic Light",
      "ROI-Match":"All Corners"
    },
    {
      "Rectangle":true,
      "Polygon":false,
      "Line":false,
      "MinItems":1,
      "MaxItems":1,
      "Name":"Car Zone",
      "ROI-Match":"All Corners"
    },
    {
      "Rectangle":false,
      "Polygon":false,
      "Line":true,
      "MinItems":1,
      "MaxItems":2,
      "Name":"Cross Line",
      "ROI-Match":"All Corners"
    }
  ],
  "ROI_Options":[
    "Inside ROI",
    "Inside ROI",
    "Both Directions"
  ],
  "Parameters":[
    {
      "Name":"Para1",
      "DataType":"Boolean",
      "NoOfdecimals":0,
      "MaxValue":0,
      "MinValue":0,
      "StartValue":"",
      "ListItems":[],
      "DefaultValue":"",
      "Value":"true"
    },
    {
      "Name":"Para2",
      "DataType":"Integer",
      "NoOfdecimals":0,
      "MaxValue":5,
      "MinValue":1,
      "StartValue":"2",
      "ListItems":[],
      "DefaultValue":"",
      "Value":"3"
    },
    {
      "Name":"Para3",
      "DataType":"List-Single",
      "NoOfdecimals":0,
      "MaxValue":0,
      "MinValue":0,
      "StartValue":"",
      "ListItems":["A","B","C"],
      "DefaultValue":"",
      "Value":"A"
    },
    {
      "Name":"Para4",
      "DataType":"Range",
      "NoOfdecimals":0,
      "MaxValue":100,
      "MinValue":50,
      "StartValue":">,60",
      "ListItems":[">","<"],
      "DefaultValue":"",
      "Value":">,52.000000"
    }
  ],
  "ROI_Values":[
    {
      "ROI-Match":"Centre Point",
      "ROIPoints":[
        {"x":269,"y":134},
        {"x":777,"y":134},
        {"x":777,"y":457},
        {"x":269,"y":457}
      ],
      "Option":"Inside ROI",
      "Name":"Car Zone 1",
      "OriginalImageSize":1920
    },
    {
      "ROI-Match":"Centre Point",
      "ROIPoints":[{"x":280,"y":613},{"x":1108,"y":280}],
      "Option":"Above",
      "Name":"Cross Line 1",
      "OriginalImageSize":1920
    },
    {
      "ROI-Match":"Centre Point",
      "ROIPoints":[{"x":1511,"y":383},{"x":1283,"y":754}],
      "Option":"Left side",
      "Name":"Cross Line 2",
      "OriginalImageSize":1920
    },
    {
      "ROI-Match":"Centre Point",
      "ROIPoints":[
        {"x":229,"y":161},
        {"x":964,"y":161},
        {"x":964,"y":628},
        {"x":229,"y":628}
      ],
      "Option":"Left side",
      "Name":"Traffic Light 1",
      "OriginalImageSize":1920
    },
    {
      "ROI-Match":"Centre Point",
      "ROIPoints":[
        {"x":1115,"y":304},
        {"x":1730,"y":304},
        {"x":1730,"y":695},
        {"x":1115,"y":695}
      ],
      "Option":"Left side",
      "Name":"Traffic Light 2",
      "OriginalImageSize":1920
    },
    {
      "ROI-Match":"Centre Point",
      "ROIPoints":[
        {"x":678,"y":683},
        {"x":1217,"y":683},
        {"x":1217,"y":1026},
        {"x":678,"y":1026}
      ],
      "Option":"Left side",
      "Name":"Traffic Light 3",
      "OriginalImageSize":1920
    }
  ]
}
    */
	struct Object
	{
		int classId{ 0 };
		int trackId{ 0 };
		std::string className{};
		float confidence{ 0.0 };
		cv::Rect box{};
		std::vector<cv::Point2f> polygon;    // Polygon that contain x1,y1,x2,y2,x3,y3,x4,y4
		cv::Mat mask{};                      // Face image in box (cropped) or mask image for segmentation
		cv::cuda::GpuMat gpuMask{};          // GPU-resident face crop (set by NV12 affine warp, avoids re-upload)
		std::vector<float> kps{};            // Pose exsimate 17 keypoints or oriented bouding box (xcenter, ycenter, width, height, angle)
		std::string extraInfo;               // More information such as facial recognition
		std::string cameraId;                // Use to check if this object belongs to any camera
		//std::string attributes;            // Attributes such as keypoint string
	};
	class ANSLIB_API ANSLIB {
    public:
        ANSLIB();
        ~ANSLIB() noexcept;
		[[nodiscard]] static ANSLIB* Create();
		static void Destroy(ANSLIB* instance);
		[[nodiscard]] int Initialize(const char* licenseKey,
			const char* modelFilePath,
			const char* modelFileZipPassword,
			float modelThreshold,
			float modelConfThreshold,
			float modelNMSThreshold,
			int modelType,
			int detectionType, int loadEngineOnCreation,std::string &labels);
		[[nodiscard]] int RunInference(cv::Mat cvImage, const char* cameraId, std::vector<ANSCENTER::Object>& detectionResult);
        [[nodiscard]] int RunInferenceWithOptions(cv::Mat cvImage, const char* cameraId, const char* activeROIMode, std::vector<ANSCENTER::Object>& detectionResult);
		[[nodiscard]] int OptimizeModel(const char* modelFilePath, const char* modelFileZipPassword, int modelType, int modelDetectionType,int fp16);
		[[nodiscard]] int Optimize(bool fp16); // Perform optimization on the loaded model on current model folder
		[[nodiscard]] int GetEngineType();
		[[nodiscard]] int LoadModelFromFolder(const char* licenseKey, const char* modelName, const char* className,
			float detectionScoreThreshold, float modelConfThreshold, float modelMNSThreshold,
			int autoDetectEngine, int modelType, int detectionType, int loadEngineOnCreation, const char* modelFolder, std::string& labelMap);
		[[nodiscard]] int DetectMovement(cv::Mat image, const char* cameraId, std::vector<Object>& results);
		[[nodiscard]] cv::Rect GetActiveWindow(cv::Mat cvImage);
		[[nodiscard]] int SetPrompt(const char* text);
		[[nodiscard]] int SetTracker(int trackerType, int enableTracker);
		[[nodiscard]] int SetTrackerParameters(const char* trackerParams);
    private:
        HMODULE dllHandle = nullptr;
        bool loaded = false;
        void* ANSHandle = nullptr;
        const char* CreateANSODHandle_CS(void** Handle,
            const char* licenseKey,
            const char* modelFilePath,
            const char* modelFileZipPassword,
            float modelThreshold,
            float modelConfThreshold,
            float modelNMSThreshold,
            int autoDetectEngine,
            int modelType,
            int detectionType, 
            int loadEngineOnCreation);
        int RunInference_CPP(void** Handle, cv::Mat** cvImage, const char* cameraId, std::vector<ANSCENTER::Object>& detectionResult);
        int RunInferenceComplete_CPP(void** Handle, cv::Mat** cvImage, const char* cameraId, const char* activeROIMode,std::vector<ANSCENTER::Object>& detectionResult);
        const char* OptimizeModelStr_CS(const char* modelFilePath, const char* modelFileZipPassword, int modelType, int modelDetectionType,int fp16);
        int ReleaseANSODHandle(void** Handle);
		int GetActiveRect(cv::Mat cvImage, cv::Rect& activeWindow);
		int GetODParameters(ANSCENTER::Params& param);
		int UpdateDetectionMinScore(float scoreThreshold);
        [[nodiscard]] bool IsLoaded() const;

        typedef const char* (*CreateANSODHandle_CSFuncT)(void**, const char*, const char*, const char*, float, float, float, int, int, int, int);
        typedef const char* (*OptimizeModelStr_CSFuncT)(const char*, const char*, int, int, int);
        typedef int (*RunInference_CPPFuncT)(void**, cv::Mat**, const char*, std::vector<ANSCENTER::Object>& detectionResult);
        typedef int (*RunInferenceComplete_CPPFuncT)(void**, cv::Mat**, const char*, const char*, std::vector<ANSCENTER::Object>& detectionResult);
        typedef int (*ReleaseANSODHandleFuncT)(void**);
		typedef int(*GetEngineTypeFuncT)();
		typedef int(*LoadModelFromFolderFuncT)(void**, const char*, const char*, const char*, float, float, float, int, int, int,int, const char*,std::string&);
		typedef int(*GetActiveRectFuncT)(void**, cv::Mat, cv::Rect&);
		typedef int(*DetectMovementFuncT)(void**, cv::Mat, const char*, std::vector<ANSCENTER::Object>&);
		typedef int(*OptimizeFuncT)(void**, bool);
        typedef int(*GetODParametersFuncT)(void**, ANSCENTER::Params&);
        typedef int(*UpdateDetectionMinScoreFuncT)(void**, float);  // Add 'Func' to match other typedefs
        typedef int(*SetPromptFuncT)(void**, const char*);
        typedef int(*SetTrackerFuncT)(void**, int, int);
        typedef int(*SetTrackerParametersFuncT)(void**, const char*);

        CreateANSODHandle_CSFuncT CreateANSODHandle_CSFunc = nullptr;
        OptimizeModelStr_CSFuncT OptimizeModelStr_CSFunc = nullptr;
        ReleaseANSODHandleFuncT ReleaseANSODHandleFunc = nullptr;
        RunInference_CPPFuncT RunInference_CPPFunc = nullptr;
        RunInferenceComplete_CPPFuncT RunInferenceComplete_CPPFunc = nullptr;
		GetEngineTypeFuncT GetEngineTypeFunc = nullptr;
		LoadModelFromFolderFuncT LoadModelFromFolderFunc = nullptr;
		GetActiveRectFuncT GetActiveRectFunc = nullptr;
		DetectMovementFuncT DetectMovementFunc = nullptr;
		OptimizeFuncT OptimizeFunc = nullptr;
        GetODParametersFuncT GetODParametersFunc = nullptr;
        UpdateDetectionMinScoreFuncT UpdateDetectionMinScoreFunc = nullptr;
        SetPromptFuncT SetPromptFunc = nullptr;
        SetTrackerFuncT SetTrackerFunc = nullptr;
        SetTrackerParametersFuncT SetTrackerParametersFunc = nullptr;
    };
}

struct CustomObject
{
    int classId{ 0 };
    int trackId{ 0 };
    std::string className{};
    float confidence{ 0.0 };
    cv::Rect box{};
    std::vector<cv::Point2f> polygon;    // Polygon that contain x1,y1,x2,y2,x3,y3,x4,y4
    cv::Mat mask{};                      // Face image in box (cropped) or mask image for segmentation
    cv::cuda::GpuMat gpuMask{};          // GPU-resident face crop (set by NV12 affine warp, avoids re-upload)
    std::vector<float> kps{};            // Pose exsimate 17 keypoints or oriented bouding box (xcenter, ycenter, width, height, angle)
    std::string extraInfo;               // More information such as facial recognition
    std::string cameraId;                // Use to check if this object belongs to any camera
    //std::string attributes;            // Attributes such as keypoint string
};
struct CustomPoint { int x, y; };
struct CustomROIConfig {
    bool Rectangle;
    bool Polygon;
    bool Line;
    int MinItems;
    int MaxItems;
    std::string Name;
    std::string ROIMatch;
};
struct CustomParameter {
    std::string Name;
    std::string DataType;
    int NoOfDecimals;
    int MaxValue;
    int MinValue;
    std::string StartValue;
    std::vector<std::string> ListItems;
    std::string DefaultValue;
    std::string Value;
};
struct CustomROIValue {
    std::string ROIMatch;
    std::vector<CustomPoint> ROIPoints;
    std::string Option;
    std::string Name;
    int OriginalImageSize;
};
struct CustomParams {
    std::vector<CustomROIConfig> ROI_Config;
    std::vector<std::string> ROI_Options;
    std::vector<CustomParameter> Parameters;
    std::vector<CustomROIValue> ROI_Values;
};
class CUSTOM_API IANSCustomClass
{
protected:
    std::string _modelDirectory; // The directory where the model is located
    float _detectionScoreThreshold{ 0.5 };
    CustomParams _params; // Parameters for the model
    bool _loadEngineOnCreate{ false }; // Load engine on create
public:
    virtual bool Initialize(const std::string& modelDirectory, float detectionScoreThreshold, std::string& labelMap) = 0;
    virtual bool OptimizeModel(bool fp16) = 0;
    virtual std::vector<CustomObject> RunInference(const cv::Mat& input) = 0;
    virtual std::vector<CustomObject> RunInference(const cv::Mat& input, const std::string& camera_id) = 0;
    virtual bool ConfigureParameters(CustomParams& param) = 0;
    virtual bool Destroy() = 0;
    bool SetParameters(const CustomParams& param) {
        try {
            this->_params.ROI_Config.clear();
            for (auto& cf : param.ROI_Config) {
                this->_params.ROI_Config.push_back(cf);
            }
            this->_params.ROI_Options.clear();
            for (auto& op : param.ROI_Options) {
                this->_params.ROI_Options.push_back(op);
            }
            this->_params.Parameters.clear();
            for (auto& par : param.Parameters) {
                this->_params.Parameters.push_back(par);
            }
            this->_params.ROI_Values.clear();
            for (auto& roi : param.ROI_Values) {
                this->_params.ROI_Values.push_back(roi);
            }
            return true;
        }
        catch (...) {
            return false;
        }
    };
    void SetLoadEngineOnCreate(bool loadEngineOnCreate) {
        this->_loadEngineOnCreate = loadEngineOnCreate;
    }
};

#endif