package com.ecpei.widgets.modules;

import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager;
import android.util.Log;

import com.facebook.react.bridge.Arguments;
import com.facebook.react.bridge.Callback;
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.WritableArray;
import com.facebook.react.bridge.WritableMap;
import com.facebook.react.bridge.WritableNativeMap;
import com.facebook.react.modules.core.DeviceEventManagerModule;
import com.facebook.react.uimanager.events.RCTEventEmitter;
import com.xiaomi.mimc.MIMCGroupMessage;
import com.xiaomi.mimc.MIMCMessage;
import com.xiaomi.mimc.MIMCMessageHandler;
import com.xiaomi.mimc.MIMCOnlineStatusListener;
import com.xiaomi.mimc.MIMCRtsCallHandler;
import com.xiaomi.mimc.MIMCServerAck;
import com.xiaomi.mimc.MIMCTokenFetcher;
import com.xiaomi.mimc.MIMCUnlimitedGroupHandler;
import com.xiaomi.mimc.MIMCUser;
import com.xiaomi.mimc.common.MIMCConstant;
import com.xiaomi.mimc.data.LaunchedResponse;
import com.xiaomi.mimc.data.RtsChannelType;
import com.xiaomi.mimc.data.RtsDataType;

import java.io.Console;
import java.util.List;

import static cn.jiguang.imui.chatinput.menu.MenuManager.TAG;

public class CustomServiceModule extends ReactContextBaseJavaModule {
    private final String MODULE_NAME = "CustomServiceModule";

    private MIMCUser mimcUser;
    private String token;

    private static final String RECEIVE_MESSAGE = "scm_receive_message";
    private static final String USER_STATUS = "scm_user_status";

    public CustomServiceModule(ReactApplicationContext reactContext) {
        super(reactContext);
    }

    @Override
    public String getName() {
        return MODULE_NAME;
    }


