#include "ANSCUSTOMPY.h"
#include <filesystem>
#include <json.hpp>
using json = nlohmann::json;
namespace fs = std::filesystem;
namespace py = pybind11;

namespace {
    using ThreadLocalModelMap = std::unordered_map<int, std::shared_ptr<ANSCENTER::ModelWrapper>>;
    ThreadLocalModelMap& GetThreadLocalState() {
        thread_local ThreadLocalModelMap threadState;
        return threadState;
    }
}
std::string CustomParametersToJson(const ANSCENTER::Params& params) {
    json root;
    // ROI_Config
    for (const auto& cfg : params.ROI_Config) {
        json j;
        j["Rectangle"] = cfg.Rectangle;
        j["Polygon"] = cfg.Polygon;
        j["Line"] = cfg.Line;
        j["MinItems"] = cfg.MinItems;
        j["MaxItems"] = cfg.MaxItems;
        j["Name"] = cfg.Name;
        j["ROI-Match"] = cfg.ROIMatch;
        root["ROI_Config"].push_back(j);
    }

    // ROI_Options
    for (const auto& opt : params.ROI_Options) {
        root["ROI_Options"].push_back(opt);
    }

    // Parameters
    for (const auto& param : params.Parameters) {
        json j;
        j["Name"] = param.Name;
        j["DataType"] = param.DataType;
        j["NoOfdecimals"] = param.NoOfDecimals;
        j["MaxValue"] = param.MaxValue;
        j["MinValue"] = param.MinValue;
        j["StartValue"] = param.StartValue;
        j["ListItems"] = param.ListItems;
        j["DefaultValue"] = param.DefaultValue;
        j["Value"] = param.Value;
        root["Parameters"].push_back(j);
    }

    // ROI_Values
    for (const auto& rv : params.ROI_Values) {
        json j;
        j["ROI-Match"] = rv.ROIMatch;

        for (const auto& pt : rv.ROIPoints) {
            j["ROIPoints"].push_back({ {"x", pt.x}, {"y", pt.y} });
        }

        j["Option"] = rv.Option;
        j["Name"] = rv.Name;
        j["OriginalImageSize"] = rv.OriginalImageSize;
        root["ROI_Values"].push_back(j);
    }

    // Convert to compact JSON string (no whitespace)
    std::string jsonString = root.dump();  // dump() without indent = compact

    return jsonString;
}
namespace ANSCENTER
{
    std::once_flag PythonRuntime::initFlag;
    std::unique_ptr<PythonRuntime> PythonRuntime::instance = nullptr;
    std::atomic<bool> PythonRuntime::_isInitialized{ false };
    std::atomic<bool> PythonRuntime::shuttingDown{ false };
    std::mutex PythonRuntime::_instanceMutex;

    std::mutex ANSCUSTOMPY::_globalInstancesMutex;
    std::unordered_set<ANSCUSTOMPY*> ANSCUSTOMPY::_globalInstances;
    std::atomic<int> ANSCUSTOMPY::globalInstanceCounter{ 1 };

    // Declare GetPythonRuntime as a friend function of PythonRuntime
    PythonRuntime& GetPythonRuntime(const std::wstring& pythonHome);

    PythonRuntime& GetPythonRuntime(const std::wstring& pythonHome) {
        std::call_once(PythonRuntime::initFlag, [&]() {
            std::lock_guard<std::mutex> lock(PythonRuntime::_instanceMutex);
            PythonRuntime::instance = std::unique_ptr<PythonRuntime>(new PythonRuntime(pythonHome));
            });
        return *PythonRuntime::instance;
    }

    PythonRuntime::PythonRuntime(const std::wstring& home) : pythonHome(home) {
        InitializeInterpreter();
    }

    bool PythonRuntime::IsInitialized() {
        return _isInitialized.load(std::memory_order_acquire) && Py_IsInitialized();
    }

    void PythonRuntime::InitializeInterpreter() {
        if (!pythonHome.empty()) {
#pragma warning(push)
#pragma warning(disable : 4996)
            Py_SetPythonHome(pythonHome.c_str());
#pragma warning(pop)
        }
        py::initialize_interpreter();
        _isInitialized.store(true, std::memory_order_release);
        PatchPythonStreamsSafe();
    }

