package com.github.mustachejava.reflect;

import com.github.mustachejava.Binding;
import com.github.mustachejava.Code;
import com.github.mustachejava.Iteration;
import com.github.mustachejava.ObjectHandler;
import com.github.mustachejava.TemplateContext;
import java.io.Writer;
import java.lang.reflect.AccessibleObject;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Iterator;
import java.util.List;
import java.util.Optional;

/* JADX INFO: loaded from: classes.dex */
public abstract class BaseObjectHandler implements ObjectHandler {
    @Override // com.github.mustachejava.ObjectHandler
    public abstract Binding createBinding(String str, TemplateContext templateContext, Code code);

    @Override // com.github.mustachejava.ObjectHandler
    public Object coerce(Object obj) {
        if (!(obj instanceof Optional)) {
            return obj;
        }
        Optional optional = (Optional) obj;
        if (optional.isPresent()) {
            return coerce(optional.get());
        }
        return null;
    }

    @Override // com.github.mustachejava.ObjectHandler
    public Writer falsey(Iteration iteration, Writer writer, Object obj, List<Object> list) {
        if (obj != null) {
            if (obj instanceof Boolean) {
                if (((Boolean) obj).booleanValue()) {
                    return writer;
                }
            } else if (obj instanceof String) {
                if (!obj.toString().equals("")) {
                    return writer;
                }
            } else if (obj instanceof List) {
                if (((List) obj).size() > 0) {
                    return writer;
                }
            } else if (obj instanceof Iterable) {
                if (((Iterable) obj).iterator().hasNext()) {
                    return writer;
                }
            } else if (obj instanceof Iterator) {
                if (((Iterator) obj).hasNext()) {
                    return writer;
                }
            } else if (!obj.getClass().isArray() || Array.getLength(obj) > 0) {
                return writer;
            }
        }
        return iteration.next(writer, obj, list);
    }

    @Override // com.github.mustachejava.ObjectHandler
    public Writer iterate(Iteration iteration, Writer writer, Object obj, List<Object> list) {
        if (obj == null) {
            return writer;
        }
        if ((obj instanceof Boolean) && !((Boolean) obj).booleanValue()) {
            return writer;
        }
        if ((obj instanceof String) && obj.toString().equals("")) {
            return writer;
        }
        int i = 0;
        if (obj instanceof List) {
            List list2 = (List) obj;
            int size = list2.size();
            while (i < size) {
                writer = iteration.next(writer, coerce(list2.get(i)), list);
                i++;
            }
            return writer;
        }
        if (obj instanceof Iterable) {
            Iterator it = ((Iterable) obj).iterator();
            while (it.hasNext()) {
                writer = iteration.next(writer, coerce(it.next()), list);
            }
            return writer;
        }
        if (obj instanceof Iterator) {
            Iterator it2 = (Iterator) obj;
            while (it2.hasNext()) {
                writer = iteration.next(writer, coerce(it2.next()), list);
            }
            return writer;
        }
        if (obj.getClass().isArray()) {
            int length = Array.getLength(obj);
            while (i < length) {
                writer = iteration.next(writer, coerce(Array.get(obj, i)), list);
                i++;
            }
            return writer;
        }
        return iteration.next(writer, obj, list);
    }

    protected Field getField(Class cls, String str) throws NoSuchFieldException {
        try {
            Field declaredField = cls.getDeclaredField(str);
            checkField(declaredField);
            declaredField.setAccessible(true);
            return declaredField;
        } catch (NoSuchFieldException e) {
            Class superclass = cls.getSuperclass();
            if (superclass != null && superclass != Object.class) {
                return getField(superclass, str);
            }
            throw e;
        }
    }

    protected Method getMethod(Class<?> cls, String str, Class<?>... clsArr) throws NoSuchMethodException {
        Method declaredMethod;
        try {
            try {
                declaredMethod = cls.getMethod(str, clsArr);
                if (declaredMethod.getDeclaringClass() == Object.class) {
                    throw new NoSuchMethodException();
                }
            } catch (NoSuchMethodException e) {
                Class<? super Object> superclass = cls.getSuperclass();
                if (superclass != null && superclass != Object.class) {
                    return getMethod(superclass, str, new Class[0]);
                }
                throw e;
            }
        } catch (NoSuchMethodException unused) {
            declaredMethod = cls.getDeclaredMethod(str, clsArr);
        }
        checkMethod(declaredMethod);
        declaredMethod.setAccessible(true);
        return declaredMethod;
    }

    protected AccessibleObject findMember(Class cls, String str) {
        AccessibleObject accessibleObjectFindMember;
        if (String.class == cls && "value".equals(str)) {
            return null;
        }
        if (checkClass(cls)) {
            for (Class<?> cls2 : cls.getInterfaces()) {
                AccessibleObject accessibleObjectFindMember2 = findMember(cls2, str);
                if (accessibleObjectFindMember2 != null) {
                    return accessibleObjectFindMember2;
                }
            }
            Class superclass = cls.getSuperclass();
            if (superclass != null && superclass != Object.class && (accessibleObjectFindMember = findMember(superclass, str)) != null) {
                return accessibleObjectFindMember;
            }
        }
        return findMemberOnClass(cls, str);
    }

    private AccessibleObject findMemberOnClass(Class cls, String str) {
        try {
            return getMethod(cls, str, new Class[0]);
        } catch (NoSuchMethodException unused) {
            String str2 = str.substring(0, 1).toUpperCase() + (str.length() > 1 ? str.substring(1) : "");
            try {
                try {
                    try {
                        return this.getMethod(cls, "get" + str2, new Class[0]);
                    } catch (NoSuchMethodException unused2) {
                        return this.getField(cls, str);
                    }
                } catch (NoSuchFieldException unused3) {
                    return null;
                }
            } catch (NoSuchMethodException unused4) {
                return this.getMethod(cls, "is" + str2, new Class[0]);
            }
        }
    }

    protected void checkMethod(Method method) throws NoSuchMethodException {
        if ((method.getModifiers() & 2) == 2) {
            throw new NoSuchMethodException("Only public, protected and package members allowed");
        }
    }

    protected void checkField(Field field) throws NoSuchFieldException {
        if ((field.getModifiers() & 2) == 2) {
            throw new NoSuchFieldException("Only public, protected and package members allowed");
        }
    }

    protected boolean checkClass(Class cls) {
        return (cls.getModifiers() & 1) != 1;
    }

    @Override // com.github.mustachejava.ObjectHandler
    public String stringify(Object obj) {
        return obj.toString();
    }
}