    @ReactMethod
    public void initIM(ReadableMap map) {
        //配置分享访问秘钥
        ApplicationInfo appInfo = null;
        try {
            String userAccount = "";
            if (map.hasKey("userAccount")) {
                userAccount = map.getString("userAccount");
            }
            appInfo = this.getCurrentActivity().getPackageManager().getApplicationInfo(this.getCurrentActivity().getPackageName(), PackageManager.GET_META_DATA);
            long appid = Long.parseLong(appInfo.metaData.getString("MI_APPID").replace("appid_", ""));
            mimcUser = MIMCUser.newInstance(appid, userAccount, this.getCurrentActivity().getApplication().getExternalCacheDir().getPath());
            mimcUser.registerTokenFetcher(new MIMCTokenFetcher() {
                @Override
                public String fetchToken() throws Exception {
                    return token;
//                    if (mimcUser != null)
//                        return mimcUser.getToken();
//                    else
//                        return null;
                }
            });
            mimcUser.registerOnlineStatusListener(new MIMCOnlineStatusListener() {
                /**
                 * @param[status]: 登录状态，ONLINE 在线，OFFLINE 离线
                 * @param[errType]: 状态改变错误码
                 * @param[errReason]: 状态改变错误原因
                 * @param[errDescription]: 状态改变错误描述
                 */
                @Override
                public void statusChange(MIMCConstant.OnlineStatus onlineStatus, String s, String s1, String s2) {
                    Log.w(TAG, "statusChange: " + onlineStatus);
                    getReactApplicationContext().getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
                            .emit(USER_STATUS, onlineStatus == MIMCConstant.OnlineStatus.ONLINE ? 1 : 0);
                }
            });
            mimcUser.registerMessageHandler(new MIMCMessageHandler() {
                @Override
                public void handleMessage(List<MIMCMessage> list) {
                    WritableArray array = Arguments.createArray();
                    for (int i = 0; i < list.size(); ++i) {
                        MIMCMessage mimcMessage = list.get(i);
                        WritableMap map = new WritableNativeMap();
                        map.putString("sequence", String.valueOf(mimcMessage.getSequence()));
                        map.putString("fromAccount", mimcMessage.getFromAccount());
                        map.putString("toAccount", mimcMessage.getToAccount());
                        map.putString("payload", new String(mimcMessage.getPayload()));
                        map.putString("bizType", mimcMessage.getBizType());
                        array.pushMap(map);
//                            Msg msg = JSON.parseObject(new String(mimcMessage.getPayload()), Msg.class);
//                            ChatMsg chatMsg = new ChatMsg();
//                            chatMsg.setBizType(mimcMessage.getBizType());
//                            chatMsg.setFromAccount(mimcMessage.getFromAccount());
//                            chatMsg.setMsg(msg);
//                            chatMsg.setSingle(true);
//                            addMsg(chatMsg);
                    }
//                    event.putString("message", message.toString());
                    getReactApplicationContext().getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
                            .emit(RECEIVE_MESSAGE, array);
//                    reactContext.getJSModule(RCTEventEmitter.class).receiveEvent(rootView.getId(), ON_MSG_CLICK_EVENT, event);
                }

                @Override
                public void handleGroupMessage(List<MIMCGroupMessage> list) {

                }

                @Override
                public void handleUnlimitedGroupMessage(List<MIMCGroupMessage> list) {

                }

                @Override
                public void handleServerAck(MIMCServerAck mimcServerAck) {

                }

                @Override
                public void handleSendMessageTimeout(MIMCMessage mimcMessage) {

                }

                @Override
                public void handleSendGroupMessageTimeout(MIMCGroupMessage mimcGroupMessage) {

                }

                @Override
                public void handleSendUnlimitedGroupMessageTimeout(MIMCGroupMessage mimcGroupMessage) {

                }
            });
            mimcUser.registerUnlimitedGroupHandler(new MIMCUnlimitedGroupHandler() {
                @Override
                public void handleCreateUnlimitedGroup(long l, String s, boolean b, String s1, Object o) {

                }

                @Override
                public void handleJoinUnlimitedGroup(long l, int i, String s, Object o) {

                }

                @Override
                public void handleQuitUnlimitedGroup(long l, int i, String s, Object o) {

                }

                @Override
                public void handleDismissUnlimitedGroup(long l, int i, String s, Object o) {

                }
            });
            mimcUser.registerRtsCallHandler(new MIMCRtsCallHandler() {
                @Override
                public LaunchedResponse onLaunched(String s, String s1, long l, byte[] bytes) {
                    return null;
                }

                @Override
                public void onAnswered(long l, boolean b, String s) {

                }

                @Override
                public void onClosed(long l, String s) {

                }

                @Override
                public void handleData(long l, byte[] bytes, RtsDataType rtsDataType, RtsChannelType rtsChannelType) {

                }

                @Override
                public void handleSendDataSuccess(long l, int i, Object o) {

                }

                @Override
                public void handleSendDataFail(long l, int i, Object o) {

                }
            });
        } catch (PackageManager.NameNotFoundException e) {
            e.printStackTrace();
        } catch (NumberFormatException ex) {
            ex.printStackTrace();
        }
    }


    @ReactMethod
    public void login() {
        if (mimcUser != null)
            mimcUser.login();
    }

    @ReactMethod
    public void logout() {
        if (mimcUser != null)
            mimcUser.logout();
    }

    @ReactMethod
    public void setToken(String token) {
        this.token = token;
    }

    @ReactMethod
    public void getToken(Callback callback) {
        if (mimcUser != null)
            callback.invoke(mimcUser.getToken());
    }

    @ReactMethod
    public void sendMessage(String userAccount, String payload, String bizType, Callback callback) {
        if (mimcUser != null) {
            String result = mimcUser.sendMessage(userAccount, payload.getBytes(), bizType);
            if (result != null) {
                callback.invoke(result);
            } else {
                callback.invoke("");
            }
        }
    }

    @ReactMethod
    public void getOnlineStatus(Callback callback) {
        if (mimcUser != null) {
            callback.invoke(mimcUser.getOnlineStatus() == MIMCConstant.OnlineStatus.ONLINE ? 1 : 0);
        } else
            callback.invoke(0);
    }

}