
package com.trustdevice;

import androidx.annotation.NonNull;

import com.facebook.react.bridge.Promise;
import com.facebook.react.bridge.ReactApplicationContext;
import com.facebook.react.bridge.ReactContextBaseJavaModule;
import com.facebook.react.bridge.ReactMethod;
import com.facebook.react.bridge.ReadableMap;
import com.facebook.react.bridge.WritableMap;
import com.facebook.react.bridge.Arguments; 
import com.trustdevice.utils.TDUniRiskUtils;

import java.util.HashMap;

import com.trustdecision.mobrisk.TDRisk;
import com.trustdecision.mobrisk.TDRiskCallback;
import com.trustdecision.mobrisk.TDAPISignResult;
import com.trustdecision.mobrisk.TDBehaviorResult;
import com.trustdecision.mobrisk.TDDeviceInfo;
import com.trustdecision.mobrisk.TDDeviceInfoCallbackAdapter;
import com.trustdecision.mobrisk.TDDeviceAPIStatus;

public class TrustdeviceModule extends ReactContextBaseJavaModule {
    private final ReactApplicationContext reactContext;

    public TrustdeviceModule(ReactApplicationContext reactContext) {
        super(reactContext);
        this.reactContext = reactContext;
    }

    @NonNull
    @Override
    public String getName() {
        return "TrustDevice";
    }

    @ReactMethod
    public void initWithOptions(ReadableMap readableMap, Promise promise) {
        if (readableMap == null) {
            promise.reject("initWithOptions Error", "options must not be null");
            return;
        }

        try {
            HashMap<String, Object> options = readableMap.toHashMap();
            TDRisk.Builder builder = TDUniRiskUtils.mapToBuilder(options);
            TDRisk.initWithOptions(this.reactContext.getApplicationContext(), builder);
            promise.resolve(null);
        } catch (Exception e) {
            promise.reject("initWithOptions Error", e);
        }
    }

    @ReactMethod
    public void getBlackBox(Promise promise) {
        try {
            String blackBox = TDRisk.getBlackBox();
            promise.resolve(blackBox);
        } catch (Exception e) {
            promise.reject("getBlackBox Error", e);
        }
    }

    @ReactMethod
    public void getBlackBoxAsync(Promise promise) {
        try {
            TDRisk.getBlackBoxAsync(new TDRiskCallback() {
                @Override
                public void onEvent(String blackbox) {
                    promise.resolve(blackbox);
                }
            });
        } catch (Exception e) {
            promise.reject("getBlackBoxAsync Error", e);
        }
    }

    private WritableMap deviceInfoResult(TDDeviceInfo info) {
        WritableMap result = Arguments.createMap();
        TDDeviceAPIStatus status = info.getApiStatus();
        int code = status == null ? -1 : status.getCode();
        String message = status == null ? "SDK returned no API status" : status.getMessage();
        WritableMap apiStatus = Arguments.createMap();
        apiStatus.putInt("code", code);
        apiStatus.putString("message", message);
        result.putString("blackBox", info.getBlackBox());
        result.putString("fpVersion", info.getFpVersion());
        result.putString("anonymousId", info.getAnonymousId());
        result.putInt("deviceRiskScore", info.getDeviceRiskScore());
        result.putString("sealedResult", info.getSealedResult());
        result.putMap("apiStatus", apiStatus);
        result.putInt("code", code);
        result.putString("msg", message);
        return result;
    }

    @ReactMethod
    public void getDeviceInfo(Promise promise) {
        new Thread(() -> {
            try {
                TDDeviceInfo info = TDRisk.getDeviceInfo();
                if (info == null) {
                    promise.reject("device_info_unavailable", "SDK returned null device info");
                } else {
                    promise.resolve(deviceInfoResult(info));
                }
            } catch (Exception e) {
                promise.reject("getDeviceInfo Error", e);
            }
        }, "TrustDevice-getDeviceInfo").start();
    }

    @ReactMethod
    public void getDeviceInfoAsync(Promise promise) {
        try {
            TDRisk.getDeviceInfo(new TDDeviceInfoCallbackAdapter() {
                @Override
                public void onResult(TDDeviceInfo info) {
                    if (info == null) {
                        promise.reject("device_info_unavailable", "SDK returned null device info");
                    } else {
                        promise.resolve(deviceInfoResult(info));
                    }
                }
            });
        } catch (Exception e) {
            promise.reject("getDeviceInfoAsync Error", e);
        }
    }

    @ReactMethod
    public void showCaptcha(Promise promise) {
        TrustdeviceUiBridge.showCaptcha(reactContext, "TrustDeviceCaptcha", promise);
    }

    @ReactMethod
    public void showLiveness(ReadableMap options, Promise promise) {
        TrustdeviceUiBridge.showLiveness(reactContext, options, promise);
    }

    @ReactMethod
    public void sign(String path, Promise promise) {
        try {
            TDAPISignResult signResult = TDRisk.sign(this.reactContext.getApplicationContext(), path);
            // 创建 WritableMap 来返回结构化数据
            WritableMap resultMap = Arguments.createMap();
            resultMap.putString("sign", signResult.signature());
            resultMap.putInt("code", signResult.code());
            resultMap.putString("msg", signResult.message());
            
            promise.resolve(resultMap);
            
        } catch (Exception e) {
            promise.reject("sign Error", e);
        }
    }

    @ReactMethod
    public void start(Promise promise) {
        try {
            TDRisk.start();
            promise.resolve(null);
        } catch (Exception e) {
            promise.reject("behaviorStart Error", e);
        }
    }

    @ReactMethod
    public void stop(Promise promise) {
        try {
            TDRisk.stop();
            promise.resolve(null);
        } catch (Exception e) {
            promise.reject("behaviorStop Error", e);
        }
    }

    @ReactMethod
    public void collect(Promise promise) {
        try {
            TDBehaviorResult behaviorResult = TDRisk.collect();
            WritableMap resultMap = Arguments.createMap();
            resultMap.putInt("code", behaviorResult.code());
            resultMap.putString("payload", behaviorResult.payload());
            resultMap.putString("msg", behaviorResult.msg());
            promise.resolve(resultMap);
        } catch (Exception e) {
            promise.reject("behaviorCollect Error", e);
        }
    }

    @ReactMethod
    public void getSDKVersion(Promise promise) {
        String sdkVersion = TDRisk.getSDKVersion();
        promise.resolve(sdkVersion);
    }
}
