/*
 * Decompiled with CFR 0.152.
 * 
 * Could not load the following classes:
 *  com.l7tech.common.io.CertUtils
 */
package com.l7tech.server.security.keystore;

import com.l7tech.common.io.CertUtils;
import com.l7tech.server.security.keystore.g;
import java.security.Key;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.PublicKey;
import java.security.cert.Certificate;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.function.Supplier;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.stream.Collectors;

public class ReplaceCertificateChainManager {
    private static final Logger a;
    private final KeyStore b;
    private final Supplier<char[]> c;
    private final List<g> d;
    private static final String[] e;

    private ReplaceCertificateChainManager(KeyStore keyStore, Supplier<char[]> supplier, List<g> list) {
        this.b = keyStore;
        this.c = supplier;
        this.d = list;
    }

    public List<String> getImpactedKeys() {
        return this.d.stream().map(g2 -> g2.a).collect(Collectors.toList());
    }

    /*
     * Loose catch block
     */
    public void update(boolean bl2) throws ReplaceCertificateChainException {
        block6: {
            try {
                if (this.d.isEmpty()) break block6;
                try {
                    block7: {
                        if (!bl2) break block6;
                        break block7;
                        catch (Exception exception) {
                            throw ReplaceCertificateChainManager.a(exception);
                        }
                    }
                    a.log(Level.INFO, e[2], this.getImpactedKeys());
                    this.a();
                }
                catch (Exception exception) {
                    throw ReplaceCertificateChainManager.a(exception);
                }
            }
            catch (Exception exception) {
                this.rollback();
                throw new ReplaceCertificateChainException(e[1], exception);
            }
        }
    }

    private void a() throws KeyStoreException {
        for (g g2 : this.d) {
            this.b.setKeyEntry(g2.a, g2.b, this.c.get(), g2.d);
            g2.e = true;
        }
    }

    public void rollback() {
        for (g g2 : this.d) {
            if (!g2.e) continue;
            try {
                this.b.setKeyEntry(g2.a, g2.b, this.c.get(), g2.c);
            }
            catch (KeyStoreException keyStoreException) {
                a.log(Level.SEVERE, e[0] + g2.a);
            }
        }
    }

    /*
     * Enabled aggressive block sorting
     */
    static {
        String[] stringArray = new String[3];
        int n2 = 0;
        String string = "Z\"v5pb\u0004h,?+puPs1zyvcVh*y0vgPyc|1toJ<,yy~c]<4v-}&Ep*~*52Z\"v5pb\u0004h,?,ebEh&?:ptPu%v:trA< w8|hW<%p+5rLyct<l.W51I3{8aoJ{ck1p&Gy1k0soG}7zyvnEu-lysiV<7w<5mAe0%yn6Y";
        int n3 = "Z\"v5pb\u0004h,?+puPs1zyvcVh*y0vgPyc|1toJ<,yy~c]<4v-}&Ep*~*52Z\"v5pb\u0004h,?,ebEh&?:ptPu%v:trA< w8|hW<%p+5rLyct<l.W51I3{8aoJ{ck1p&Gy1k0soG}7zyvnEu-lysiV<7w<5mAe0%yn6Y".length();
        int n4 = 54;
        int n5 = -1;
        while (true) {
            int n6 = ++n5;
            stringArray[n2++] = ReplaceCertificateChainManager.a(99, ReplaceCertificateChainManager.a(string.substring(n6, n6 + n4)));
            if ((n5 += n4) >= n3) {
                e = stringArray;
                a = Logger.getLogger(ReplaceCertificateChainManager.class.getName());
                return;
            }
            n4 = string.charAt(n5);
        }
    }

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

