/*
 * Decompiled with CFR 0.152.
 */
package com.l7tech.server.transport.http;

import java.io.Serializable;

public class ConnectionId
implements Comparable,
Serializable {
    private static final long serialVersionUID = 1L;
    private static final char PARSE_SEPARATOR = '-';
    private static final ThreadLocal tlConnectionId;
    private final long _generation;
    private final long _sequence;
    private static final String[] a;

    public ConnectionId(long l2, long l3) {
        this._generation = l2;
        this._sequence = l3;
    }

    public ConnectionId(String string) {
        int n2 = string.indexOf(45);
        try {
            if (n2 < 0) {
                throw new IllegalArgumentException(a[0] + string + a[1]);
            }
        }
        catch (IllegalArgumentException illegalArgumentException) {
            throw ConnectionId.a(illegalArgumentException);
        }
        String string2 = string.substring(0, n2);
        String string3 = string.substring(n2 + 1);
        this._generation = Long.parseLong(string2, 16);
        this._sequence = Long.parseLong(string3, 16);
    }

    public long getGeneration() {
        return this._generation;
    }

    public long getSequence() {
        return this._sequence;
    }

    public int compareTo(Object object) {
        ConnectionId connectionId = (ConnectionId)object;
        try {
            if (this._generation > connectionId._generation) {
                return 1;
            }
        }
        catch (IllegalArgumentException illegalArgumentException) {
            throw ConnectionId.a(illegalArgumentException);
        }
        try {
            if (this._generation < connectionId._generation) {
                return -1;
            }
        }
        catch (IllegalArgumentException illegalArgumentException) {
            throw ConnectionId.a(illegalArgumentException);
        }
        try {
            if (this._sequence > connectionId._sequence) {
                return 1;
            }
        }
        catch (IllegalArgumentException illegalArgumentException) {
            throw ConnectionId.a(illegalArgumentException);
        }
        try {
            if (this._sequence < connectionId._sequence) {
                return -1;
            }
        }
        catch (IllegalArgumentException illegalArgumentException) {
            throw ConnectionId.a(illegalArgumentException);
        }
        return 0;
    }

    public boolean equals(Object object) {
        boolean bl2;
        block14: {
            block13: {
                try {
                    if (object == null) {
                        return false;
                    }
                }
                catch (IllegalArgumentException illegalArgumentException) {
                    throw ConnectionId.a(illegalArgumentException);
                }
                try {
                    if (object == this) {
                        return true;
                    }
                }
                catch (IllegalArgumentException illegalArgumentException) {
                    throw ConnectionId.a(illegalArgumentException);
                }
                try {
                    if (!(object instanceof ConnectionId)) {
                        return false;
                    }
                }
                catch (IllegalArgumentException illegalArgumentException) {
                    throw ConnectionId.a(illegalArgumentException);
                }
                ConnectionId connectionId = (ConnectionId)object;
                try {
                    try {
                        if (this._generation != connectionId._generation || this._sequence != connectionId._sequence) break block13;
                    }
                    catch (IllegalArgumentException illegalArgumentException) {
                        throw ConnectionId.a(illegalArgumentException);
                    }
                    bl2 = true;
                    break block14;
                }
                catch (IllegalArgumentException illegalArgumentException) {
                    throw ConnectionId.a(illegalArgumentException);
                }
            }
            bl2 = false;
        }
        return bl2;
    }

    public int hashCode() {
        return (int)(this._generation * 53L + this._sequence);
    }

    public String toString() {
        StringBuffer stringBuffer = new StringBuffer();
        stringBuffer.append(this.paddedHex(this._generation));
        stringBuffer.append('-');
        stringBuffer.append(this.paddedHex(this._sequence));
        return stringBuffer.toString();
    }

    public static void setConnectionId(ConnectionId connectionId) {
        tlConnectionId.set(connectionId);
    }

    public static ConnectionId getConnectionId() {
        return (ConnectionId)tlConnectionId.get();
    }

    private String paddedHex(long l2) {
        return this.paddedHex(Long.toHexString(l2), 16);
    }

    private String paddedHex(String string, int n2) {
        StringBuffer stringBuffer = new StringBuffer();
        try {
            while (stringBuffer.length() < n2 - string.length()) {
                stringBuffer.append("0");
            }
        }
        catch (IllegalArgumentException illegalArgumentException) {
            throw ConnectionId.a(illegalArgumentException);
        }
        stringBuffer.append(string);
        return stringBuffer.toString();
    }

    /*
     * Enabled aggressive block sorting
     */
    static {
        String[] stringArray = new String[2];
        int n2 = 0;
        String string = "\fa%G\u0012%\u0001\u0011g'G\u001dXm/\u0002\u0012q\u001d\u0017}`\u0004\u000e?\u0007\u0019`.G\u0000q!\u001dx5\u0002\u0012%:\u001c";
        int n3 = "\fa%G\u0012%\u0001\u0011g'G\u001dXm/\u0002\u0012q\u001d\u0017}`\u0004\u000e?\u0007\u0019`.G\u0000q!\u001dx5\u0002\u0012%:\u001c".length();
        int n4 = 11;
        int n5 = -1;
        while (true) {
            int n6 = ++n5;
            stringArray[n2++] = ConnectionId.a(43, ConnectionId.a(string.substring(n6, n6 + n4)));
            if ((n5 += n4) >= n3) {
                a = stringArray;
                tlConnectionId = new ThreadLocal();
                return;
            }
            n4 = string.charAt(n5);
        }
    }

    private static IllegalArgumentException a(IllegalArgumentException illegalArgumentException) {
        return illegalArgumentException;
    }

    private static char[] a(String string) {
        char[] cArray = string.toCharArray();
        if (cArray.length < 2) {
            cArray = cArray;
            cArray[0] = (char)(cArray[0] ^ 0x58);
        }
        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 -> 83;
                    case 1 -> 34;
                    case 2 -> 107;
                    case 3 -> 76;
                    case 4 -> 74;
                    case 5 -> 122;
                    default -> 88;
                })));
                ++n3;
                n4 = n4;
            } while (n4 > n3);
        }
        return new String(cArray2).intern();
    }
}