/*
 * Decompiled with CFR 0.152.
 * 
 * Could not load the following classes:
 *  com.l7tech.identity.BadCredentialsException
 *  com.l7tech.identity.UserBean
 *  com.l7tech.identity.ldap.LdapIdentityProviderConfig
 *  com.l7tech.identity.ldap.LdapUrlBasedIdentityProviderConfig
 *  com.l7tech.identity.ldap.LdapUser
 *  com.l7tech.identity.ldap.UserMappingConfig
 *  com.l7tech.objectmodel.EntityHeaderSet
 *  com.l7tech.objectmodel.EntityType
 *  com.l7tech.objectmodel.FindException
 *  com.l7tech.objectmodel.Goid
 *  com.l7tech.objectmodel.IdentityHeader
 *  com.l7tech.util.ExceptionUtils
 */
package com.l7tech.server.identity.ldap;

import com.l7tech.identity.BadCredentialsException;
import com.l7tech.identity.UserBean;
import com.l7tech.identity.ldap.LdapIdentityProviderConfig;
import com.l7tech.identity.ldap.LdapUrlBasedIdentityProviderConfig;
import com.l7tech.identity.ldap.LdapUser;
import com.l7tech.identity.ldap.UserMappingConfig;
import com.l7tech.objectmodel.EntityHeaderSet;
import com.l7tech.objectmodel.EntityType;
import com.l7tech.objectmodel.FindException;
import com.l7tech.objectmodel.Goid;
import com.l7tech.objectmodel.IdentityHeader;
import com.l7tech.server.identity.ldap.LdapClassLoaderRequired;
import com.l7tech.server.identity.ldap.LdapIdentityProvider;
import com.l7tech.server.identity.ldap.LdapRuntimeConfig;
import com.l7tech.server.identity.ldap.LdapUserManager;
import com.l7tech.server.identity.ldap.LdapUtils;
import com.l7tech.server.identity.ldap.ab;
import com.l7tech.server.identity.ldap.ac;
import com.l7tech.server.identity.ldap.ad;
import com.l7tech.server.identity.ldap.ag;
import com.l7tech.server.identity.ldap.h;
import com.l7tech.util.ExceptionUtils;
import java.util.Collection;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.naming.AuthenticationException;
import javax.naming.NameNotFoundException;
import javax.naming.NamingException;
import javax.naming.directory.Attribute;
import javax.naming.directory.Attributes;