    void PythonRuntime::PatchPythonStreamsSafe() {
        try {
            py::exec(R"(
import sys, io
class DummyStream(io.StringIO):
    def write(self, txt): pass
    def flush(self): pass
if sys.stdout is None or not hasattr(sys.stdout, "write"):
    sys.stdout = DummyStream()
if sys.stderr is None or not hasattr(sys.stderr, "write"):
    sys.stderr = DummyStream()
)");
        }
        catch (const py::error_already_set& e) {
            std::cerr << "[PatchPythonStreamsSafe] Python error: " << e.what() << std::endl;
        }
    }

    void PythonRuntime::AddToSysPath(const std::string& path) {
        if (!IsInitialized()) {
            std::cerr << "[PythonRuntime::AddToSysPath] Interpreter not initialized!\n";
            return;
        }
        py::gil_scoped_acquire gil;
        py::module_ sys = py::module_::import("sys");
        sys.attr("path").attr("insert")(0, path);
    }

    void PythonRuntime::Shutdown() {
        std::lock_guard<std::mutex> lock(_instanceMutex);
        if (shuttingDown.exchange(true)) return;
        if (_isInitialized.load(std::memory_order_acquire)) {
            try {
                py::gil_scoped_acquire gil;
                py::module::import("gc").attr("collect")();
            }
            catch (...) {
                std::cerr << "[PythonRuntime::Shutdown] GC failed (ignored)." << std::endl;
            }
            try {
                py::finalize_interpreter();
            }
            catch (...) {
                std::cerr << "[PythonRuntime::Shutdown] finalize_interpreter failed." << std::endl;
            }
            _isInitialized.store(false, std::memory_order_release);
        }
        instance.reset();
    }
    
  
    /// <summary>
	/// /// Initializes the ANSCUSTOMPY model with the given parameters.
    /// </summary>
    ANSCUSTOMPY::ANSCUSTOMPY() {
        _instanceId = globalInstanceCounter.fetch_add(1, std::memory_order_relaxed);
        _destroyed = false;
        _isInitialized = false;
    }
    ANSCUSTOMPY::~ANSCUSTOMPY() {
        try {
            if (PythonRuntime::IsInitialized())
                Destroy();
        }
        catch (...) {
            std::cerr << "[~ANSCUSTOMPY] Exception during destruction." << std::endl;
        }
    }
    void ANSCUSTOMPY::RegisterSelf() {
        {
            std::lock_guard<std::mutex> lock(_globalInstancesMutex);
            _globalInstances.insert(this);
        }
        auto& threadState = GetThreadLocalState();
        if (!_wrapper || !_wrapper->modelFactory) return;
        if (threadState.find(_instanceId) == threadState.end()) {
            if (_wrapper && _wrapper->modelFactory) {
                py::gil_scoped_acquire gil;
                auto newWrapper = std::make_shared<ModelWrapper>();
                newWrapper->modelFactory = _wrapper->modelFactory;
                newWrapper->map[0] = std::make_shared<py::object>(_wrapper->modelFactory());
                threadState[_instanceId] = newWrapper;
            }
        }
    }
    void ANSCUSTOMPY::UnregisterSelf() {
        std::lock_guard<std::mutex> lock(_globalInstancesMutex);
        _globalInstances.erase(this);
    }
    void ANSCUSTOMPY::ClearThreadState() {
        auto& threadState = GetThreadLocalState();
        auto it = threadState.find(_instanceId);
        if (it != threadState.end()) {
            if (PythonRuntime::IsInitialized()) {
                py::gil_scoped_acquire gil;
                it->second->map.clear();
            }
            else {
                it->second->map.clear();
            }
            threadState.erase(it);
        }
    }
    bool ANSCUSTOMPY::EnsureModelReady(const std::string& methodName) {
        if (!_isInitialized || _destroyed || !PythonRuntime::IsInitialized()) {
            return false;
        }
        //auto& threadState = GetThreadLocalState();
        //if (threadState.find(_instanceId) == threadState.end()) {
        //    if (_wrapper && _wrapper->modelFactory) {
        //        py::gil_scoped_acquire gil;
        //        auto newWrapper = std::make_shared<ModelWrapper>();
        //        newWrapper->modelFactory = _wrapper->modelFactory;
        //        newWrapper->map[0] = std::make_shared<py::object>(_wrapper->modelFactory());
        //        threadState[_instanceId] = newWrapper;
        //    }
        //    else {
        //        return false;
        //    }
        //}
        return true;
    }
    py::object ANSCUSTOMPY::GetThreadLocalModel() {
        auto& threadState = GetThreadLocalState();
        auto it = threadState.find(_instanceId);
        if (_destroyed || it == threadState.end() || !it->second) {
            return py::none();
        }
        auto& modelMap = it->second->map;
        auto modelIt = modelMap.find(0);
        if (modelIt == modelMap.end()) {
            py::gil_scoped_acquire gil;
            auto obj = it->second->modelFactory();
            if (obj.is_none()) return py::none();
            auto wrapped = std::make_shared<py::object>(obj);
            modelMap[0] = wrapped;
            return *wrapped;
        }
        return *modelIt->second;
    }
    bool ANSCUSTOMPY::Destroy() {
        //std::lock_guard<std::recursive_mutex> lock(_mutex);
        if (_destroyed) return true;
        _destroyed = true;
        ClearThreadState();
        UnregisterSelf();
        return true;
    }
    void ANSCUSTOMPY::SafeShutdownAll(bool waitForShutdown) {
        std::unordered_set<ANSCUSTOMPY*> instancesCopy;
        {
            std::lock_guard<std::mutex> lock(_globalInstancesMutex);
            instancesCopy = _globalInstances;
        }
        for (ANSCUSTOMPY* instance : instancesCopy) {
            if (instance) {
                try {
                    instance->ClearThreadState();
                    instance->Destroy();
                }
                catch (...) {
                    std::cerr << "[SafeShutdownAll] Destroy failed." << std::endl;
                }
            }
        }
        std::this_thread::sleep_for(std::chrono::milliseconds(300));
        auto shutdownFunc = []() {
            try {
                std::this_thread::sleep_for(std::chrono::milliseconds(300));
                int retry = 0;
                while (!ANSCUSTOMPY::_globalInstances.empty() && retry++ < 100) {
                    std::this_thread::sleep_for(std::chrono::milliseconds(50));
                }
                if (PythonRuntime::IsInitialized()) {
                    py::gil_scoped_acquire gil;
                    py::module::import("gc").attr("collect")();
                    PythonRuntime::Shutdown();
                }
            }
            catch (...) {
                std::cerr << "[SafeShutdownAll] Shutdown failed." << std::endl;
            }
            };
        if (waitForShutdown) shutdownFunc();
        else std::thread(shutdownFunc).detach();
    }
    
    
    bool ANSCUSTOMPY::InitializePythonModel(const std::string& moduleName, const std::string& fullPath) {
        if (!PythonRuntime::IsInitialized()) {
            _logger.LogError("[InitializePythonModel] Python error:\n", "Python interpreter is not initialized.", __FILE__, __LINE__);
            return false;
        }
        py::gil_scoped_acquire gil;
        try {
            py::exec("import logging; logging.getLogger('ultralytics').setLevel(logging.CRITICAL)", py::globals());
            py::dict locals;
            std::ostringstream code;
            code << "import importlib.util\n"
                << "spec = importlib.util.spec_from_file_location('" << moduleName << "', r'" << fullPath << "')\n"
                << "mod = importlib.util.module_from_spec(spec)\n"
                << "spec.loader.exec_module(mod)\n";

            py::exec(code.str(), py::globals(), locals);
            py::object mod = locals["mod"];
            py::object modelClass = mod.attr("ANSModel");

            auto& threadState = GetThreadLocalState();
            auto& wrapper = threadState[_instanceId];  // ensure per-thread-per-instance
            if (!wrapper) wrapper = std::make_shared<ModelWrapper>();

            wrapper->modelFactory = [modelClass]() {
                    py::gil_scoped_acquire gil;
                    py::object instance = modelClass();
                    return instance;};
            _wrapper = wrapper;  // Store for main thread access too
            return true;
        }
        catch (const py::error_already_set& e) {
            PyErr_Print();
            _logger.LogFatal("InitializePythonModel", std::string("Python error: ") + e.what(), __FILE__, __LINE__);
            return false;
        }
    }
   