    private static char[] a(String string) {
        char[] cArray = string.toCharArray();
        if (cArray.length < 2) {
            cArray = cArray;
            cArray[0] = (char)(cArray[0] ^ 0x47);
        }
        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 -> 127;
                    case 1 -> 32;
                    case 2 -> 124;
                    case 3 -> 58;
                    case 4 -> 118;
                    case 5 -> 101;
                    default -> 71;
                })));
                ++n3;
                n4 = n4;
            } while (n4 > n3);
        }
        return new String(cArray2).intern();
    }

    static class ReplaceCertificateChainException
    extends Exception {
        static final long serialVersionUID = 4318786330106228656L;

        ReplaceCertificateChainException(String string, Throwable throwable) {
            super(string, throwable);
        }

        ReplaceCertificateChainException(String string) {
            super(string);
        }
    }

    public static class Builder {
        private KeyStore a;
        private Supplier<char[]> b;
        private String c;
        private boolean d;
        private Certificate[] e;
        private boolean f;
        private static final String[] g;

        Builder a(boolean bl2) {
            this.f = bl2;
            return this;
        }

        Builder a(KeyStore keyStore) {
            this.a = keyStore;
            return this;
        }

        Builder a(Supplier<char[]> supplier) {
            this.b = supplier;
            return this;
        }

        Builder a(String string) {
            this.c = string;
            return this;
        }

        Builder b(boolean bl2) {
            this.d = bl2;
            return this;
        }

        Builder a(Certificate[] certificateArray) {
            this.e = certificateArray;
            return this;
        }

        public ReplaceCertificateChainManager build() throws ReplaceCertificateChainException {
            try {
                ArrayList<g> arrayList = new ArrayList<g>();
                Enumeration<String> enumeration = this.a.aliases();
                while (enumeration.hasMoreElements()) {
                    String string = enumeration.nextElement();
                    Key key = this.a.getKey(string, this.b.get());
                    Certificate[] certificateArray = this.a.getCertificateChain(string);
                    if (key == null) continue;
                    try {
                        if (certificateArray == null) {
                            continue;
                        }
                    }
                    catch (ReplaceCertificateChainException replaceCertificateChainException) {
                        throw Builder.a(replaceCertificateChainException);
                    }
                    if (string.equalsIgnoreCase(this.c)) continue;
                    Certificate[] certificateArray2 = this.a(certificateArray, this.e);
                    try {
                        if (certificateArray2 == null) continue;
                        a.log(Level.FINE, g[2], string);
                        arrayList.add(new g(string, key, certificateArray, certificateArray2));
                    }
                    catch (ReplaceCertificateChainException replaceCertificateChainException) {
                        throw Builder.a(replaceCertificateChainException);
                    }
                }
                return new ReplaceCertificateChainManager(this.a, this.b, arrayList);
            }
            catch (ReplaceCertificateChainException replaceCertificateChainException) {
                throw replaceCertificateChainException;
            }
            catch (Exception exception) {
                throw new ReplaceCertificateChainException(g[0], exception);
            }
        }

        private Certificate[] a(Certificate[] certificateArray, Certificate[] certificateArray2) throws ReplaceCertificateChainException {
            for (int i2 = 0; i2 < certificateArray.length; ++i2) {
                Certificate[] certificateArray3;
                int n2 = this.a(certificateArray2, (X509Certificate)certificateArray[i2]);
                if (n2 == -1) continue;
                int n3 = i2;
                int n4 = certificateArray2.length - n2;
                if (!CertUtils.arePublicKeysEqual((PublicKey)certificateArray[i2].getPublicKey(), (PublicKey)certificateArray2[n2].getPublicKey())) {
                    String[] stringArray = g;
                    certificateArray3 = String.format(stringArray[1], ((X509Certificate)certificateArray[i2]).getSubjectX500Principal().getName(stringArray[3]));
                    try {
                        a.log(Level.WARNING, (String)certificateArray3);
                        if (this.f) {
                            continue;
                        }
                    }
                    catch (ReplaceCertificateChainException replaceCertificateChainException) {
                        throw Builder.a(replaceCertificateChainException);
                    }
                    throw new ReplaceCertificateChainException((String)certificateArray3);
                }
                if (this.a(certificateArray, n3, certificateArray2, n2)) {
                    certificateArray3 = new Certificate[n3 + n4];
                    System.arraycopy(certificateArray, 0, certificateArray3, 0, n3);
                    System.arraycopy(certificateArray2, n2, certificateArray3, n3, n4);
                    return certificateArray3;
                }
                return null;
            }
            return null;
        }

        private boolean a(Certificate[] certificateArray, int n2, Certificate[] certificateArray2, int n3) {
            int n4;
            int n5 = n2;
            for (n4 = n3; n5 < certificateArray.length && n4 < certificateArray2.length; ++n5, ++n4) {
                if (certificateArray[n5].equals(certificateArray2[n4])) continue;
                return true;
            }
            return n5 < certificateArray.length || n4 < certificateArray2.length;
        }

        private int a(Certificate[] certificateArray, X509Certificate x509Certificate) {
            for (int i2 = 0; i2 < certificateArray.length; ++i2) {
                X509Certificate x509Certificate2 = (X509Certificate)certificateArray[i2];
                String[] stringArray = g;
                if (!x509Certificate2.getSubjectX500Principal().getName(stringArray[4]).equals(x509Certificate.getSubjectX500Principal().getName(stringArray[3]))) continue;
                return i2;
            }
            return -1;
        }

        private static ReplaceCertificateChainException a(ReplaceCertificateChainException replaceCertificateChainException) {
            return replaceCertificateChainException;
        }

        /*
         * Unable to fully structure code
         */
        static {
            block10: {
                block9: {
                    var5 = new String[5];
                    var3_1 = 0;
                    var2_2 = ")>EZc\u0013,\u001b0\fTs\u001e`\u000b\u007fOSt\u0003e\t6OWr\u0012,\f7M_h\u0004,\t0^\u0016r\u001fiO>JPc\u0014x\n;\f]c\u000e\u007fF!:[\u0016e\u0012~\u001b6J_e\u0016x\n\u007fHYc\u0004,\u00010X\u0016e\u0012~\u001b6JO&\u0003d\n\u007f\\Cd\u001be\f\u007fGS\u007fWj\u0000-\fBn\u0012,\u001f-E@g\u0003iO4IO&R\u007f6-*EZb\u001eb\b\u007fBSqWo\n-X_`\u001eo\u000e+I\u0016e\u001fm\u00061\fPi\u0005,\u0004:U\u0016q\u001ex\u0007\u007fMZo\u0016\u007fU\u007fW\u0006{";
                    var4_3 = ")>EZc\u0013,\u001b0\fTs\u001e`\u000b\u007fOSt\u0003e\t6OWr\u0012,\f7M_h\u0004,\t0^\u0016r\u001fiO>JPc\u0014x\n;\f]c\u000e\u007fF!:[\u0016e\u0012~\u001b6J_e\u0016x\n\u007fHYc\u0004,\u00010X\u0016e\u0012~\u001b6JO&\u0003d\n\u007f\\Cd\u001be\f\u007fGS\u007fWj\u0000-\fBn\u0012,\u001f-E@g\u0003iO4IO&R\u007f6-*EZb\u001eb\b\u007fBSqWo\n-X_`\u001eo\u000e+I\u0016e\u001fm\u00061\fPi\u0005,\u0004:U\u0016q\u001ex\u0007\u007fMZo\u0016\u007fU\u007fW\u0006{".length();
                    var1_4 = 56;
                    var0_5 = -1;
lbl7:
                    // 2 sources

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

                    while (true) {
                        var5[var3_1++] = Builder.a(v0, Builder.b(v2));
                        if ((var0_5 += var1_4) < var4_3) {
                            var1_4 = var2_2.charAt(var0_5);
                            ** continue;
                        }
                        var2_2 = "4\u0010f\r=K6\u00074\u0010f\r=K6";
                        var4_3 = "4\u0010f\r=K6\u00074\u0010f\r=K6".length();
                        var1_4 = 7;
                        var0_5 = -1;
lbl22:
                        // 2 sources

                        while (true) {
                            v0 = 18;
                            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++] = Builder.a(v0, Builder.b(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;
                }
            }
            Builder.g = var5;
        }

        private static char[] b(String string) {
            char[] cArray = string.toCharArray();
            if (cArray.length < 2) {
                cArray = cArray;
                cArray[0] = (char)(cArray[0] ^ 0x17);
            }
            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 -> 116;
                        case 1 -> 68;
                        case 2 -> 55;
                        case 3 -> 45;
                        case 4 -> 29;
                        case 5 -> 108;
                        default -> 23;
                    })));
                    ++n3;
                    n4 = n4;
                } while (n4 > n3);
            }
            return new String(cArray2).intern();
        }
    }
}