package com.ifpdos.udi.sdk.localhttpd;

import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.util.Log;
import com.google.gson.Gson;
import com.google.gson.annotations.SerializedName;
import com.ifpdos.udi.sdk.AddEventResponse;
import com.ifpdos.udi.sdk.IConnectCallback;
import com.ifpdos.udi.sdk.IEventHandler;
import com.ifpdos.udi.sdk.IEventHelper;
import com.ifpdos.udi.sdk.UdiSdk;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;
import okhttp3.Call;
import okhttp3.Callback;
import okhttp3.HttpUrl;
import okhttp3.MediaType;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;
import okhttp3.ResponseBody;

/* JADX INFO: loaded from: classes.dex */
public class LocalSocketEventHelper implements IEventHelper {
    private static final String ALL_EVENT_FILTER = "*";
    private static final int DEFAULT_RETRY_LIMIT = 180;
    private static final String EVENT_DATA_PART = "data";
    private static final String EVENT_EVENT_PART = "event";
    private static final String EVENT_SEPARATOR = ":";
    private static final int RETRY_DELAY = 1000;
    private static final String SUBSCRIBE_URI_PREFIX = "/v1/udi/events/subscribe/";
    private static final String URI_EVENTS_ADD = "/v1/udi/events/add";
    private static final String URI_EVENTS_REMOVE = "/v1/udi/events/remove";
    private final Thread mSseThread;
    private static final MediaType MEDIA_TYPE_JSON = MediaType.parse("application/json; charset=utf-8");
    private static final Callback EMPTY_CALLBACK = new Callback() { // from class: com.ifpdos.udi.sdk.localhttpd.LocalSocketEventHelper.1
        @Override // okhttp3.Callback
        public void onFailure(Call call, IOException iOException) {
        }

        @Override // okhttp3.Callback
        public void onResponse(Call call, Response response) {
            ResponseBody responseBodyBody = response.body();
            if (responseBodyBody == null) {
                return;
            }
            try {
                String strString = responseBodyBody.string();
                if (strString == null || strString.isEmpty() || !UdiSdk.isDebug()) {
                    return;
                }
                Log.d("UdiSdk", call.request().url() + " response : " + response.code() + ", " + strString);
            } catch (IOException e2) {
                Log.e("UdiSdk", "read body failed", e2);
            }
        }
    };
    private final Callback mAddEventCallback = new Callback() { // from class: com.ifpdos.udi.sdk.localhttpd.LocalSocketEventHelper.2
        @Override // okhttp3.Callback
        public void onFailure(Call call, IOException iOException) {
        }

        @Override // okhttp3.Callback
        public void onResponse(Call call, Response response) {
            List<String> list;
            ResponseBody responseBodyBody = response.body();
            if (responseBodyBody == null) {
                return;
            }
            try {
                AddEventResponse addEventResponse = (AddEventResponse) LocalSocketEventHelper.this.mGson.fromJson(responseBodyBody.string(), AddEventResponse.class);
                if (addEventResponse == null) {
                    return;
                }
                List<String> list2 = addEventResponse.success;
                if (list2 != null) {
                    Iterator<String> it = list2.iterator();
                    while (it.hasNext()) {
                        LocalSocketEventHelper.this.mEventToRetry.remove(it.next());
                    }
                }
                if (response.code() != 503 || (list = addEventResponse.retry) == null || list.isEmpty()) {
                    return;
                }
                LocalSocketEventHelper.this.retryAddEvent(addEventResponse.retry);
            } catch (Throwable th) {
                Log.e("UdiSdk", "read body failed", th);
            }
        }
    };
    private final Map<String, Set<IEventHandler>> mEventMap = new HashMap();
    private final Map<IEventHandler, Set<String>> mHandlerMap = new HashMap();
    private final Gson mGson = new Gson();
    private final Set<IEventHandler> mAllEventHandler = new HashSet();
    private String mSseId = null;
    private int mRetryLimit = 180;
    private final Handler mHandler = new RetryHandler(Looper.getMainLooper());
    private final Map<String, Integer> mEventToRetry = new ConcurrentHashMap();
    private final OkHttpClient mOkHttpClient = UdiSdk.newOkHttpClientBuilder().readTimeout(2147483647L, TimeUnit.MILLISECONDS).build();