    bool ANSCUSTOMPY::Initialize(std::string licenseKey, ModelConfig modelConfig,
        const std::string& modelZipFilePath, const std::string& modelZipPassword,
        std::string& labelMap) {
        //std::lock_guard<std::recursive_mutex> lock(_mutex);
        try {
            // Step 1: Base model init
            bool result = ANSODBase::Initialize(licenseKey, modelConfig, modelZipFilePath, modelZipPassword, labelMap);
            if (!result) return false;

            _modelConfig = modelConfig;
            _modelConfig.inpHeight = 640;
            _modelConfig.inpWidth = 640;
            if (_modelConfig.modelMNSThreshold < 0.2) _modelConfig.modelMNSThreshold = 0.5;
            if (_modelConfig.modelConfThreshold < 0.2) _modelConfig.modelConfThreshold = 0.5;

            // Step 2: Validate model folder
            if (_modelFolder.empty()) {
                _logger.LogError("ANSCUSTOMPY::Initialize", "_modelFolder is not set.", __FILE__, __LINE__);
                return false;
            }

            // Step 3: Set Python Home
            std::wstring pythonHome;
            const fs::path sharedPython = "C:/ProgramData/ANSCENTER/Python311";
            const fs::path sharedDll = sharedPython / "python311.dll";

            if (fs::exists(sharedDll)) {
                pythonHome = sharedPython.wstring();
            }
            else {
                pythonHome = (fs::path(_modelFolder) / "python_env").wstring();
            }

            // Step 4: Initialize Python and sys.path
            auto& runtime = GetPythonRuntime(pythonHome);
            runtime.AddToSysPath(_modelFolder);

            // Step 5: Load Python model class from unique module
            //_scriptPath = _modelFolder + "/ansinfer.py";
            _scriptPath = fs::path(_modelFolder).append("ansinfer.py").string();
            _moduleName = "ansinfer_" + std::to_string(_instanceId);

            if (!InitializePythonModel(_moduleName, _scriptPath)) {
                _logger.LogError("ANSCUSTOMPY::Initialize", "Failed to load Python model.", __FILE__, __LINE__);
                return false;
            }

            // Step 6: Load class names
            _classFilePath = CreateFilePath(_modelFolder, "classes.names");
            std::ifstream isValidFileName(_classFilePath);
            if (!isValidFileName) {
                _logger.LogDebug("ANSCUSTOMPY::LoadModel. Load classes from string", _classFilePath, __FILE__, __LINE__);
                LoadClassesFromString();
            }
            else {
                _logger.LogDebug("ANSCUSTOMPY::LoadModel. Load classes from file", _classFilePath, __FILE__, __LINE__);
                LoadClassesFromFile();
            }

            labelMap.clear();
            if (!_classes.empty())
                labelMap = VectorToCommaSeparatedString(_classes);

            _destroyed = false;
            _isInitialized = true;
            RegisterSelf();
            return true;

        }
        catch (const std::exception& e) {
            _logger.LogFatal("ANSCUSTOMPY::Initialize", e.what(), __FILE__, __LINE__);
            return false;
        }
    }

