package com.vungle.ads.internal.session;

import android.content.Context;
import com.google.android.gms.ads.RequestConfiguration;
import com.vungle.ads.internal.executor.Executors;
import com.vungle.ads.internal.executor.FutureResult;
import com.vungle.ads.internal.model.UnclosedAd;
import com.vungle.ads.internal.util.FileUtility;
import com.vungle.ads.internal.util.Logger;
import com.vungle.ads.internal.util.PathProvider;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.TimeUnit;
import kotlin.Unit;
import kotlin.jvm.functions.Function1;
import kotlin.jvm.internal.DefaultConstructorMarker;
import kotlin.jvm.internal.Intrinsics;
import kotlin.jvm.internal.Reflection;
import kotlin.reflect.KType;
import kotlin.reflect.KTypeProjection;
import kotlinx.serialization.DeserializationStrategy;
import kotlinx.serialization.SerializationStrategy;
import kotlinx.serialization.SerializersKt;
import kotlinx.serialization.StringFormat;
import kotlinx.serialization.json.Json;
import kotlinx.serialization.json.JsonBuilder;
import kotlinx.serialization.json.JsonKt;
import kotlinx.serialization.modules.SerializersModule;

/* loaded from: classes4.dex */
public final class UnclosedAdDetector {
    private static final String FILENAME = "unclosed_ad";
    private final Context context;
    private final Executors executors;
    private File file;
    private final PathProvider pathProvider;
    private final String sessionId;
    private final CopyOnWriteArrayList<UnclosedAd> unclosedAdList;
    public static final Companion Companion = new Companion(null);
    private static final Json json = JsonKt.Json$default((Json) null, new Function1() { // from class: com.vungle.ads.internal.session.UnclosedAdDetector$Companion$json$1
        @Override // kotlin.jvm.functions.Function1
        public /* bridge */ /* synthetic */ Object invoke(Object obj) {
            invoke((JsonBuilder) obj);
            return Unit.INSTANCE;
        }

        public final void invoke(JsonBuilder Json) {
            Intrinsics.checkNotNullParameter(Json, "$this$Json");
            Json.setIgnoreUnknownKeys(true);
            Json.setEncodeDefaults(true);
            Json.setExplicitNulls(false);
            Json.setAllowStructuredMapKeys(true);
        }
    }, 1, (Object) null);

    public final Context getContext() {
        return this.context;
    }

    public final Executors getExecutors() {
        return this.executors;
    }

    public final PathProvider getPathProvider() {
        return this.pathProvider;
    }

    public UnclosedAdDetector(Context context, String sessionId, Executors executors, PathProvider pathProvider) {
        Intrinsics.checkNotNullParameter(context, "context");
        Intrinsics.checkNotNullParameter(sessionId, "sessionId");
        Intrinsics.checkNotNullParameter(executors, "executors");
        Intrinsics.checkNotNullParameter(pathProvider, "pathProvider");
        this.context = context;
        this.sessionId = sessionId;
        this.executors = executors;
        this.pathProvider = pathProvider;
        this.file = pathProvider.getUnclosedAdFile(FILENAME);
        this.unclosedAdList = new CopyOnWriteArrayList<>();
        File file = this.file;
        if (file == null || file.exists()) {
            return;
        }
        this.file.createNewFile();
    }

    public static final class Companion {
        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
            this();
        }

