package com.github.mustachejava;

import com.github.mustachejava.codes.PartialCode;
import com.github.mustachejava.util.GuardException;
import com.github.mustachejava.util.InternalArrayList;
import com.github.mustachejava.util.Wrapper;
import com.seewo.vcommons.utils.ShellCommandUtils;
import java.io.File;
import java.io.IOException;
import java.io.StringWriter;
import java.io.Writer;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.Future;
import java.util.concurrent.atomic.AtomicLong;

/* JADX INFO: loaded from: classes.dex */
public class DeferringMustacheFactory extends DefaultMustacheFactory {
    public static final Object DEFERRED = new Object();

    public DeferringMustacheFactory() {
    }

    public DeferringMustacheFactory(String str) {
        super(str);
    }

    public DeferringMustacheFactory(File file) {
        super(file);
    }

    private static class Deferral {
        final Future<Object> future;
        final long id;

        Deferral(long j, Future<Object> future) {
            this.id = j;
            this.future = future;
        }
    }

    public static class DeferredCallable implements Callable<String> {
        private List<Deferral> deferrals = new ArrayList();

        public void add(Deferral deferral) {
            this.deferrals.add(deferral);
        }

        @Override // java.util.concurrent.Callable
        public String call() throws Exception {
            StringBuilder sb = new StringBuilder();
            for (Deferral deferral : this.deferrals) {
                Object obj = deferral.future.get();
                if (obj != null) {
                    DeferringMustacheFactory.writeDeferral(sb, deferral, obj);
                }
            }
            return sb.toString();
        }
    }

    @Override // com.github.mustachejava.DefaultMustacheFactory, com.github.mustachejava.MustacheFactory
    public MustacheVisitor createMustacheVisitor() {
        final AtomicLong atomicLong = new AtomicLong(0L);
        return new DefaultMustacheVisitor(this) { // from class: com.github.mustachejava.DeferringMustacheFactory.1
            @Override // com.github.mustachejava.DefaultMustacheVisitor, com.github.mustachejava.MustacheVisitor
            public void partial(TemplateContext templateContext, String str, String str2) {
                this.list.add(new C00081(new TemplateContext(MustacheParser.DEFAULT_SM, MustacheParser.DEFAULT_EM, templateContext.file(), templateContext.line(), templateContext.startOfLine()), this.df, str, Long.valueOf(atomicLong.incrementAndGet())));
            }

            /* JADX INFO: renamed from: com.github.mustachejava.DeferringMustacheFactory$1$1, reason: invalid class name and collision with other inner class name */
            class C00081 extends PartialCode {
                Wrapper deferredWrapper;
                final /* synthetic */ Long val$divid;

                /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
                C00081(TemplateContext templateContext, DefaultMustacheFactory defaultMustacheFactory, String str, Long l) {
                    super(templateContext, defaultMustacheFactory, str);
                    this.val$divid = l;
                }

                @Override // com.github.mustachejava.codes.PartialCode, com.github.mustachejava.codes.DefaultCode, com.github.mustachejava.Code
                public Writer execute(Writer writer, List<Object> list) {
                    Object obj = get(list);
                    DeferredCallable deferred = getDeferred(list);
                    if (obj == DeferringMustacheFactory.DEFERRED && deferred != null) {
                        try {
                            DeferringMustacheFactory.this.writeTarget(writer, this.val$divid);
                            writer.append((CharSequence) this.appended);
                            final InternalArrayList internalArrayList = new InternalArrayList(list);
                            deferred.add(new Deferral(this.val$divid.longValue(), DeferringMustacheFactory.this.getExecutorService().submit(new Callable() { // from class: com.github.mustachejava.DeferringMustacheFactory$1$1$$ExternalSyntheticLambda0
                                @Override // java.util.concurrent.Callable
                                public final Object call() {
                                    return this.f$0.m20xeb78d93f(internalArrayList);
                                }
                            })));
                            return writer;
                        } catch (IOException e) {
                            throw new MustacheException("Failed to write", e, this.tc);
                        }
                    }
                    return appendText(this.partial.execute(writer, list));
                }

                /* JADX INFO: renamed from: lambda$execute$0$com-github-mustachejava-DeferringMustacheFactory$1$1, reason: not valid java name */
                /* synthetic */ Object m20xeb78d93f(List list) throws Exception {
                    try {
                        StringWriter stringWriter = new StringWriter();
                        this.partial.execute((Writer) stringWriter, (List<Object>) list).close();
                        return stringWriter.toString();
                    } catch (IOException e) {
                        throw new MustacheException("Failed to writer", e, this.tc);
                    }
                }

                private DeferredCallable getDeferred(List<Object> list) {
                    try {
                        if (this.deferredWrapper == null) {
                            this.deferredWrapper = DeferringMustacheFactory.this.getObjectHandler().find("deferred", list);
                        }
                        return (DeferredCallable) this.deferredWrapper.call(list);
                    } catch (GuardException unused) {
                        this.deferredWrapper = null;
                        return getDeferred(list);
                    }
                }
            }
        };
    }

    protected void writeTarget(Writer writer, Long l) throws IOException {
        writer.append("<div id=\"");
        writer.append((CharSequence) l.toString());
        writer.append("\"></div>");
    }

    protected static void writeDeferral(StringBuilder sb, Deferral deferral, Object obj) {
        sb.append("<script>document.getElementById(\"");
        sb.append(deferral.id);
        sb.append("\").innerHTML=\"");
        sb.append(obj.toString().replace("<", "&lt;").replace("\"", "\\\"").replace(ShellCommandUtils.COMMAND_LINE_END, "\\n"));
        sb.append("\";</script>");
    }
}