    bool ANSCUSTOMPY::LoadModel(const std::string& modelZipFilePath, const std::string& modelZipPassword) {
        //std::lock_guard<std::recursive_mutex> lock(_mutex);
        try {
            // Step 0: Assign unique instance ID 
            if (!ANSODBase::LoadModel(modelZipFilePath, modelZipPassword))
                return false;

            if (_modelFolder.empty()) {
                _logger.LogError("ANSCUSTOMPY::LoadModel", "_modelFolder is not set.", __FILE__, __LINE__);
                return false;
            }

            // Step 3: Set Python home
            std::wstring pythonHome;
            const fs::path sharedPython = "C:/ProgramData/ANSCENTER/Python311";
            const fs::path sharedDll = sharedPython / "python311.dll";

            if (fs::exists(sharedDll)) {
                pythonHome = sharedPython.wstring();
            }
            else {
                pythonHome = (fs::path(_modelFolder) / "python_env").wstring();
            }

            // Step 4: Initialize Python and sys.path
            auto& runtime = GetPythonRuntime(pythonHome);
            runtime.AddToSysPath(_modelFolder);

            // Step 5: Load Python model class from unique module
            //_scriptPath = _modelFolder + "/ansinfer.py";
            _scriptPath = fs::path(_modelFolder).append("ansinfer.py").string();
            _moduleName = "ansinfer_" + std::to_string(_instanceId);

            if (!InitializePythonModel(_moduleName, _scriptPath)) {
                _logger.LogError("ANSCUSTOMPY::LoadModel", "Failed to load Python model.", __FILE__, __LINE__);
                return false;
            }
            _destroyed = false;
            _isInitialized = true;
            RegisterSelf();
            return true;
        }
        catch (const std::exception& e) {
            _logger.LogFatal("ANSCUSTOMPY::LoadModel", e.what(), __FILE__, __LINE__);
            return false;
        }
    }

