/*
 * Decompiled with CFR 0.152.
 * 
 * Could not load the following classes:
 *  com.google.gson.Gson
 *  com.google.gson.JsonSyntaxException
 *  com.l7tech.common.log.HybridDiagnosticContext
 *  com.l7tech.gateway.common.log.SinkConfiguration
 */
package com.l7tech.server.log;

import com.google.gson.Gson;
import com.google.gson.JsonSyntaxException;
import com.l7tech.common.log.HybridDiagnosticContext;
import com.l7tech.gateway.common.log.SinkConfiguration;
import com.l7tech.server.audit.AuditLogFormatter;
import com.l7tech.server.log.MessageCategory;
import com.l7tech.server.log.MessageSinkSupport;
import com.l7tech.server.log.a;
import com.l7tech.server.log.b;
import java.io.FileDescriptor;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.text.MessageFormat;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.logging.Handler;
import java.util.logging.LogRecord;
import java.util.logging.Logger;
import java.util.logging.StreamHandler;

public class ConsoleMessageSink
extends MessageSinkSupport {
    private final Handler e;
    private static final Function<String, String> f = new b();

    @Override
    public void close() {
    }

    @Override
    public List<Handler> getHandlers() {
        return Collections.singletonList(this.e);
    }

    ConsoleMessageSink(SinkConfiguration sinkConfiguration, Handler handler) {
        super(sinkConfiguration);
        this.e = handler;
    }

    @Override
    void processMessage(MessageCategory messageCategory, LogRecord logRecord) {
        if (this.e != null) {
            this.e.publish(logRecord);
        }
    }

    static Handler b() {
        Handler[] handlerArray;
        Handler handler = null;
        Logger logger = Logger.getLogger("");
        for (Handler handler2 : handlerArray = logger.getHandlers()) {
            if (!(handler2 instanceof L7ConsoleHandler)) continue;
            handler = handler2;
            break;
        }
        return handler;
    }

    public static class L7ConsoleHandler
    extends StreamHandler {
        private static final OutputStream a;
        private static final String[] b;

        public L7ConsoleHandler() {
            this.setOutputStream(a);
        }

        @Override
        public synchronized void publish(LogRecord logRecord) {
            if (AuditLogFormatter.isFormatJson()) {
                String[] stringArray;
                Map<String, String> map;
                Gson gson = new Gson();
                try {
                    map = (Map)gson.fromJson(logRecord.getMessage(), new a(this).getType());
                }
                catch (JsonSyntaxException jsonSyntaxException) {
                    map = new HashMap<String, String>();
                    try {
                        stringArray = b;
                        map.put(stringArray[10], new MessageFormat(logRecord.getMessage()).format(logRecord.getParameters()));
                    }
                    catch (Exception exception) {
                        stringArray = b;
                        map.put(stringArray[4], logRecord.getMessage());
                    }
                }
                if (map == null) {
                    map = new HashMap();
                }
                try {
                    map.computeIfAbsent(b[3], f);
                    map.computeIfAbsent(b[11], f);
                    map.computeIfAbsent(b[9], f);
                    map.computeIfAbsent(b[6], f);
                    map.computeIfAbsent(b[0], f);
                    if (HybridDiagnosticContext.getFirst((String)b[8]) != null) {
                        map.computeIfAbsent(b[2], f);
                    }
                }
                catch (JsonSyntaxException jsonSyntaxException) {
                    throw L7ConsoleHandler.a(jsonSyntaxException);
                }
                stringArray = b;
                map.computeIfAbsent(stringArray[1], f);
                map.computeIfAbsent(stringArray[5], f);
                map.computeIfAbsent(stringArray[7], f);
                logRecord.setMessage(gson.toJson(map));
            }
            super.publish(logRecord);
            this.flush();
        }

        @Override
        public synchronized void close() throws SecurityException {
            this.flush();
        }

        /*
         * Unable to fully structure code
         */
        static {
            block10: {
                block9: {
                    var5 = new String[12];
                    var3_1 = 0;
                    var2_2 = "\u0006n A\f\u0019p6\u001e\u0005\u0017A\u0007x+V\u001b\u0007\u0006n AD\u0017V\u0007\u0000x7E\u0000\u001dW\u0007\u001ex6@\b\u0019W\t\u0010q,V\u0007\n\u001f\u001am\u000e\u0016p$Z\u0005S^\u001an1V\u0007\u001b@\n\u0001x4F\f\rF^t!\u0007\u0006n AD\u0017V\u000b\u001ft6G\f\u0010\u001f\u0003r7G";
                    var4_3 = "\u0006n A\f\u0019p6\u001e\u0005\u0017A\u0007x+V\u001b\u0007\u0006n AD\u0017V\u0007\u0000x7E\u0000\u001dW\u0007\u001ex6@\b\u0019W\t\u0010q,V\u0007\n\u001f\u001am\u000e\u0016p$Z\u0005S^\u001an1V\u0007\u001b@\n\u0001x4F\f\rF^t!\u0007\u0006n AD\u0017V\u000b\u001ft6G\f\u0010\u001f\u0003r7G".length();
                    var1_4 = 4;
                    var0_5 = -1;
lbl7:
                    // 2 sources

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

                    while (true) {
                        var5[var3_1++] = L7ConsoleHandler.a(v0, L7ConsoleHandler.a(v2));
                        if ((var0_5 += var1_4) < var4_3) {
                            var1_4 = var2_2.charAt(var0_5);
                            ** continue;
                        }
                        var2_2 = ">X\u0016`(9w\u0013 X\u0017e =w~[\n\u007f-;`~M\u0004g!";
                        var4_3 = ">X\u0016`(9w\u0013 X\u0017e =w~[\n\u007f-;`~M\u0004g!".length();
                        var1_4 = 7;
                        var0_5 = -1;
lbl22:
                        // 2 sources

                        while (true) {
                            v0 = 90;
                            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++] = L7ConsoleHandler.a(v0, L7ConsoleHandler.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;
                }
            }
            L7ConsoleHandler.b = var5;
            L7ConsoleHandler.a = new FileOutputStream(FileDescriptor.err);
        }

        private static JsonSyntaxException a(JsonSyntaxException jsonSyntaxException) {
            return jsonSyntaxException;
        }

        private static char[] a(String string) {
            char[] cArray = string.toCharArray();
            if (cArray.length < 2) {
                cArray = cArray;
                cArray[0] = (char)(cArray[0] ^ 0x48);
            }
            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 -> 9;
                        case 1 -> 103;
                        case 2 -> 63;
                        case 3 -> 73;
                        case 4 -> 19;
                        case 5 -> 4;
                        default -> 72;
                    })));
                    ++n3;
                    n4 = n4;
                } while (n4 > n3);
            }
            return new String(cArray2).intern();
        }
    }
}