/*
 * Decompiled with CFR 0.152.
 * 
 * Could not load the following classes:
 *  com.l7tech.identity.BadCredentialsException
 *  com.l7tech.identity.User
 *  com.l7tech.identity.UserBean
 *  com.l7tech.identity.ldap.BindOnlyLdapIdentityProviderConfig
 *  com.l7tech.identity.ldap.BindOnlyLdapUser
 *  com.l7tech.identity.ldap.LdapUrlBasedIdentityProviderConfig
 *  com.l7tech.identity.ldap.LdapUser
 *  com.l7tech.objectmodel.DeleteException
 *  com.l7tech.objectmodel.EntityHeaderSet
 *  com.l7tech.objectmodel.EntityType
 *  com.l7tech.objectmodel.FindException
 *  com.l7tech.objectmodel.Goid
 *  com.l7tech.objectmodel.IdentityHeader
 *  com.l7tech.objectmodel.SaveException
 *  com.l7tech.objectmodel.UpdateException
 *  com.l7tech.policy.assertion.credential.LoginCredentials
 *  com.l7tech.util.Config
 *  com.l7tech.util.ConfigFactory
 *  org.jetbrains.annotations.Nullable
 */
package com.l7tech.server.identity.ldap;

import com.l7tech.identity.BadCredentialsException;
import com.l7tech.identity.User;
import com.l7tech.identity.UserBean;
import com.l7tech.identity.ldap.BindOnlyLdapIdentityProviderConfig;
import com.l7tech.identity.ldap.BindOnlyLdapUser;
import com.l7tech.identity.ldap.LdapUrlBasedIdentityProviderConfig;
import com.l7tech.identity.ldap.LdapUser;
import com.l7tech.objectmodel.DeleteException;
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.objectmodel.SaveException;
import com.l7tech.objectmodel.UpdateException;
import com.l7tech.policy.assertion.credential.LoginCredentials;
import com.l7tech.server.identity.AuthenticationResult;
import com.l7tech.server.identity.ldap.BindOnlyLdapIdentityProvider;
import com.l7tech.server.identity.ldap.BindOnlyLdapUserManager;
import com.l7tech.server.identity.ldap.LdapClassLoaderRequired;
import com.l7tech.server.identity.ldap.LdapRuntimeConfig;
import com.l7tech.server.identity.ldap.LdapUtils;
import com.l7tech.util.Config;
import com.l7tech.util.ConfigFactory;
import java.util.Set;
import java.util.logging.Logger;
import java.util.regex.Pattern;
import org.jetbrains.annotations.Nullable;

