package com.benq.platform.test;

import android.graphics.Rect;
import android.util.Log;
import com.google.gson.Gson;
import com.jsyn.unitgen.u;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import o1.AbstractC0676l;
import okhttp3.HttpUrl;

/* JADX INFO: loaded from: classes.dex */
public final class ParameterConverter {
    public static final ParameterConverter INSTANCE = new ParameterConverter();
    private static final Gson gson = new Gson();

    private ParameterConverter() {
    }

    private final byte[] parseByteArray(String str) {
        try {
            String string = E1.g.y0(str).toString();
            if (new E1.f("^\\d+$").a(string)) {
                return new byte[Integer.parseInt(string)];
            }
            String strD0 = E1.g.d0(E1.g.c0(string, "["), "]");
            if (E1.g.n(strD0)) {
                return new byte[0];
            }
            List listL0 = E1.g.l0(strD0, new String[]{","}, false, 0, 6, null);
            ArrayList arrayList = new ArrayList(AbstractC0676l.o(listL0, 10));
            Iterator it = listL0.iterator();
            while (it.hasNext()) {
                arrayList.add(Byte.valueOf((byte) Integer.parseInt(E1.g.y0((String) it.next()).toString())));
            }
            return AbstractC0676l.N(arrayList);
        } catch (Exception e2) {
            Log.e("ParameterConverter", "Failed to parse ByteArray: " + str, e2);
            return null;
        }
    }

    private final Rect parseRectFromCommaSeparated(String str) {
        try {
            List listL0 = E1.g.l0(str, new String[]{","}, false, 0, 6, null);
            ArrayList arrayList = new ArrayList(AbstractC0676l.o(listL0, 10));
            Iterator it = listL0.iterator();
            while (it.hasNext()) {
                arrayList.add(Integer.valueOf(Integer.parseInt(E1.g.y0((String) it.next()).toString())));
            }
            if (arrayList.size() == 4) {
                return new Rect(((Number) arrayList.get(0)).intValue(), ((Number) arrayList.get(1)).intValue(), ((Number) arrayList.get(2)).intValue(), ((Number) arrayList.get(3)).intValue());
            }
            Log.w("ParameterConverter", "Invalid Rect format: " + str + ". Expected 'left,top,right,bottom' or JSON format '{\"left\":0,\"top\":0,\"right\":1920,\"bottom\":1080}'");
            return null;
        } catch (Exception e2) {
            Log.e("ParameterConverter", "Failed to parse Rect from comma-separated: " + str, e2);
            return null;
        }
    }

    public final Object convertStringToObject(String value, Class<?> type) {
        Object byteArray;
        kotlin.jvm.internal.l.e(value, "value");
        kotlin.jvm.internal.l.e(type, "type");
        Object rectFromCommaSeparated = null;
        if (value.length() == 0) {
            if (kotlin.jvm.internal.l.a(type, Integer.TYPE)) {
                return 0;
            }
            if (kotlin.jvm.internal.l.a(type, Long.TYPE)) {
                return 0L;
            }
            if (kotlin.jvm.internal.l.a(type, Float.TYPE)) {
                return Float.valueOf(0.0f);
            }
            if (kotlin.jvm.internal.l.a(type, Double.TYPE)) {
                return Double.valueOf(u.FALSE);
            }
            if (kotlin.jvm.internal.l.a(type, Boolean.TYPE)) {
                return Boolean.FALSE;
            }
            if (kotlin.jvm.internal.l.a(type, String.class)) {
                return HttpUrl.FRAGMENT_ENCODE_SET;
            }
            if (kotlin.jvm.internal.l.a(type, byte[].class)) {
                return new byte[0];
            }
            return null;
        }
        try {
            if (kotlin.jvm.internal.l.a(type, Integer.TYPE)) {
                byteArray = Integer.valueOf(Integer.parseInt(value));
            } else if (kotlin.jvm.internal.l.a(type, Long.TYPE)) {
                byteArray = Long.valueOf(Long.parseLong(value));
            } else if (kotlin.jvm.internal.l.a(type, Float.TYPE)) {
                byteArray = Float.valueOf(Float.parseFloat(value));
            } else if (kotlin.jvm.internal.l.a(type, Double.TYPE)) {
                byteArray = Double.valueOf(Double.parseDouble(value));
            } else if (kotlin.jvm.internal.l.a(type, Boolean.TYPE)) {
                byteArray = Boolean.valueOf(Boolean.parseBoolean(value));
            } else if (kotlin.jvm.internal.l.a(type, String.class)) {
                byteArray = value;
            } else if (kotlin.jvm.internal.l.a(type, byte[].class)) {
                byteArray = parseByteArray(value);
            } else {
                try {
                    if (E1.g.y(value, "{", false, 2, null) && E1.g.k(value, "}", false, 2, null)) {
                        rectFromCommaSeparated = gson.fromJson(value, (Class<Object>) type);
                    } else if (E1.g.y(value, "[", false, 2, null) && E1.g.k(value, "]", false, 2, null)) {
                        rectFromCommaSeparated = gson.fromJson(value, (Class<Object>) type);
                    } else if (kotlin.jvm.internal.l.a(type, Rect.class)) {
                        rectFromCommaSeparated = parseRectFromCommaSeparated(value);
                    } else {
                        Log.w("ParameterConverter", "Unsupported format for type " + type.getName() + ". Expected JSON format or use '{...}' / '[...]' notation.");
                    }
                } catch (Exception e2) {
                    Log.e("ParameterConverter", "Failed to deserialize JSON for type " + type.getName() + ": " + value, e2);
                }
                byteArray = rectFromCommaSeparated;
            }
            return byteArray;
        } catch (Exception e3) {
            Log.e("ParameterConverter", "Failed to convert value '" + value + "' to type " + type.getName(), e3);
            return rectFromCommaSeparated;
        }
    }
}