        private Companion() {
        }
    }

    public final void addUnclosedAd(UnclosedAd ad) {
        Intrinsics.checkNotNullParameter(ad, "ad");
        ad.setSessionId(this.sessionId);
        this.unclosedAdList.add(ad);
        writeUnclosedAdToFile(this.unclosedAdList);
    }

    public final void removeUnclosedAd(UnclosedAd ad) {
        Intrinsics.checkNotNullParameter(ad, "ad");
        if (this.unclosedAdList.contains(ad)) {
            this.unclosedAdList.remove(ad);
            writeUnclosedAdToFile(this.unclosedAdList);
        }
    }

    public final List<UnclosedAd> retrieveUnclosedAd() {
        ArrayList arrayList = new ArrayList();
        List<UnclosedAd> readUnclosedAdFromFile = readUnclosedAdFromFile();
        if (readUnclosedAdFromFile != null) {
            arrayList.addAll(readUnclosedAdFromFile);
        }
        this.executors.getIoExecutor().execute(new Runnable() { // from class: com.vungle.ads.internal.session.UnclosedAdDetector$$ExternalSyntheticLambda0
            @Override // java.lang.Runnable
            public final void run() {
                UnclosedAdDetector.m3967retrieveUnclosedAd$lambda1(UnclosedAdDetector.this);
            }
        });
        return arrayList;
    }

    /* JADX INFO: Access modifiers changed from: private */
    /* renamed from: retrieveUnclosedAd$lambda-1, reason: not valid java name */
    public static final void m3967retrieveUnclosedAd$lambda1(UnclosedAdDetector this$0) {
        Intrinsics.checkNotNullParameter(this$0, "this$0");
        try {
            FileUtility.deleteAndLogIfFailed(this$0.file);
        } catch (Exception e) {
            Logger.Companion.e("UnclosedAdDetector", "Fail to delete file " + e.getMessage());
        }
    }

    private final /* synthetic */ <T> T decodeJson(String str) {
        StringFormat stringFormat = json;
        SerializersModule serializersModule = stringFormat.getSerializersModule();
        Intrinsics.reifiedOperationMarker(6, RequestConfiguration.MAX_AD_CONTENT_RATING_T);
        DeserializationStrategy serializer = SerializersKt.serializer(serializersModule, (KType) null);
        Intrinsics.checkNotNull(serializer, "null cannot be cast to non-null type kotlinx.serialization.KSerializer<T of kotlinx.serialization.internal.Platform_commonKt.cast>");
        return (T) stringFormat.decodeFromString(serializer, str);
    }

    private final List<UnclosedAd> readUnclosedAdFromFile() {
        return (List) new FutureResult(this.executors.getIoExecutor().submit(new Callable() { // from class: com.vungle.ads.internal.session.UnclosedAdDetector$$ExternalSyntheticLambda2
            @Override // java.util.concurrent.Callable
            public final Object call() {
                List m3966readUnclosedAdFromFile$lambda2;
                m3966readUnclosedAdFromFile$lambda2 = UnclosedAdDetector.m3966readUnclosedAdFromFile$lambda2(UnclosedAdDetector.this);
                return m3966readUnclosedAdFromFile$lambda2;
            }
        })).get(1000L, TimeUnit.MILLISECONDS);
    }

    /* JADX INFO: Access modifiers changed from: private */
    /* renamed from: readUnclosedAdFromFile$lambda-2, reason: not valid java name */
    public static final List m3966readUnclosedAdFromFile$lambda2(UnclosedAdDetector this$0) {
        List arrayList;
        Intrinsics.checkNotNullParameter(this$0, "this$0");
        try {
            String readString = FileUtility.INSTANCE.readString(this$0.file);
            if (readString != null && readString.length() != 0) {
                StringFormat stringFormat = json;
                DeserializationStrategy serializer = SerializersKt.serializer(stringFormat.getSerializersModule(), Reflection.typeOf(List.class, KTypeProjection.Companion.invariant(Reflection.typeOf(UnclosedAd.class))));
                Intrinsics.checkNotNull(serializer, "null cannot be cast to non-null type kotlinx.serialization.KSerializer<T of kotlinx.serialization.internal.Platform_commonKt.cast>");
                arrayList = (List) stringFormat.decodeFromString(serializer, readString);
                return arrayList;
            }
            arrayList = new ArrayList();
            return arrayList;
        } catch (Exception e) {
            Logger.Companion.e("UnclosedAdDetector", "Fail to read unclosed ad file " + e.getMessage());
            return new ArrayList();
        }
    }

    private final void writeUnclosedAdToFile(List<UnclosedAd> list) {
        try {
            StringFormat stringFormat = json;
            SerializationStrategy serializer = SerializersKt.serializer(stringFormat.getSerializersModule(), Reflection.typeOf(List.class, KTypeProjection.Companion.invariant(Reflection.typeOf(UnclosedAd.class))));
            Intrinsics.checkNotNull(serializer, "null cannot be cast to non-null type kotlinx.serialization.KSerializer<T of kotlinx.serialization.internal.Platform_commonKt.cast>");
            final String encodeToString = stringFormat.encodeToString(serializer, list);
            this.executors.getIoExecutor().execute(new Runnable() { // from class: com.vungle.ads.internal.session.UnclosedAdDetector$$ExternalSyntheticLambda1
                @Override // java.lang.Runnable
                public final void run() {
                    UnclosedAdDetector.m3968writeUnclosedAdToFile$lambda3(UnclosedAdDetector.this, encodeToString);
                }
            });
        } catch (Throwable th) {
            Logger.Companion.e("UnclosedAdDetector", "Fail to write unclosed ad file " + th.getMessage());
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    /* renamed from: writeUnclosedAdToFile$lambda-3, reason: not valid java name */
    public static final void m3968writeUnclosedAdToFile$lambda3(UnclosedAdDetector this$0, String jsonContent) {
        Intrinsics.checkNotNullParameter(this$0, "this$0");
        Intrinsics.checkNotNullParameter(jsonContent, "$jsonContent");
        FileUtility.INSTANCE.writeString(this$0.file, jsonContent);
    }
}