@LdapClassLoaderRequired
public class BindOnlyLdapUserManagerImpl
implements BindOnlyLdapUserManager {
    private static final Logger a;
    private BindOnlyLdapIdentityProvider b;
    private BindOnlyLdapIdentityProviderConfig c;
    private LdapRuntimeConfig d;
    private Config e;
    private static final String[] f;

    public BindOnlyLdapUser findByPrimaryKey(String string) throws FindException {
        return this.findByLogin(string);
    }

    public BindOnlyLdapUser findByLogin(String string) throws FindException {
        this.b(string);
        return this.a(string, null);
    }

    public void delete(BindOnlyLdapUser bindOnlyLdapUser) throws DeleteException {
        throw new UnsupportedOperationException();
    }

    public void delete(String string) throws DeleteException, FindException {
        throw new UnsupportedOperationException();
    }

    public void deleteAll(Goid goid) throws DeleteException, FindException {
        throw new UnsupportedOperationException();
    }

    public void update(BindOnlyLdapUser bindOnlyLdapUser) throws UpdateException, FindException {
        throw new UnsupportedOperationException();
    }

    public String save(BindOnlyLdapUser bindOnlyLdapUser, Set<IdentityHeader> set) throws SaveException {
        throw new UnsupportedOperationException();
    }

    public String save(Goid goid, BindOnlyLdapUser bindOnlyLdapUser, Set<IdentityHeader> set) throws SaveException {
        throw new UnsupportedOperationException();
    }

    public BindOnlyLdapUser reify(UserBean userBean) {
        try {
            if (!userBean.getProviderId().equals((Object)this.c.getGoid())) {
                throw new IllegalArgumentException(f[0]);
            }
        }
        catch (UnsupportedOperationException unsupportedOperationException) {
            throw BindOnlyLdapUserManagerImpl.a(unsupportedOperationException);
        }
        BindOnlyLdapUser bindOnlyLdapUser = this.a(userBean.getLogin(), userBean.getSubjectDn());
        bindOnlyLdapUser.setProviderId(userBean.getProviderId());
        bindOnlyLdapUser.setLogin(userBean.getLogin());
        return bindOnlyLdapUser;
    }

    public void update(BindOnlyLdapUser bindOnlyLdapUser, Set<IdentityHeader> set) throws UpdateException, FindException {
        throw new UnsupportedOperationException();
    }

    public EntityHeaderSet<IdentityHeader> search(String string) throws FindException {
        return new EntityHeaderSet();
    }

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

    public BindOnlyLdapUser headerToUser(IdentityHeader identityHeader) {
        BindOnlyLdapUser bindOnlyLdapUser = this.a(identityHeader.getStrId(), null);
        bindOnlyLdapUser.setProviderId(this.c.getGoid());
        bindOnlyLdapUser.setLogin(identityHeader.getStrId());
        return bindOnlyLdapUser;
    }

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

    public EntityHeaderSet<IdentityHeader> findAllHeaders() throws FindException {
        return new EntityHeaderSet();
    }

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

    @Override
    public AuthenticationResult authenticatePasswordCredentials(LoginCredentials loginCredentials) throws BadCredentialsException, BindOnlyLdapUserManager.BadUsernamePatternException {
        String string = loginCredentials.getLogin();
        String string2 = this.makeDn(string);
        boolean bl2 = this.authenticateBasic(string2, new String(loginCredentials.getCredentials()));
        try {
            if (bl2) {
                return new AuthenticationResult((User)this.a(string, string2), loginCredentials.getSecurityTokens());
            }
        }
        catch (BadCredentialsException badCredentialsException) {
            throw BindOnlyLdapUserManagerImpl.a((Exception)((Object)badCredentialsException));
        }
        String[] stringArray = f;
        a.info(stringArray[2] + string);
        throw new BadCredentialsException(stringArray[4]);
    }

    @Override
    public String makeDn(String string) throws BindOnlyLdapUserManager.BadUsernamePatternException {
        String string2;
        this.a(string);
        String string3 = this.c.getBindPatternPrefix();
        if (string3 == null) {
            string3 = "";
        }
        if ((string2 = this.c.getBindPatternSuffix()) == null) {
            string2 = "";
        }
        return string3 + string + string2;
    }

    private void a(String string) throws BindOnlyLdapUserManager.BadUsernamePatternException {
        String string2;
        block8: {
            String string3;
            block7: {
                String[] stringArray = f;
                string3 = this.e.getProperty(stringArray[3]);
                try {
                    try {
                        if (string3 != null && string3.trim().length() >= 1) break block7;
                    }
                    catch (BindOnlyLdapUserManager.BadUsernamePatternException badUsernamePatternException) {
                        throw BindOnlyLdapUserManagerImpl.a(badUsernamePatternException);
                    }
                    string2 = f[1];
                    break block8;
                }
                catch (BindOnlyLdapUserManager.BadUsernamePatternException badUsernamePatternException) {
                    throw BindOnlyLdapUserManagerImpl.a(badUsernamePatternException);
                }
            }
            string2 = string3;
        }
        Pattern pattern = Pattern.compile(string2);
        try {
            if (!pattern.matcher(string).matches()) {
                throw new BindOnlyLdapUserManager.BadUsernamePatternException();
            }
        }
        catch (BindOnlyLdapUserManager.BadUsernamePatternException badUsernamePatternException) {
            throw BindOnlyLdapUserManagerImpl.a(badUsernamePatternException);
        }
    }

    private void b(String string) throws FindException {
        try {
            this.a(string);
        }
        catch (BindOnlyLdapUserManager.BadUsernamePatternException badUsernamePatternException) {
            throw new FindException(badUsernamePatternException.getMessage(), (Throwable)badUsernamePatternException);
        }
    }

    @Override
    public void configure(BindOnlyLdapIdentityProvider bindOnlyLdapIdentityProvider) {
        this.e = ConfigFactory.getCachedConfig();
        this.b = bindOnlyLdapIdentityProvider;
        this.c = (BindOnlyLdapIdentityProviderConfig)bindOnlyLdapIdentityProvider.getConfig();
    }

    @Override
    public void setLdapRuntimeConfig(LdapRuntimeConfig ldapRuntimeConfig) {
        this.d = ldapRuntimeConfig;
    }

    private BindOnlyLdapUser a(String string, @Nullable String string2) {
        return new BindOnlyLdapUser(this.c.getGoid(), string2, string);
    }

    /*
     * Unable to fully structure code
     */
    static {
        block10: {
            block9: {
                var5 = new String[5];
                var3_1 = 0;
                var2_2 = "!k\u001bR_`9\u0015v^D\u0010g/Tv\u0011T_`9\u0018w\u0010G_v3Tl\u0016I\f\",\u0006w\bI\u001bg.\u0004*6U\u0004%\u0017j\u001bD\u001al(\u001dy\u0012S_f5\u00108\u0010O\u000b\"=\u0001l\u0016E\u0011v5\u0017y\nE_d3\u00068";
                var4_3 = "!k\u001bR_`9\u0015v^D\u0010g/Tv\u0011T_`9\u0018w\u0010G_v3Tl\u0016I\f\",\u0006w\bI\u001bg.\u0004*6U\u0004%\u0017j\u001bD\u001al(\u001dy\u0012S_f5\u00108\u0010O\u000b\"=\u0001l\u0016E\u0011v5\u0017y\nE_d3\u00068".length();
                var1_4 = 42;
                var0_5 = -1;
lbl7:
                // 2 sources

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

                while (true) {
                    var5[var3_1++] = BindOnlyLdapUserManagerImpl.a(v0, BindOnlyLdapUserManagerImpl.c(v2));
                    if ((var0_5 += var1_4) < var4_3) {
                        var1_4 = var2_2.charAt(var0_5);
                        ** continue;
                    }
                    var2_2 = "c\u0007d+W\u0010J\u007f\u000f`\u000ew\u001cUa\u0002h>T\u0018S{\u0006w5 l\u0011`?a\u0017Sf\u0002i($\u001dNkCk4pYFz\u0017m>j\rNl\u0002q>";
                    var4_3 = "c\u0007d+W\u0010J\u007f\u000f`\u000ew\u001cUa\u0002h>T\u0018S{\u0006w5 l\u0011`?a\u0017Sf\u0002i($\u001dNkCk4pYFz\u0017m>j\rNl\u0002q>".length();
                    var1_4 = 25;
                    var0_5 = -1;
lbl22:
                    // 2 sources

                    while (true) {
                        v0 = 107;
                        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++] = BindOnlyLdapUserManagerImpl.a(v0, BindOnlyLdapUserManagerImpl.c(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;
            }
        }
        BindOnlyLdapUserManagerImpl.f = var5;
        BindOnlyLdapUserManagerImpl.a = Logger.getLogger(BindOnlyLdapUserManagerImpl.class.getName());
    }

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

    private static char[] c(String string) {
        char[] cArray = string.toCharArray();
        if (cArray.length < 2) {
            cArray = cArray;
            cArray[0] = (char)(cArray[0] ^ 0x4C);
        }
        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 -> 100;
                    case 1 -> 8;
                    case 2 -> 110;
                    case 3 -> 48;
                    case 4 -> 111;
                    case 5 -> 18;
                    default -> 76;
                })));
                ++n3;
                n4 = n4;
            } while (n4 > n3);
        }
        return new String(cArray2).intern();
    }
}