    bool ANSCUSTOMPY::LoadModelFromFolder(std::string licenseKey, ModelConfig modelConfig,
        std::string modelName, std::string className,
        const std::string& modelFolder,
        std::string& labelMap)
    {
        //std::lock_guard<std::recursive_mutex> lock(_mutex);
        try {
            // Step 0: Assign unique instance ID early
            if (!ANSODBase::LoadModelFromFolder(licenseKey, modelConfig, modelName, className, modelFolder, labelMap))
                return false;
            _modelConfig = modelConfig;
            _modelConfig.inpHeight = 640;
            _modelConfig.inpWidth = 640;
            if (_modelConfig.modelMNSThreshold < 0.2) _modelConfig.modelMNSThreshold = 0.5;
            if (_modelConfig.modelConfThreshold < 0.2) _modelConfig.modelConfThreshold = 0.5;

            // Step 2: Validate model folder
            if (_modelFolder.empty()) {
                _logger.LogError("ANSCUSTOMPY::Initialize", "_modelFolder is not set.", __FILE__, __LINE__);
                return false;
            }

            // Step 3: Set Python home
            std::wstring pythonHome;
            const fs::path sharedPython = "C:/ProgramData/ANSCENTER/Python311";
            const fs::path sharedDll = sharedPython / "python311.dll";

            if (fs::exists(sharedDll)) {
                pythonHome = sharedPython.wstring();
            }
            else {
                pythonHome = (fs::path(_modelFolder) / "python_env").wstring();
            }

            // Step 4: Initialize Python and sys.path
            auto& runtime = GetPythonRuntime(pythonHome);
            runtime.AddToSysPath(_modelFolder);

            // Step 5: Load Python model class from unique module
            //_scriptPath = _modelFolder + "/ansinfer.py";
            _scriptPath = fs::path(_modelFolder).append("ansinfer.py").string();
            _moduleName = "ansinfer_" + std::to_string(_instanceId);

            if (!InitializePythonModel(_moduleName, _scriptPath)) {
                _logger.LogError("ANSCUSTOMPY::Initialize", "Failed to load Python model.", __FILE__, __LINE__);
                return false;
            }

            // Step 6: Load class labels
            _classFilePath = CreateFilePath(_modelFolder, "classes.names");
            std::ifstream isValidFileName(_classFilePath);
            if (!isValidFileName) {
                _logger.LogDebug("ANSCUSTOMPY::LoadModel", "Load classes from string", __FILE__, __LINE__);
                LoadClassesFromString();
            }
            else {
                _logger.LogDebug("ANSCUSTOMPY::LoadModel", "Load classes from file", __FILE__, __LINE__);
                LoadClassesFromFile();
            }

            labelMap.clear();
            if (!_classes.empty())
                labelMap = VectorToCommaSeparatedString(_classes);
            _destroyed = false;
            _isInitialized = true;
            RegisterSelf();
            return true;
        }
        catch (const std::exception& e) {
            _logger.LogFatal("ANSCUSTOMPY::LoadModelFromFolder", e.what(), __FILE__, __LINE__);
            return false;
        }
    }