    private static class EventRequest {

        @SerializedName("events")
        Set<String> events;

        @SerializedName("uuid")
        String uuid;

        EventRequest(String str, Set<String> set) {
            this.uuid = str;
            this.events = set;
        }
    }

    private class RetryHandler extends Handler {
        static final int MSG_RETRY_ADD_EVENT = 1;

        RetryHandler(Looper looper) {
            super(looper);
        }

        @Override // android.os.Handler
        public void handleMessage(Message message) {
            super.handleMessage(message);
            if (message.what == 1) {
                Log.d("UdiSdk", "retry add event");
                LocalSocketEventHelper localSocketEventHelper = LocalSocketEventHelper.this;
                localSocketEventHelper.sendAddEventRequest(localSocketEventHelper.mEventToRetry.keySet());
            }
        }
    }

    public LocalSocketEventHelper(final IConnectCallback iConnectCallback) {
        Thread thread = new Thread(new Runnable() { // from class: com.ifpdos.udi.sdk.localhttpd.LocalSocketEventHelper.3
            @Override // java.lang.Runnable
            public void run() {
                try {
                    LocalSocketEventHelper.this.doSseConnect(iConnectCallback);
                } catch (IOException e2) {
                    iConnectCallback.onDisconnect(e2);
                }
            }
        });
        this.mSseThread = thread;
        thread.start();
    }

    private synchronized String createSubscribeSseId() {
        return UUID.randomUUID().toString().replaceAll("-", HttpUrl.FRAGMENT_ENCODE_SET);
    }

