package com.github.mustachejava.codes;

import com.github.mustachejava.Code;
import com.github.mustachejava.DefaultMustacheFactory;
import com.github.mustachejava.Mustache;
import com.github.mustachejava.MustacheException;
import com.github.mustachejava.TemplateContext;
import java.io.IOException;
import java.io.Writer;
import java.util.List;

/* JADX INFO: loaded from: classes.dex */
public class PartialCode extends DefaultCode {
    static final /* synthetic */ boolean $assertionsDisabled = false;
    protected final String dir;
    protected final String extension;
    protected boolean isRecursive;
    protected Mustache partial;
    protected int recrusionLimit;

    protected PartialCode(TemplateContext templateContext, DefaultMustacheFactory defaultMustacheFactory, Mustache mustache, String str, String str2) {
        super(templateContext, defaultMustacheFactory, mustache, str2, str);
        String strFile = templateContext.file();
        int iLastIndexOf = strFile.lastIndexOf(".");
        this.extension = iLastIndexOf == -1 ? "" : strFile.substring(iLastIndexOf);
        this.dir = strFile.substring(0, strFile.lastIndexOf("/") + 1);
        this.recrusionLimit = defaultMustacheFactory.getRecursionLimit();
    }

    public PartialCode(TemplateContext templateContext, DefaultMustacheFactory defaultMustacheFactory, String str) {
        this(templateContext, defaultMustacheFactory, null, ">", str);
    }

    @Override // com.github.mustachejava.codes.DefaultCode, com.github.mustachejava.Code
    public void identity(Writer writer) {
        try {
            if (this.name != null) {
                super.tag(writer, this.type);
            }
            appendText(writer);
        } catch (IOException e) {
            throw new MustacheException(e, this.tc);
        }
    }

    @Override // com.github.mustachejava.codes.DefaultCode, com.github.mustachejava.Code
    public Code[] getCodes() {
        Mustache mustache = this.partial;
        if (mustache == null) {
            return null;
        }
        return mustache.getCodes();
    }

    @Override // com.github.mustachejava.codes.DefaultCode, com.github.mustachejava.Code
    public void setCodes(Code[] codeArr) {
        this.partial.setCodes(codeArr);
    }

    @Override // com.github.mustachejava.codes.DefaultCode, com.github.mustachejava.Code
    public Writer execute(Writer writer, List<Object> list) {
        DepthLimitedWriter depthLimitedWriter;
        Writer writer2;
        DepthLimitedWriter depthLimitedWriter2;
        if (this.isRecursive) {
            if (writer instanceof DepthLimitedWriter) {
                depthLimitedWriter2 = (DepthLimitedWriter) writer;
            } else {
                depthLimitedWriter2 = new DepthLimitedWriter(writer);
            }
            if (depthLimitedWriter2.incr() > this.recrusionLimit) {
                throw new MustacheException("Maximum partial recursion limit reached: " + this.recrusionLimit, this.tc);
            }
            depthLimitedWriter = depthLimitedWriter2;
            writer2 = depthLimitedWriter2;
        } else {
            depthLimitedWriter = null;
            writer2 = writer;
        }
        Writer writerExecutePartial = executePartial(writer2, list);
        if (this.isRecursive) {
            depthLimitedWriter.decr();
        }
        return appendText(writerExecutePartial);
    }

    protected Writer executePartial(Writer writer, List<Object> list) {
        return this.partial.execute(writer, list);
    }

    @Override // com.github.mustachejava.codes.DefaultCode, com.github.mustachejava.Code
    public synchronized void init() {
        filterText();
        Mustache mustacheCompilePartial = this.df.compilePartial(partialName());
        this.partial = mustacheCompilePartial;
        if ((mustacheCompilePartial instanceof DefaultMustache) && ((DefaultMustache) mustacheCompilePartial).isRecursive()) {
            this.isRecursive = true;
        }
        if (this.partial == null) {
            throw new MustacheException("Failed to compile partial: " + this.name, this.tc);
        }
    }

    protected String partialName() {
        return this.df.resolvePartialPath(this.dir, this.name, this.extension);
    }
}