@LdapClassLoaderRequired
public class LdapUserManagerImpl
implements LdapUserManager {
    private LdapIdentityProvider a;
    private LdapIdentityProviderConfig b;
    private LdapRuntimeConfig c;
    private ad d;
    private final Logger e = Logger.getLogger(this.getClass().getName());
    private static final String[] f;

    @Override
    public synchronized void configure(LdapIdentityProvider ldapIdentityProvider) {
        this.a = ldapIdentityProvider;
        this.b = this.a.getConfig();
        this.d = new ag(this, this.b.getSearchBase(), this.a());
    }

    public void setLdapRuntimeConfig(LdapRuntimeConfig ldapRuntimeConfig) {
        this.c = ldapRuntimeConfig;
    }

    public LdapUser findByPrimaryKey(String string) throws FindException {
        LdapUser[] ldapUserArray = new LdapUser[1];
        try {
            this.d.a(string, new ab(this, ldapUserArray));
        }
        catch (NameNotFoundException nameNotFoundException) {
            if (this.e.isLoggable(Level.FINEST)) {
                String string2 = ExceptionUtils.getMessage((Throwable)nameNotFoundException);
                String string3 = this.c().getName();
                String string4 = string;
                String[] stringArray = f;
                this.e.finest(stringArray[13] + string4 + stringArray[1] + string3 + stringArray[9] + string2 + ")");
            }
        }
        catch (AuthenticationException authenticationException) {
            String[] stringArray = f;
            this.e.log(Level.WARNING, stringArray[6] + ExceptionUtils.getMessage((Throwable)authenticationException), ExceptionUtils.getDebugException((Throwable)authenticationException));
        }
        catch (NamingException namingException) {
            this.e.log(Level.WARNING, f[4] + ExceptionUtils.getMessage((Throwable)namingException), ExceptionUtils.getDebugException((Throwable)namingException));
        }
        return ldapUserArray[0];
    }

    public LdapUser findByLogin(String string) throws FindException {
        LdapUser[] ldapUserArray = new LdapUser[1];
        try {
            UserMappingConfig[] userMappingConfigArray;
            LdapIdentityProviderConfig ldapIdentityProviderConfig = this.c();
            h h2 = new h();
            h2.or();
            for (UserMappingConfig userMappingConfig : userMappingConfigArray = ldapIdentityProviderConfig.getUserMappings()) {
                h2.attrEquals(userMappingConfig.getLoginAttrName(), string);
            }
            try {
                h2.end();
                this.d.a(h2.buildFilter(), 1L, null, new ac(this, ldapUserArray));
                if (ldapUserArray[0] == null) {
                    this.e.fine(ldapIdentityProviderConfig.getName() + f[5] + string);
                }
            }
            catch (AuthenticationException authenticationException) {
                throw LdapUserManagerImpl.a(authenticationException);
            }
        }
        catch (AuthenticationException authenticationException) {
            String[] stringArray = f;
            this.e.log(Level.WARNING, stringArray[14] + authenticationException.getMessage(), ExceptionUtils.getDebugException((Throwable)authenticationException));
        }
        catch (NamingException namingException) {
            this.e.log(Level.WARNING, f[2] + namingException.getMessage(), ExceptionUtils.getDebugException((Throwable)namingException));
        }
        return ldapUserArray[0];
    }

    private LdapUser a(String string, Attributes attributes) throws NamingException {
        try {
            if (!this.a.isValidEntryBasedOnUserAccountControlAttribute(string, attributes)) {
                this.e.warning(f[7] + string + f[10]);
                return null;
            }
        }
        catch (NamingException namingException) {
            throw LdapUserManagerImpl.a(namingException);
        }
        try {
            if (this.a.checkExpiredMSADAccount(string, attributes)) {
                this.e.warning(f[11] + string + f[8]);
                return null;
            }
        }
        catch (NamingException namingException) {
            throw LdapUserManagerImpl.a(namingException);
        }
        LdapIdentityProviderConfig ldapIdentityProviderConfig = this.c();
        UserMappingConfig[] userMappingConfigArray = ldapIdentityProviderConfig.getUserMappings();
        String[] stringArray = f;
        Attribute attribute = attributes.get(stringArray[12]);
        for (UserMappingConfig userMappingConfig : userMappingConfigArray) {
            LdapUser ldapUser;
            block28: {
                Object object;
                block29: {
                    Object object2;
                    String string2 = userMappingConfig.getObjClass();
                    if (!LdapUtils.a(attribute, string2)) continue;
                    ldapUser = new LdapUser();
                    ldapUser.setProviderId(ldapIdentityProviderConfig.getGoid());
                    ldapUser.setDn(string);
                    ldapUser.setAttributes(attributes);
                    object = LdapUtils.a(attributes, userMappingConfig.getEmailNameAttrName());
                    try {
                        if (object != null) {
                            ldapUser.setEmail(object.toString());
                        }
                    }
                    catch (NamingException namingException) {
                        throw LdapUserManagerImpl.a(namingException);
                    }
                    object = LdapUtils.a(attributes, userMappingConfig.getFirstNameAttrName());
                    try {
                        if (object != null) {
                            ldapUser.setFirstName(object.toString());
                        }
                    }
                    catch (NamingException namingException) {
                        throw LdapUserManagerImpl.a(namingException);
                    }
                    object = LdapUtils.a(attributes, userMappingConfig.getLastNameAttrName());
                    try {
                        if (object != null) {
                            ldapUser.setLastName(object.toString());
                        }
                    }
                    catch (NamingException namingException) {
                        throw LdapUserManagerImpl.a(namingException);
                    }
                    object = LdapUtils.a(attributes, userMappingConfig.getLoginAttrName());
                    try {
                        if (object != null) {
                            ldapUser.setLogin(object.toString());
                        }
                    }
                    catch (NamingException namingException) {
                        throw LdapUserManagerImpl.a(namingException);
                    }
                    object = LdapUtils.a(attributes, userMappingConfig.getNameAttrName());
                    try {
                        if (object != null) {
                            ldapUser.setCn(object.toString());
                        }
                    }
                    catch (NamingException namingException) {
                        throw LdapUserManagerImpl.a(namingException);
                    }
                    object = LdapUtils.a(attributes, userMappingConfig.getPasswdAttrName());
                    if (object instanceof byte[]) {
                        object2 = (byte[])object;
                        ldapUser.setPassword(new String((byte[])object2));
                    }
                    if ((object2 = (Object)userMappingConfig.getUserCertAttrName()) == null) {
                        stringArray = f;
                        object2 = stringArray[16];
                    }
                    object = LdapUtils.a(attributes, (String)object2);
                    try {
                        try {
                            if (object == null) break block28;
                            if (!(object instanceof byte[])) break block29;
                        }
                        catch (NamingException namingException) {
                            throw LdapUserManagerImpl.a(namingException);
                        }
                        ldapUser.setLdapCertBytes((byte[])object);
                        break block28;
                    }
                    catch (NamingException namingException) {
                        throw LdapUserManagerImpl.a(namingException);
                    }
                }
                this.e.warning(f[3] + String.valueOf(object.getClass()));
            }
            return ldapUser;
        }
        return null;
    }

    public void delete(LdapUser ldapUser) {
        throw new UnsupportedOperationException();
    }

    public void deleteAll(Goid goid) {
        throw new UnsupportedOperationException();
    }

    public void delete(String string) {
        throw new UnsupportedOperationException();
    }

    public void update(LdapUser ldapUser) {
        throw new UnsupportedOperationException();
    }

    public String save(LdapUser ldapUser, Set set) {
        throw new UnsupportedOperationException();
    }

    public String save(Goid goid, LdapUser ldapUser, Set set) {
        throw new UnsupportedOperationException();
    }

    public LdapUser reify(UserBean userBean) {
        throw new UnsupportedOperationException();
    }

    public void update(LdapUser ldapUser, Set set) {
        throw new UnsupportedOperationException();
    }

    public Class<LdapUser> getImpClass() {
        return LdapUser.class;
    }

    public EntityHeaderSet<IdentityHeader> findAllHeaders() throws FindException {
        LdapIdentityProvider ldapIdentityProvider = this.b();
        return ldapIdentityProvider.search(new EntityType[]{EntityType.USER}, "*");
    }

    public EntityHeaderSet<IdentityHeader> search(String string) throws FindException {
        LdapIdentityProvider ldapIdentityProvider = this.b();
        return ldapIdentityProvider.search(new EntityType[]{EntityType.USER}, "*");
    }

    public IdentityHeader userToHeader(LdapUser ldapUser) {
        return new IdentityHeader(ldapUser.getProviderId(), ldapUser.getId(), EntityType.USER, ldapUser.getLogin(), ldapUser.getName(), ldapUser.getCn(), null);
    }

    public LdapUser headerToUser(IdentityHeader identityHeader) {
        LdapUser ldapUser = new LdapUser();
        ldapUser.setProviderId(this.b.getGoid());
        ldapUser.setDn(identityHeader.getStrId());
        ldapUser.setCn(identityHeader.getName());
        return ldapUser;
    }

    @Override
    public boolean authenticateBasic(String string, String string2) throws BadCredentialsException {
        return LdapUtils.authenticateBasic(this.b(), (LdapUrlBasedIdentityProviderConfig)this.c(), this.c, this.e, string, string2);
    }

    private String[] a() {
        String[] stringArray = null;
        Collection<String> collection = this.a.getReturningAttributes();
        if (collection != null) {
            stringArray = collection.toArray(new String[collection.size()]);
        }
        return stringArray;
    }

    private LdapIdentityProvider b() {
        LdapIdentityProvider ldapIdentityProvider = this.a;
        try {
            if (ldapIdentityProvider == null) {
                throw new IllegalStateException(f[0]);
            }
        }
        catch (UnsupportedOperationException unsupportedOperationException) {
            throw LdapUserManagerImpl.a(unsupportedOperationException);
        }
        return ldapIdentityProvider;
    }

    private LdapIdentityProviderConfig c() {
        LdapIdentityProviderConfig ldapIdentityProviderConfig = this.b;
        try {
            if (ldapIdentityProviderConfig == null) {
                throw new IllegalStateException(f[15]);
            }
        }
        catch (UnsupportedOperationException unsupportedOperationException) {
            throw LdapUserManagerImpl.a(unsupportedOperationException);
        }
        return ldapIdentityProviderConfig;
    }

    private static Exception a(Exception exception) {
        return exception;
    }

    /*
     * Unable to fully structure code
     */
    static {
        block10: {
            block9: {
                var5 = new String[17];
                var3_1 = 0;
                var2_2 = "feI{~\u0002;NcZ.o\b1\t\u0012\bnR>nM;G~\u001d>e\u0004&\\*T5\fdN|\u000b=\b'ZeOa=K}yX)=\u000e0Z~T=t\u000e4\\o\u001d\u0017y\f%\bzO4m\b'\\s\u001d+r\u001d DkI>yM\"A~U{y\f!I*T5=\f;\b\u007fS>e\u001d0K~X?=\u000b:Zg\\/=\fdN|\u000b=\b'ZeOa=\u0010\bi\\5s\u0002!\blT5yM6F7\u001bdN|\u000b=\f \\bX5i\u00046I~T4sM0ZxR)'M\u0005}yX)=\u001c\bcN{x\u0015%AxX?3M\u0007M~H)s\u0004;O*S.q\u0001{\u0002\b\"'\bcN{q\u00026CoY{r\u001fuLcN:\u007f\u00010L$\u001d\tx\u0019 ZdT5zM;]fQu\bii^4h\u0003!\b\u000bGhW>~\u00196DkN(\u0005}yX)=\u001bdN|\u000b=\f \\bX5i\u00046I~T4sM0ZxR)'M";
                var4_3 = "feI{~\u0002;NcZ.o\b1\t\u0012\bnR>nM;G~\u001d>e\u0004&\\*T5\fdN|\u000b=\b'ZeOa=K}yX)=\u000e0Z~T=t\u000e4\\o\u001d\u0017y\f%\bzO4m\b'\\s\u001d+r\u001d DkI>yM\"A~U{y\f!I*T5=\f;\b\u007fS>e\u001d0K~X?=\u000b:Zg\\/=\fdN|\u000b=\b'ZeOa=\u0010\bi\\5s\u0002!\blT5yM6F7\u001bdN|\u000b=\f \\bX5i\u00046I~T4sM0ZxR)'M\u0005}yX)=\u001c\bcN{x\u0015%AxX?3M\u0007M~H)s\u0004;O*S.q\u0001{\u0002\b\"'\bcN{q\u00026CoY{r\u001fuLcN:\u007f\u00010L$\u001d\tx\u0019 ZdT5zM;]fQu\bii^4h\u0003!\b\u000bGhW>~\u00196DkN(\u0005}yX)=\u001bdN|\u000b=\f \\bX5i\u00046I~T4sM0ZxR)'M".length();
                var1_4 = 15;
                var0_5 = -1;
lbl7:
                // 2 sources

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

                while (true) {
                    var5[var3_1++] = LdapUserManagerImpl.a(v0, LdapUserManagerImpl.a(v2));
                    if ((var0_5 += var1_4) < var4_3) {
                        var1_4 = var2_2.charAt(var0_5);
                        ** continue;
                    }
                    var2_2 = "mnBpu\t0EhQ%d\u0003:\u0002\u0016VrS\"U\u0003,WhP9u\u0007*F:T9x\u0007,Z";
                    var4_3 = "mnBpu\t0EhQ%d\u0003:\u0002\u0016VrS\"U\u0003,WhP9u\u0007*F:T9x\u0007,Z".length();
                    var1_4 = 15;
                    var0_5 = -1;
lbl22:
                    // 2 sources

                    while (true) {
                        v0 = 77;
                        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++] = LdapUserManagerImpl.a(v0, LdapUserManagerImpl.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;
            }
        }
        LdapUserManagerImpl.f = var5;
    }

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

    /*
     * Handled impossible loop by duplicating code
     * Enabled aggressive block sorting
     */
    private static String a(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 -> 110;
                    case 1 -> 76;
                    case 2 -> 123;
                    case 3 -> 29;
                    case 4 -> 91;
                    case 5 -> 43;
                    default -> 19;
                })));
                ++n3;
                n4 = n4;
            } while (n4 > n3);
        }
        return new String(cArray2).intern();
    }
}