// Copyright (c) 2022 NetEase, Inc. All rights reserved.
// Use of this source code is governed by a MIT license that can be
// found in the LICENSE file.

#include "IMManager.h"

#if defined(_WIN32)
#include <windows.h>
#endif

#include "../NimResult.h"
#include <libopenimsdk.h>
#include "../ZegoDataUtils.h"
#include "ConstDefine.h"


IMManagerService::IMManagerService() {
    m_serviceName = "imManager";

    _im_manager_listener.onInitSdk = [](int state, char *msg) {
        // friend added, handle friendInfo

        flutter::EncodableMap arguments;
        switch (ConstDefine(state)) {
            case ConstDefine::CONNECTING:
                arguments.insert(std::make_pair("type", "onConnecting"));
                arguments.insert(std::make_pair("data", *msg));
                break;
            case ConstDefine::CONNECT_SUCCESS:
                arguments.insert(std::make_pair("type", "onConnectSuccess"));
                arguments.insert(std::make_pair("data", *msg));
                break;
            case ConstDefine::CONNECT_FAILED:
                arguments.insert(std::make_pair("type", "onConnectFailed"));
                arguments.insert(std::make_pair("data", *msg));
                break;
            case ConstDefine::KICKED_OFFLINE:
                arguments.insert(std::make_pair("type", "onKickedOffline"));
                arguments.insert(std::make_pair("data", *msg));
                break;
            case ConstDefine::USER_TOKEN_EXPIRED:
                arguments.insert(std::make_pair("type", "onUserTokenExpired"));
                arguments.insert(std::make_pair("data", *msg));
                break;
            case ConstDefine::USER_TOKEN_INVALID:
                arguments.insert(std::make_pair("type", "onUserTokenExpired"));
                arguments.insert(std::make_pair("data", *msg));
                break;
        }
        notifyEvent("connectListener", arguments);
    };

    _im_manager_listener.baseCallBack = [](char *opid, int errCode, char *errMsg, char *msg) {
        CallBaseCallBack(msg, errCode, errMsg, msg);
    };

    _im_manager_listener.uploadCallback = [](int state, char *msg) {
        // upload progress

        flutter::EncodableMap arguments;
        switch (ConstDefine(state)) {
            case ConstDefine::OPEN:
                arguments.insert(std::make_pair("type", "onConnecting"));
                arguments.insert(std::make_pair("data", *msg));
                break;
            case ConstDefine::PART_SIZE:
                arguments.insert(std::make_pair("type", "onConnectSuccess"));
                arguments.insert(std::make_pair("data", *msg));
                break;
            case ConstDefine::HASH_PART_PROGRESS:
                arguments.insert(std::make_pair("type", "onConnectFailed"));
                arguments.insert(std::make_pair("data", *msg));
                break;
            case ConstDefine::HASH_PART_COMPLETE:
                arguments.insert(std::make_pair("type", "onKickedOffline"));
                arguments.insert(std::make_pair("data", *msg));
                break;
            case ConstDefine::UPLOAD_ID:
                arguments.insert(std::make_pair("type", "onUserTokenExpired"));
                arguments.insert(std::make_pair("data", *msg));
                break;
            case ConstDefine::UPLOAD_PART_COMPLETE:
                arguments.insert(std::make_pair("type", "onUserTokenExpired"));
                arguments.insert(std::make_pair("data", *msg));
                break;
            case ConstDefine::UPLOAD_COMPLETE:
                arguments.insert(std::make_pair("type", "onUserTokenExpired"));
                arguments.insert(std::make_pair("data", *msg));
                break;
            case ConstDefine::COMPLETE:
                arguments.insert(std::make_pair("type", "onUserTokenExpired"));
                arguments.insert(std::make_pair("data", *msg));
                break;
        }
        notifyEvent("uploadFileListener", arguments);
    };
}