    std::vector<Object> ANSCUSTOMPY::RunInference(const cv::Mat& input) {
        return RunInference(input, "CustomPyCam");
    }
    std::vector<Object> ANSCUSTOMPY::RunInference(const cv::Mat& input, const std::string& camera_id) {
        std::vector<Object> results;
        if (!_isInitialized) {
            _logger.LogError("ANSCUSTOMPY::RunInference", "Model is not initialized.", __FILE__, __LINE__);
            return results;
        }
        if (!_licenseValid) {
            _logger.LogError("ANSCUSTOMPY::RunInference", "Invalid License", __FILE__, __LINE__);
            return results;
        }
        if (input.empty()) {
            _logger.LogError("ANSCUSTOMPY::RunInference", "Input image is empty.", __FILE__, __LINE__);
            return results;
        }
        try {
            std::string jsonStr = RunPythonInferenceFromMat(input);
            if (!jsonStr.empty()) {
                results = ANSUtilityHelper::GetDetectionsFromString(jsonStr);
            }
            else {
                _logger.LogWarn("ANSCUSTOMPY::RunInference", "Empty JSON result from Python inference.", __FILE__, __LINE__);
            }
        }
        catch (const std::exception& e) {
            _logger.LogFatal("ANSCUSTOMPY::RunInference", e.what(), __FILE__, __LINE__);
        }

        return results;
    }
 
    std::string ANSCUSTOMPY::RunPythonInferenceFromMat(const cv::Mat& image) {
        if (!EnsureModelReady("RunPythonInferenceFromMat"))
            return "";
        if (image.empty())
            return "";

        try {
            py::object model = GetThreadLocalModel();
            if (model.is_none()) {
                _logger.LogError("ANSCUSTOMPY::RunPythonInferenceFromMat", "Model is None.", __FILE__, __LINE__);
                return "";
            }
            py::gil_scoped_acquire gil;
            if (!py::hasattr(model, "run_inference")) {
                _logger.LogError("ANSCUSTOMPY::RunPythonInferenceFromMat", "Model has no 'run_inference' method.", __FILE__, __LINE__);
                return "";
            }
            py::bytes image_bytes(reinterpret_cast<const char*>(image.data), image.total() * image.elemSize());
            py::object result = model.attr("run_inference")(image_bytes, image.cols, image.rows, image.channels());
            return result.cast<std::string>();
        }
        catch (const py::error_already_set& e) {
            PyErr_Print();
            _logger.LogFatal("RunPythonInferenceFromMat", e.what(), __FILE__, __LINE__);
            return "";
        }
        catch (const std::exception& e) {
            _logger.LogFatal("RunPythonInferenceFromMat", e.what(), __FILE__, __LINE__);
            return "";
        }
    }

