/*
 * Decompiled with CFR 0.152.
 * 
 * Could not load the following classes:
 *  com.l7tech.gateway.common.jdbc.JdbcConnection
 *  com.l7tech.objectmodel.EntityHeader
 *  com.l7tech.objectmodel.EntityManager$UniqueType
 *  com.l7tech.objectmodel.FindException
 *  com.l7tech.objectmodel.NamedEntity
 *  com.l7tech.objectmodel.PersistentEntity
 *  jakarta.persistence.TypedQuery
 *  jakarta.persistence.criteria.CriteriaBuilder
 *  jakarta.persistence.criteria.Predicate
 *  jakarta.persistence.criteria.Root
 *  org.hibernate.HibernateException
 *  org.springframework.context.ApplicationListener
 *  org.springframework.orm.hibernate5.HibernateCallback
 *  org.springframework.transaction.annotation.Propagation
 *  org.springframework.transaction.annotation.Transactional
 */
package com.l7tech.server.jdbc;

import com.l7tech.gateway.common.jdbc.JdbcConnection;
import com.l7tech.objectmodel.EntityHeader;
import com.l7tech.objectmodel.EntityManager;
import com.l7tech.objectmodel.FindException;
import com.l7tech.objectmodel.NamedEntity;
import com.l7tech.objectmodel.PersistentEntity;
import com.l7tech.server.HibernateEntityManager;
import com.l7tech.server.ServerConfig;
import com.l7tech.server.jdbc.JdbcConnectionManager;
import com.l7tech.server.jdbc.i;
import com.l7tech.server.jdbc.q;
import com.l7tech.server.policy.variable.ExpandVariables;
import com.l7tech.server.util.PostStartupTransactionalApplicationListener;
import jakarta.persistence.TypedQuery;
import jakarta.persistence.criteria.CriteriaBuilder;
import jakarta.persistence.criteria.Predicate;
import jakarta.persistence.criteria.Root;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;
import java.util.logging.Logger;
import org.hibernate.HibernateException;
import org.springframework.context.ApplicationListener;
import org.springframework.orm.hibernate5.HibernateCallback;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