void IMManagerService::onMethodCalled(
        const std::string &method, const flutter::EncodableMap *arguments,
        std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (method == "initSDK") {
        initializeSDK(arguments, result);
    } else if (method == "unInitSDK") {
        unInitSDK(arguments, result);
    } else if (method == "login") {
        login(arguments, result);
    } else if (method == "logout") {
        logout(arguments, result);
    } else if (method == "getLoginStatus") {
        getLoginStatus(arguments, result);
    } else if (method == "uploadFile") {
        uploadFile(arguments, result);
    } else if (method == "uploadLogs") {
        uploadLogs(arguments, result);
    } else if (method == "logs") {
        logs(arguments, result);
    } else if (method == "updateFcmToken") {
        updateFcmToken(arguments, result);
    } else if (method == "setAppBackgroundStatus") {
        setAppBackgroundStatus(arguments, result);
    } else if (method == "networkStatusChanged") {
        networkStatusChanged(arguments, result);

    } else {
        result->NotImplemented();
    }
}


void IMManagerService::initializeSDK(
        const flutter::EncodableMap *arguments,
        std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(arguments->at(ZFValue("operationID")));
        char *operationID_cs = const_cast<char *>(operationID.c_str());
        auto config = map_2_json(*arguments);
        char *config_cs = const_cast<char *>(config.c_str());


        auto error = init_sdk(_im_manager_listener.onInitSdk,
                              operationID_cs,
                              config_cs);
        if (error == 0) {
            // handle error
            std::string msg = "IM init failed";
            result->Error("", "",
                          NimResult::getErrorResult(error, ""));
        } else {

            result->Success(EncodableValue(error == 0));
        }
    }
}