    bool ANSCUSTOMPY::OptimizeModel(bool fp16, std::string& optimizedModelFolder) {
        if (!EnsureModelReady("OptimizeModel")) return false;
        try {
            py::object model = GetThreadLocalModel();
            if (model.is_none()) {
                _logger.LogError("ANSCUSTOMPY::OptimizeModel", "Model is None.", __FILE__, __LINE__);
                return false;
            }
            py::gil_scoped_acquire gil;
            if (!py::hasattr(model, "model_optimize")) {
                _logger.LogError("ANSCUSTOMPY::OptimizeModel", "Python model has no method 'model_optimize'.", __FILE__, __LINE__);
                return false;
            }
            py::object result;
            try {
                result = model.attr("model_optimize")(fp16);
            }
            catch (const py::error_already_set& e) {
                PyErr_Print();
                _logger.LogFatal("ANSCUSTOMPY::OptimizeModel", std::string("Exception in 'model_optimize': ") + e.what(), __FILE__, __LINE__);
                return false;
            }

            if (result.is_none()) {
                _logger.LogError("ANSCUSTOMPY::OptimizeModel", "Python 'model_optimize' returned None.", __FILE__, __LINE__);
                return false;
            }

            if (!py::isinstance<py::bool_>(result)) {
                _logger.LogError("ANSCUSTOMPY::OptimizeModel", "Unexpected return type from 'model_optimize'. Expected bool.", __FILE__, __LINE__);
                return false;
            }

            bool success = result.cast<bool>();
            if (success) {
                optimizedModelFolder = fs::path(_scriptPath).parent_path().string();
            }

            return success;
        }
        catch (const py::error_already_set& e) {
            PyErr_Print();
            _logger.LogFatal("ANSCUSTOMPY::OptimizeModel", e.what(), __FILE__, __LINE__);
            return false;
        }
        catch (const std::exception& e) {
            _logger.LogFatal("ANSCUSTOMPY::OptimizeModel", e.what(), __FILE__, __LINE__);
            return false;
        }
    }
    bool ANSCUSTOMPY::ConfigureParameters(Params& param) {
        if (!EnsureModelReady("ConfigureParamaters")) return false;

        try {
            py::object model = GetThreadLocalModel();
            if (model.is_none()) {
                _logger.LogError("ANSCUSTOMPY::ConfigureParamaters", "Model is None.", __FILE__, __LINE__);
                return false;
            }
            py::gil_scoped_acquire gil;
            if (!py::hasattr(model, "configureParameters")) {
                _logger.LogError("ANSCUSTOMPY::ConfigureParamaters", "Python model missing 'configureParameters' method.", __FILE__, __LINE__);
                return false;
            }
            py::object result;
            try {
                result = model.attr("configureParameters")();
            }
            catch (const py::error_already_set& e) {
                PyErr_Print();
                _logger.LogFatal("ANSCUSTOMPY::ConfigureParamaters", std::string("Exception in 'configureParameters': ") + e.what(), __FILE__, __LINE__);
                return false;
            }

            if (result.is_none()) {
                _logger.LogError("ANSCUSTOMPY::ConfigureParamaters", "Returned None from Python method.", __FILE__, __LINE__);
                return false;
            }

            if (!py::isinstance<py::str>(result)) {
                _logger.LogError("ANSCUSTOMPY::ConfigureParamaters", "Expected Python string return from 'configureParameters'.", __FILE__, __LINE__);
                return false;
            }

            std::string jsonStr = result.cast<std::string>();
            if (jsonStr.empty()) {
                _logger.LogError("ANSCUSTOMPY::ConfigureParamaters", "Empty JSON string returned from Python.", __FILE__, __LINE__);
                return false;
            }

            param = ANSUtilityHelper::ParseCustomParameters(jsonStr);
            return true;
        }
        catch (const py::error_already_set& e) {
            PyErr_Print();
            _logger.LogFatal("ANSCUSTOMPY::ConfigureParamaters", e.what(), __FILE__, __LINE__);
            return false;
        }
        catch (const std::exception& e) {
            _logger.LogFatal("ANSCUSTOMPY::ConfigureParamaters", e.what(), __FILE__, __LINE__);
            return false;
        }
    }

    bool ANSCUSTOMPY::SetParameters(const Params& param) {
        if (!EnsureModelReady("SetParamaters")) return false;
        try {
            std::string jsonStr = CustomParametersToJson(param);
            if (jsonStr.empty()) {
                _logger.LogError("ANSCUSTOMPY::SetParamaters", "Serialized parameter string is empty.", __FILE__, __LINE__);
                return false;
            }
            py::object model = GetThreadLocalModel();
            if (model.is_none()) {
                _logger.LogError("ANSCUSTOMPY::SetParamaters", "Model is None.", __FILE__, __LINE__);
                return false;
            }
            py::gil_scoped_acquire gil;
            if (!py::hasattr(model, "setParameters")) {
                _logger.LogError("ANSCUSTOMPY::SetParamaters", "Python model has no method 'setParameters'.", __FILE__, __LINE__);
                return false;
            }
            py::object result;
            try {
                result = model.attr("setParameters")(jsonStr);
            }
            catch (const py::error_already_set& e) {
                PyErr_Print();
                _logger.LogFatal("ANSCUSTOMPY::SetParamaters", std::string("Exception in 'setParameters': ") + e.what(), __FILE__, __LINE__);
                return false;
            }

            if (result.is_none()) {
                _logger.LogError("ANSCUSTOMPY::SetParamaters", "Python method returned None.", __FILE__, __LINE__);
                return false;
            }

            if (!py::isinstance<py::bool_>(result)) {
                _logger.LogError("ANSCUSTOMPY::SetParamaters", "Python method returned non-boolean type.", __FILE__, __LINE__);
                return false;
            }

            return result.cast<bool>();
        }
        catch (const py::error_already_set& e) {
            PyErr_Print();
            _logger.LogFatal("ANSCUSTOMPY::SetParamaters", std::string("Python error: ") + e.what(), __FILE__, __LINE__);
            return false;
        }
        catch (const std::exception& e) {
            _logger.LogFatal("ANSCUSTOMPY::SetParamaters", e.what(), __FILE__, __LINE__);
            return false;
        }
    }
}