package com.ifpdos.udi.sdk.localhttpd;

import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.util.Log;
import com.ifpdos.sdk.httpd.binder.aidl.RequestLine;
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 g.a.a.a.a;
import g.e.b.f0.b;
import g.e.b.j;
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.MediaType;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;
import okhttp3.ResponseBody;
import okhttp3.n0.c;
import okhttp3.n0.connection.RealCall;

/* 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 OkHttpClient mOkHttpClient;
    private final Thread mSseThread;
    private static final MediaType MEDIA_TYPE_JSON = MediaType.c("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 responseBody = response.f9647r;
            if (responseBody == null) {
                return;
            }
            try {
                String strG = responseBody.g();
                if (strG == null || strG.isEmpty() || !UdiSdk.isDebug()) {
                    return;
                }
                Log.d("UdiSdk", call.getF9770m().a + " response : " + response.f9644o + ", " + strG);
            } 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 responseBody = response.f9647r;
            if (responseBody == null) {
                return;
            }
            try {
                AddEventResponse addEventResponse = (AddEventResponse) LocalSocketEventHelper.this.mGson.b(responseBody.g(), 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.f9644o != 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 j mGson = new j();
    private final Set<IEventHandler> mAllEventHandler = new HashSet();
    private String mSseId = null;
    private int mRetryLimit = DEFAULT_RETRY_LIMIT;
    private final Handler mHandler = new RetryHandler(Looper.getMainLooper());
    private final Map<String, Integer> mEventToRetry = new ConcurrentHashMap();

    public static class EventRequest {

        @b("events")
        public Set<String> events;

        @b("uuid")
        public String uuid;

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

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

        public 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) {
        OkHttpClient.a aVarNewOkHttpClientBuilder = UdiSdk.newOkHttpClientBuilder();
        aVarNewOkHttpClientBuilder.d(2147483647L, TimeUnit.MILLISECONDS);
        this.mOkHttpClient = new OkHttpClient(aVarNewOkHttpClientBuilder);
        this.mSseThread = 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) {
                    LocalSocketEventHelper.this.mHandler.post(new Runnable() { // from class: com.ifpdos.udi.sdk.localhttpd.LocalSocketEventHelper.3.1
                        @Override // java.lang.Runnable
                        public void run() {
                            iConnectCallback.onDisconnect(e2);
                        }
                    });
                }
            }
        });
    }

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

    private synchronized void dispatchEvent(Map<String, String> map) {
        if (map == null) {
            return;
        }
        String str = map.get(EVENT_EVENT_PART);
        String str2 = map.get(EVENT_DATA_PART);
        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);
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void doSseConnect(IConnectCallback iConnectCallback) {
        Log.d("UdiSdk", "start connect sse");
        String str = SUBSCRIBE_URI_PREFIX + getSseId();
        Request.a aVar = new Request.a();
        aVar.f(UdiSdk.getFullUrl(str));
        aVar.c(RequestLine.METHOD_GET, null);
        Request requestA = aVar.a();
        ResponseBody responseBodyTryCreateSseConnect = tryCreateSseConnect(requestA);
        int i2 = 0;
        while (responseBodyTryCreateSseConnect == null) {
            i2++;
            a.c0("retry connect sse, time ", i2, "UdiSdk");
            try {
                Thread.sleep(1000L);
            } catch (InterruptedException unused) {
            }
            responseBodyTryCreateSseConnect = tryCreateSseConnect(requestA);
            if (responseBodyTryCreateSseConnect == null && i2 >= this.mRetryLimit) {
                if (iConnectCallback != null) {
                    iConnectCallback.onFailed();
                    return;
                }
                return;
            }
        }
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(responseBodyTryCreateSseConnect.getF9836o().w()));
        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("*")) {
            return this.mAllEventHandler;
        }
        if (!this.mEventMap.containsKey(str)) {
            this.mEventMap.put(str, new HashSet());
        }
        return this.mEventMap.get(str);
    }

    private synchronized String getSseId() {
        if (this.mSseId == null) {
            this.mSseId = createSubscribeSseId();
        }
        return this.mSseId;
    }

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

    private Map<String, String> readEvent(BufferedReader bufferedReader) throws IOException {
        int iIndexOf;
        HashMap map = new HashMap();
        String line = bufferedReader.readLine();
        if (line == null) {
            throw new IOException("sse 连接已断开");
        }
        loop0: while (true) {
            printSseData(line);
            while (line != null && !line.isEmpty()) {
                iIndexOf = line.indexOf(EVENT_SEPARATOR);
                if (iIndexOf <= 0) {
                }
            }
            map.put(line.substring(0, iIndexOf).trim(), line.substring(iIndexOf + 1).trim());
            line = bufferedReader.readLine();
        }
        if (map.containsKey(EVENT_EVENT_PART) && map.containsKey(EVENT_DATA_PART)) {
            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.a aVar = new Request.a();
        aVar.f(UdiSdk.getFullUrl(URI_EVENTS_ADD));
        aVar.d(RequestBody.create(MEDIA_TYPE_JSON, this.mGson.g(eventRequest)));
        Request requestA = aVar.a();
        if (UdiSdk.isDebug()) {
            Log.d("UdiSdk", eventRequest.uuid + " listener event:");
            Iterator<String> it = eventRequest.events.iterator();
            while (it.hasNext()) {
                Log.d("UdiSdk", it.next());
            }
        }
        ((RealCall) this.mOkHttpClient.b(requestA)).i(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());
            }
        }
        Request.a aVar = new Request.a();
        aVar.f(UdiSdk.getFullUrl(URI_EVENTS_REMOVE));
        aVar.d(RequestBody.create(MEDIA_TYPE_JSON, this.mGson.g(eventRequest)));
        ((RealCall) this.mOkHttpClient.b(aVar.a())).i(EMPTY_CALLBACK);
    }

    private ResponseBody tryCreateSseConnect(Request request) {
        try {
            return ((RealCall) this.mOkHttpClient.b(request)).j().f9647r;
        } catch (Exception unused) {
            return null;
        }
    }

    @Override // com.ifpdos.udi.sdk.IEventHelper
    public void destroy() {
        if (this.mSseId != null) {
            StringBuilder sbF = a.F(SUBSCRIBE_URI_PREFIX);
            sbF.append(getSseId());
            String string = sbF.toString();
            Request.a aVar = new Request.a();
            aVar.f(UdiSdk.getFullUrl(string));
            aVar.c("DELETE", c.f9714d);
            ((RealCall) this.mOkHttpClient.b(aVar.a())).i(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) {
        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);
        }
    }

    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 void start() {
        this.mSseThread.start();
    }

    @Override // com.ifpdos.udi.sdk.IEventHelper
    public synchronized void unregisterEvents(IEventHandler iEventHandler) {
        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("*");
        }
        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);
    }

    @Override // com.ifpdos.udi.sdk.IEventHelper
    public synchronized void unregisterEvents(Set<String> set, IEventHandler iEventHandler) {
        HashSet hashSet = new HashSet();
        for (String str : set) {
            this.mEventToRetry.remove(str);
            if (!str.equals("*")) {
                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);
    }
}