    private synchronized void dispatchEvent(Map<String, String> map) {
        if (map == null) {
            return;
        }
        try {
            String str = map.get("event");
            String str2 = map.get("data");
            Set<IEventHandler> set = this.mEventMap.get(str);
            if (set != null && !set.isEmpty()) {
                Iterator<IEventHandler> it = set.iterator();
                while (it.hasNext()) {
                    it.next().onEvent(str, str2);
                }
            }
            Iterator<IEventHandler> it2 = this.mAllEventHandler.iterator();
            while (it2.hasNext()) {
                it2.next().onEvent(str, str2);
            }
        } catch (Throwable th) {
            throw th;
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void doSseConnect(IConnectCallback iConnectCallback) throws IOException {
        Log.d("UdiSdk", "start connect sse");
        Request requestBuild = new Request.Builder().url(UdiSdk.getFullUrl(SUBSCRIBE_URI_PREFIX + getSseId())).get().build();
        ResponseBody responseBodyTryCreateSseConnect = tryCreateSseConnect(requestBuild);
        int i2 = 0;
        while (responseBodyTryCreateSseConnect == null) {
            i2++;
            Log.d("UdiSdk", "retry connect sse, time " + i2);
            try {
                Thread.sleep(1000L);
            } catch (InterruptedException unused) {
            }
            responseBodyTryCreateSseConnect = tryCreateSseConnect(requestBuild);
            if (responseBodyTryCreateSseConnect == null && i2 >= this.mRetryLimit) {
                if (iConnectCallback != null) {
                    iConnectCallback.onFailed();
                    return;
                }
                return;
            }
        }
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(responseBodyTryCreateSseConnect.byteStream()));
        if (iConnectCallback != null) {
            iConnectCallback.onSuccess();
        }
        while (this.mSseId != null) {
            dispatchEvent(readEvent(bufferedReader));
        }
    }

    private Set<String> getEventsForHandler(IEventHandler iEventHandler) {
        if (!this.mHandlerMap.containsKey(iEventHandler)) {
            this.mHandlerMap.put(iEventHandler, new HashSet());
        }
        return this.mHandlerMap.get(iEventHandler);
    }

    private Set<IEventHandler> getHandlersForEvent(String str) {
        if (str.equals(ALL_EVENT_FILTER)) {
            return this.mAllEventHandler;
        }
        if (!this.mEventMap.containsKey(str)) {
            this.mEventMap.put(str, new HashSet());
        }
        return this.mEventMap.get(str);
    }

    private synchronized String getSseId() {
        try {
            if (this.mSseId == null) {
                this.mSseId = createSubscribeSseId();
            }
        } catch (Throwable th) {
            throw th;
        }
        return this.mSseId;
    }

    private void printSseData(String str) {
        if (UdiSdk.isDebug()) {
            Log.d("UdiSdk", "read sse data: " + str);
        }
    }

    private Map<String, String> readEvent(BufferedReader bufferedReader) throws IOException {
        HashMap map = new HashMap();
        String line = bufferedReader.readLine();
        if (line == null) {
            throw new IOException("sse 连接已断开");
        }
        printSseData(line);
        while (line != null && !line.isEmpty()) {
            int iIndexOf = line.indexOf(EVENT_SEPARATOR);
            if (iIndexOf > 0) {
                map.put(line.substring(0, iIndexOf).trim(), line.substring(iIndexOf + 1).trim());
                line = bufferedReader.readLine();
                printSseData(line);
            }
        }
        if (map.containsKey("event") && map.containsKey("data")) {
            return map;
        }
        return null;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void retryAddEvent(List<String> list) {
        Iterator<Map.Entry<String, Integer>> it = this.mEventToRetry.entrySet().iterator();
        for (String str : list) {
            if (!this.mEventToRetry.containsKey(str)) {
                this.mEventToRetry.put(str, 0);
            }
        }
        while (it.hasNext()) {
            Map.Entry<String, Integer> next = it.next();
            if (next.getValue().intValue() > this.mRetryLimit) {
                Log.d("UdiSdk", next.getKey() + " add failed, retry " + this.mRetryLimit + " times");
                it.remove();
            } else {
                next.setValue(Integer.valueOf(next.getValue().intValue() + 1));
            }
        }
        this.mHandler.removeMessages(1);
        this.mHandler.sendEmptyMessageDelayed(1, 1000L);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void sendAddEventRequest(Set<String> set) {
        EventRequest eventRequest = new EventRequest(getSseId(), set);
        Request requestBuild = new Request.Builder().url(UdiSdk.getFullUrl(URI_EVENTS_ADD)).post(RequestBody.create(MEDIA_TYPE_JSON, this.mGson.toJson(eventRequest))).build();
        if (UdiSdk.isDebug()) {
            Log.d("UdiSdk", eventRequest.uuid + " listener event:");
            Iterator<String> it = eventRequest.events.iterator();
            while (it.hasNext()) {
                Log.d("UdiSdk", it.next());
            }
        }
        this.mOkHttpClient.newCall(requestBuild).enqueue(this.mAddEventCallback);
    }

    private void sendRemoveEventRequest(Set<String> set) {
        if (set.isEmpty()) {
            return;
        }
        EventRequest eventRequest = new EventRequest(getSseId(), set);
        if (UdiSdk.isDebug()) {
            Log.d("UdiSdk", eventRequest.uuid + " listener event:");
            Iterator<String> it = eventRequest.events.iterator();
            while (it.hasNext()) {
                Log.d("UdiSdk", it.next());
            }
        }
        this.mOkHttpClient.newCall(new Request.Builder().url(UdiSdk.getFullUrl(URI_EVENTS_REMOVE)).post(RequestBody.create(MEDIA_TYPE_JSON, this.mGson.toJson(eventRequest))).build()).enqueue(EMPTY_CALLBACK);
    }

    private ResponseBody tryCreateSseConnect(Request request) {
        try {
            return this.mOkHttpClient.newCall(request).execute().body();
        } catch (Exception unused) {
            return null;
        }
    }

    @Override // com.ifpdos.udi.sdk.IEventHelper
    public void destroy() {
        if (this.mSseId != null) {
            this.mOkHttpClient.newCall(new Request.Builder().url(UdiSdk.getFullUrl(SUBSCRIBE_URI_PREFIX + getSseId())).delete().build()).enqueue(EMPTY_CALLBACK);
            this.mSseId = null;
            try {
                this.mSseThread.join();
            } catch (InterruptedException unused) {
            }
        }
    }

    @Override // com.ifpdos.udi.sdk.IEventHelper
    public Map<IEventHandler, Set<String>> getHandlerMap() {
        return this.mHandlerMap;
    }

    @Override // com.ifpdos.udi.sdk.IEventHelper
    public synchronized void registerEvents(Set<String> set, IEventHandler iEventHandler) {
        try {
            if (set.isEmpty()) {
                return;
            }
            HashSet hashSet = new HashSet();
            getEventsForHandler(iEventHandler).addAll(set);
            for (String str : set) {
                Set<IEventHandler> handlersForEvent = getHandlersForEvent(str);
                if (handlersForEvent.isEmpty()) {
                    hashSet.add(str);
                }
                handlersForEvent.add(iEventHandler);
            }
            if (!hashSet.isEmpty()) {
                sendAddEventRequest(hashSet);
            }
        } catch (Throwable th) {
            throw th;
        }
    }

    public void setRetryLimit(int i2) {
        this.mRetryLimit = i2;
    }

    @Override // com.ifpdos.udi.sdk.IEventHelper
    public void setToken(String str) {
    }

    @Override // com.ifpdos.udi.sdk.IEventHelper
    public synchronized void unregisterEvents(Set<String> set, IEventHandler iEventHandler) {
        try {
            HashSet hashSet = new HashSet();
            for (String str : set) {
                this.mEventToRetry.remove(str);
                if (!str.equals(ALL_EVENT_FILTER)) {
                    Set<IEventHandler> set2 = this.mEventMap.get(str);
                    if (set2 != null && set2.contains(iEventHandler)) {
                        set2.remove(iEventHandler);
                        if (set2.isEmpty()) {
                            hashSet.add(str);
                        }
                    }
                } else if (this.mAllEventHandler.contains(iEventHandler)) {
                    this.mAllEventHandler.remove(iEventHandler);
                    hashSet.add(str);
                }
            }
            Set<String> set3 = this.mHandlerMap.get(iEventHandler);
            if (set3 != null) {
                set3.removeAll(set);
                if (set3.isEmpty()) {
                    this.mHandlerMap.remove(iEventHandler);
                }
            }
            sendRemoveEventRequest(hashSet);
        } catch (Throwable th) {
            throw th;
        }
    }

    @Override // com.ifpdos.udi.sdk.IEventHelper
    public synchronized void unregisterEvents(IEventHandler iEventHandler) {
        try {
            Set<String> hashSet = this.mHandlerMap.get(iEventHandler);
            this.mHandlerMap.remove(iEventHandler);
            if (this.mAllEventHandler.contains(iEventHandler)) {
                this.mAllEventHandler.remove(iEventHandler);
                if (hashSet == null) {
                    hashSet = new HashSet<>();
                }
                hashSet.add(ALL_EVENT_FILTER);
            }
            if (hashSet == null) {
                return;
            }
            HashSet hashSet2 = new HashSet();
            for (String str : hashSet) {
                Set<IEventHandler> set = this.mEventMap.get(str);
                if (set != null) {
                    set.remove(iEventHandler);
                    if (set.isEmpty()) {
                        hashSet2.add(str);
                    }
                }
            }
            sendRemoveEventRequest(hashSet2);
        } catch (Throwable th) {
            throw th;
        }
    }
}