package com.github.mustachejava.reflect;

import com.github.mustachejava.Binding;
import com.github.mustachejava.Code;
import com.github.mustachejava.MustacheException;
import com.github.mustachejava.ObjectHandler;
import com.github.mustachejava.TemplateContext;
import com.github.mustachejava.codes.PartialCode;
import com.github.mustachejava.util.GuardException;
import com.github.mustachejava.util.Wrapper;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import java.util.concurrent.CopyOnWriteArraySet;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.logging.Logger;

/* JADX INFO: loaded from: classes.dex */
public class GuardedBinding implements Binding {
    private final Code code;
    private final String name;
    private final ObjectHandler oh;
    private volatile Wrapper[] prevWrappers;
    private Set<Wrapper> previousSet = new CopyOnWriteArraySet();
    private final TemplateContext tc;
    private static final Wrapper[] EMPTY_WRAPPERS = new Wrapper[0];
    private static Logger logger = Logger.getLogger("mustache");
    private static boolean debug = Boolean.getBoolean("mustache.debug");

    public GuardedBinding(ObjectHandler objectHandler, String str, TemplateContext templateContext, Code code) {
        this.name = str;
        this.code = code;
        this.oh = objectHandler;
        this.tc = templateContext;
    }

    @Override // com.github.mustachejava.Binding
    public Object get(List<Object> list) {
        Wrapper[] wrapperArr = this.prevWrappers;
        if (wrapperArr != null) {
            for (Wrapper wrapper : wrapperArr) {
                try {
                    return this.oh.coerce(wrapper.call(list));
                } catch (MustacheException e) {
                    throw new MustacheException("Failed: " + wrapper, e, this.tc);
                } catch (GuardException unused) {
                }
            }
        }
        return this.createAndGet(list);
    }

    private Object createAndGet(List<Object> list) {
        Wrapper wrapper = getWrapper(this.name, list);
        this.previousSet.add(wrapper);
        if (this.prevWrappers == null || this.prevWrappers.length != this.previousSet.size()) {
            this.prevWrappers = (Wrapper[]) this.previousSet.toArray(EMPTY_WRAPPERS);
        }
        try {
            return this.oh.coerce(wrapper.call(list));
        } catch (GuardException unused) {
            throw new GuardException("BUG: Unexpected guard failure: " + this.name + " " + this.previousSet + " " + Collections.singletonList(list));
        }
    }

    protected synchronized Wrapper getWrapper(String str, List<Object> list) {
        Wrapper wrapperFind;
        wrapperFind = this.oh.find(str, list);
        if ((wrapperFind instanceof MissingWrapper) && debug && !(this.code instanceof PartialCode)) {
            logWarning("Failed to find: ", str, list, this.tc);
        }
        return wrapperFind;
    }

    public static void logWarning(String str, String str2, List<Object> list, TemplateContext templateContext) {
        final StringBuilder sbAppend = new StringBuilder(str).append(str2).append(" (").append(templateContext.file()).append(":").append(templateContext.line()).append(") in");
        list.stream().filter(new Predicate() { // from class: com.github.mustachejava.reflect.GuardedBinding$$ExternalSyntheticLambda0
            @Override // java.util.function.Predicate
            public final boolean test(Object obj) {
                return Objects.nonNull(obj);
            }
        }).forEach(new Consumer() { // from class: com.github.mustachejava.reflect.GuardedBinding$$ExternalSyntheticLambda1
            @Override // java.util.function.Consumer
            public final void accept(Object obj) {
                GuardedBinding.lambda$logWarning$0(sbAppend, obj);
            }
        });
        logger.warning(sbAppend.toString());
    }

    static /* synthetic */ void lambda$logWarning$0(StringBuilder sb, Object obj) {
        Class<?> cls = obj.getClass();
        try {
            try {
                sb.append(" ").append(cls.getSimpleName());
            } catch (Exception unused) {
            }
        } catch (Exception unused2) {
            sb.append(" ").append(cls.getName());
        }
    }
}