void IMManagerService::unInitSDK(
        const flutter::EncodableMap *arguments,
        std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(
                arguments->at(flutter::EncodableValue("operationID")));
        char *operationID_cs = const_cast<char *>(operationID.c_str());

        un_init_sdk(operationID_cs);

    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void IMManagerService::login(
        const flutter::EncodableMap *arguments,
        std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(
                arguments->at(flutter::EncodableValue("operationID")));
        auto userID = zego_value_get_string(arguments->at(flutter::EncodableValue("userID")));
        auto token = zego_value_get_string(arguments->at(flutter::EncodableValue("token")));
        char *operationID_cs = const_cast<char *>(operationID.c_str());
        char *userID_cs = const_cast<char *>(userID.c_str());
        char *token_cs = const_cast<char *>(token.c_str());

        NewBaseCallBack(operationID, result);

        ::login(_im_manager_listener.baseCallBack, operationID_cs, userID_cs, token_cs);

    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void IMManagerService::logout(
        const flutter::EncodableMap *arguments,
        std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(
                arguments->at(flutter::EncodableValue("operationID")));
        char *operationID_cs = const_cast<char *>(operationID.c_str());
        NewBaseCallBack(operationID, result);
        ::logout(_im_manager_listener.baseCallBack, operationID_cs);

    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void IMManagerService::getLoginStatus(
        const flutter::EncodableMap *arguments,
        std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(
                arguments->at(flutter::EncodableValue("operationID")));
        char *operationID_cs = const_cast<char *>(operationID.c_str());

        int status = get_login_status(operationID_cs);
        flutter::EncodableMap statusMap;

        result->Success(flutter::EncodableValue(status));
    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void IMManagerService::uploadFile(
        const flutter::EncodableMap *arguments,
        std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    //	if (arguments) {
    //		auto operationID = zego_value_get_string(arguments->at(flutter::EncodableValue("operationID")));
    //		auto id = zego_value_get_string(arguments->at(flutter::EncodableValue("id")));
    //		auto fileInfo = map_2_json(*arguments);
    //		char* operationID_cs = const_cast<char*>(operationID.c_str());
    //		char* fileInfo_cs = const_cast<char*>(fileInfo.c_str());
    //		uploadFileResult = result;
    //		upload_file(_im_manager_listener.onUploadFile, operationID_cs, fileInfo_cs, _im_manager_listener.uploadCallback);
    //	}
    //	else {
    //		result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    //	}
}

void IMManagerService::uploadLogs(
        const flutter::EncodableMap *arguments,
        std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
//    if (arguments) {
//        auto operationID = zego_value_get_string(
//                arguments->at(flutter::EncodableValue("operationID")));
//        auto line = zego_value_get_int(arguments->at(flutter::EncodableValue("line")));
//        auto ex = zego_value_get_string(arguments->at(flutter::EncodableValue("ex")));
//        char *operationID_cs = const_cast<char *>(operationID.c_str());
//        char *ex_cs = const_cast<char *>(ex.c_str());
//
//        upload_logs(_im_manager_listener.onUploadLogs, operationID_cs, line, ex_cs);
//
//    } else {
//        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
//    }
}

void IMManagerService::logs(
        const flutter::EncodableMap *arguments,
        std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    //	if (arguments) {
    //		auto operationID = zego_value_get_string(arguments->at(flutter::EncodableValue("operationID")));
    //		auto logLevel = zego_value_get_int(arguments->at(flutter::EncodableValue("logLevel")));
    //		auto file = zego_value_get_string(arguments->at(flutter::EncodableValue("file")));
    //		auto line = zego_value_get_int(arguments->at(flutter::EncodableValue("line")));
    //		auto msgs = zego_value_get_string(arguments->at(flutter::EncodableValue("msgs")));
    //		auto err = zego_value_get_string(arguments->at(flutter::EncodableValue("err")));
    //		auto keyAndValue = zego_value_get_string(arguments->at(flutter::EncodableValue("keyAndValue")));
    //		char* operationID_cs = const_cast<char*>(operationID.c_str());
    //		char* file_cs = const_cast<char*>(file.c_str());
    //		char* msgs_cs = const_cast<char*>(msgs.c_str());
    //		char* err_cs = const_cast<char*>(err.c_str());
    //		char* keyAndValue_cs = const_cast<char*>(keyAndValue.c_str());
    //
    //		auto error = logs(_im_manager_listener.onLogs, operationID_cs, logLevel, file_cs, line, msgs_cs, err_cs, keyAndValue_cs);
    //		if (error != 0) {
    //			std::string msg = "Logging failed";
    //			result->Error("", "", NimResult::getErrorResult(error, msg));
    //		}
    //		else {
    //			result->Success(NimResult::getSuccessResult());
    //		}
    //	}
    //	else {
    //		result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    //	}
}

void IMManagerService::updateFcmToken(
        const flutter::EncodableMap *arguments,
        std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (arguments) {
        auto operationID = zego_value_get_string(
                arguments->at(flutter::EncodableValue("operationID")));
        auto fcmToken = zego_value_get_string(arguments->at(flutter::EncodableValue("fcmToken")));
        auto expireTime = zego_value_get_int(arguments->at(flutter::EncodableValue("expireTime")));
        char *operationID_cs = const_cast<char *>(operationID.c_str());
        char *fcmToken_cs = const_cast<char *>(fcmToken.c_str());
        NewBaseCallBack(operationID, result);
        update_fcm_token(_im_manager_listener.baseCallBack, operationID_cs, fcmToken_cs,
                         expireTime);
    } else {
        result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    }
}

void IMManagerService::setAppBackgroundStatus(
        const flutter::EncodableMap *arguments,
        std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    	if (arguments) {
    		auto operationID = zego_value_get_string(arguments->at(flutter::EncodableValue("operationID")));
    		auto isBackground = zego_value_get_bool(arguments->at(flutter::EncodableValue("isBackground")));
    		char* operationID_cs = const_cast<char*>(operationID.c_str());
            NewBaseCallBack(operationID, result);
    		set_app_background_status(_im_manager_listener.baseCallBack, operationID_cs, isBackground);

    	}
    	else {
    		result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    	}
}

void IMManagerService::networkStatusChanged(
        const flutter::EncodableMap *arguments,
        std::shared_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    	if (arguments) {
    		auto operationID = zego_value_get_string(arguments->at(flutter::EncodableValue("operationID")));
    		char* operationID_cs = const_cast<char*>(operationID.c_str());
            NewBaseCallBack(operationID, result);
    		network_status_changed(_im_manager_listener.baseCallBack, operationID_cs);

    	}
    	else {
    		result->Error("INVALID_ARGUMENT", "Arguments cannot be null");
    	}
}