@Transactional(propagation=Propagation.REQUIRED, rollbackFor={Throwable.class})
public class JdbcConnectionManagerImpl
extends HibernateEntityManager<JdbcConnection, EntityHeader>
implements JdbcConnectionManager,
PostStartupTransactionalApplicationListener {
    private static final Logger m;
    private static final String[] n;

    public Class<? extends PersistentEntity> getImpClass() {
        return JdbcConnection.class;
    }

    @Override
    protected EntityManager.UniqueType getUniqueType() {
        return EntityManager.UniqueType.NAME;
    }

    @Override
    public JdbcConnection getJdbcConnection(String string) throws FindException {
        return this.findByUniqueName(string);
    }

    @Override
    @Transactional(readOnly=true)
    public JdbcConnection findByUniqueName(String string) throws FindException {
        try {
            if (string == null) {
                throw new NullPointerException();
            }
        }
        catch (HibernateException hibernateException) {
            throw JdbcConnectionManagerImpl.a((RuntimeException)((Object)hibernateException));
        }
        try {
            if (!NamedEntity.class.isAssignableFrom(this.getImpClass())) {
                throw new IllegalArgumentException(n[2]);
            }
        }
        catch (HibernateException hibernateException) {
            throw JdbcConnectionManagerImpl.a((RuntimeException)((Object)hibernateException));
        }
        try {
            return (JdbcConnection)this.getHibernateTemplate().execute((HibernateCallback)new q(this, string));
        }
        catch (HibernateException hibernateException) {
            throw new FindException(n[0], (Throwable)hibernateException);
        }
    }

    @Override
    public List<String> getSupportedDriverClass() {
        ArrayList<String> arrayList;
        block7: {
            arrayList = new ArrayList<String>();
            String string = ServerConfig.getInstance().getProperty(n[3]);
            try {
                if (string == null || string.isEmpty()) break block7;
            }
            catch (NullPointerException nullPointerException) {
                throw JdbcConnectionManagerImpl.a(nullPointerException);
            }
            StringTokenizer stringTokenizer = new StringTokenizer(string, "\n");
            while (stringTokenizer.hasMoreTokens()) {
                String string2 = stringTokenizer.nextToken();
                try {
                    try {
                        if (string2 == null || string2.isEmpty()) continue;
                    }
                    catch (NullPointerException nullPointerException) {
                        throw JdbcConnectionManagerImpl.a(nullPointerException);
                    }
                    arrayList.add(string2);
                }
                catch (NullPointerException nullPointerException) {
                    throw JdbcConnectionManagerImpl.a(nullPointerException);
                }
            }
        }
        return arrayList;
    }

    @Override
    public boolean isDriverClassSupported(String string) {
        block4: {
            try {
                try {
                    if (string == null || string.isEmpty()) break block4;
                }
                catch (NullPointerException nullPointerException) {
                    throw JdbcConnectionManagerImpl.a(nullPointerException);
                }
                return this.getSupportedDriverClass().contains(ExpandVariables.processEnvVar(string));
            }
            catch (NullPointerException nullPointerException) {
                throw JdbcConnectionManagerImpl.a(nullPointerException);
            }
        }
        return false;
    }

    @Override
    public void clearAllFromCache() {
        try {
            if (this.getSessionFactory().getCache() != null) {
                m.warning(n[1]);
                this.getSessionFactory().getCache().evictQueryRegions();
                this.getSessionFactory().getCache().evictEntityRegion(JdbcConnection.class);
            }
        }
        catch (NullPointerException nullPointerException) {
            throw JdbcConnectionManagerImpl.a(nullPointerException);
        }
    }

    public ApplicationListener getListener() {
        return new i(this);
    }

    static /* synthetic */ Predicate access$000(JdbcConnectionManagerImpl jdbcConnectionManagerImpl, Predicate predicate, CriteriaBuilder criteriaBuilder, Root root) {
        return jdbcConnectionManagerImpl.addFindByNamePredicate(predicate, criteriaBuilder, root);
    }

    static /* synthetic */ PersistentEntity access$100(JdbcConnectionManagerImpl jdbcConnectionManagerImpl, TypedQuery typedQuery) {
        return jdbcConnectionManagerImpl.initializeLazilyLoadedUniqueResult(typedQuery);
    }

    static /* synthetic */ List access$200(JdbcConnectionManagerImpl jdbcConnectionManagerImpl, String string, Object object) throws FindException {
        return jdbcConnectionManagerImpl.findByPropertyMaybeNull(string, object);
    }

    /*
     * Unable to fully structure code
     */
    static {
        block10: {
            block9: {
                var5 = new String[4];
                var3_1 = 0;
                var2_2 = "xt`\b\u0007>\bO;s\r\r4\u000fNu|\u0015\u00165\u000f^ua\r\u0017)+xwp\u0005\u00119A\\;t\b\u000fpLZx}\u0001\u0007pe_yv'\f>A^xa\r\f>\u000f^ua\r\u00179JH";
                var4_3 = "xt`\b\u0007>\bO;s\r\r4\u000fNu|\u0015\u00165\u000f^ua\r\u0017)+xwp\u0005\u00119A\\;t\b\u000fpLZx}\u0001\u0007pe_yv'\f>A^xa\r\f>\u000f^ua\r\u00179JH".length();
                var1_4 = 27;
                var0_5 = -1;
lbl7:
                // 2 sources

                while (true) {
                    v0 = 2;
                    v1 = ++var0_5;
                    v2 = var2_2.substring(v1, v1 + var1_4);
                    v3 = -1;
                    break block9;
                    break;
                }
lbl13:
                // 1 sources

                while (true) {
                    var5[var3_1++] = JdbcConnectionManagerImpl.b(v0, JdbcConnectionManagerImpl.a(v2));
                    if ((var0_5 += var1_4) < var4_3) {
                        var1_4 = var2_2.charAt(var0_5);
                        ** continue;
                    }
                    var2_2 = "$87\\\bV\u0005\u001e19JZ<\u0017P50[Ao\r\u0015#~NZ~D\u001e?*\u000ffz\t\u00154\u001bA\\r\u0010\u00195-\u000e$\u001a4<Lkt\n\u001e5=[At\n^4,F^~\u00163<?\\[5\u0013\u00189*Jdr\u0017\u0004";
                    var4_3 = "$87\\\bV\u0005\u001e19JZ<\u0017P50[Ao\r\u0015#~NZ~D\u001e?*\u000ffz\t\u00154\u001bA\\r\u0010\u00195-\u000e$\u001a4<Lkt\n\u001e5=[At\n^4,F^~\u00163<?\\[5\u0013\u00189*Jdr\u0017\u0004".length();
                    var1_4 = 46;
                    var0_5 = -1;
lbl22:
                    // 2 sources

                    while (true) {
                        v0 = 73;
                        v4 = ++var0_5;
                        v2 = var2_2.substring(v4, v4 + var1_4);
                        v3 = 0;
                        break block9;
                        break;
                    }
                    break;
                }
lbl28:
                // 1 sources

                while (true) {
                    var5[var3_1++] = JdbcConnectionManagerImpl.b(v0, JdbcConnectionManagerImpl.a(v2));
                    if ((var0_5 += var1_4) < var4_3) {
                        var1_4 = var2_2.charAt(var0_5);
                        ** continue;
                    }
                    break block10;
                    break;
                }
            }
            switch (v3) {
                default: {
                    ** continue;
                }
                ** case 0:
lbl39:
                // 1 sources

                ** continue;
            }
        }
        JdbcConnectionManagerImpl.n = var5;
        JdbcConnectionManagerImpl.m = Logger.getLogger(JdbcConnectionManagerImpl.class.getName());
    }

    private static RuntimeException a(RuntimeException runtimeException) {
        return runtimeException;
    }

    private static char[] a(String string) {
        char[] cArray = string.toCharArray();
        if (cArray.length < 2) {
            cArray = cArray;
            cArray[0] = (char)(cArray[0] ^ 0x2D);
        }
        return cArray;
    }

    /*
     * Handled impossible loop by duplicating code
     * Enabled aggressive block sorting
     */
    private static String b(int n2, char[] cArray) {
        char[] cArray2;
        block11: {
            int n3;
            int n4;
            int n5;
            block10: {
                n5 = n2;
                cArray2 = cArray;
                n4 = cArray.length;
                n3 = 0;
                if (!true) break block10;
                n4 = n4;
                if (n4 <= n3) break block11;
            }
            do {
                n5 = n5;
                cArray2 = cArray2;
                int n6 = n3;
                cArray2[n6] = (char)(cArray2[n6] ^ (n5 ^ (switch (n3 % 7) {
                    case 0 -> 57;
                    case 1 -> 25;
                    case 2 -> 23;
                    case 3 -> 102;
                    case 4 -> 97;
                    case 5 -> 82;
                    default -> 45;
                })));
                ++n3;
                n4 = n4;
            } while (n4 > n3);
        }
        return new String(cArray2).intern();
    }
}