// 
// Decompiled by Procyon v0.6.0
// 

package com.google.common.flogger.backend;

import org.checkerframework.checker.nullness.compatqual.NullableDecl;
import java.util.logging.Level;
import java.util.Collections;
import com.google.common.flogger.LogContext;
import java.util.Collection;
import com.google.common.flogger.MetadataKey;
import java.util.Set;

public final class SimpleMessageFormatter
{
    private static final Set<MetadataKey<?>> DEFAULT_KEYS_TO_IGNORE;
    private static final MetadataHandler<MetadataKey.KeyValueHandler> DEFAULT_HANDLER;
    private static final LogMessageFormatter DEFAULT_FORMATTER;
    
    public static LogMessageFormatter getDefaultFormatter() {
        return SimpleMessageFormatter.DEFAULT_FORMATTER;
    }
    
    public static StringBuilder appendFormatted(final LogData logData, final MetadataProcessor metadata, final MetadataHandler<MetadataKey.KeyValueHandler> metadataHandler, final StringBuilder buffer) {
        BaseMessageFormatter.appendFormattedMessage(logData, buffer);
        return appendContext(metadata, metadataHandler, buffer);
    }
    
    public static StringBuilder appendContext(final MetadataProcessor metadataProcessor, final MetadataHandler<MetadataKey.KeyValueHandler> metadataHandler, final StringBuilder buffer) {
        final KeyValueFormatter kvf = new KeyValueFormatter("[CONTEXT ", " ]", buffer);
        metadataProcessor.process(metadataHandler, kvf);
        kvf.done();
        return buffer;
    }
    
    public static String getLiteralLogMessage(final LogData logData) {
        return MessageUtils.safeToString(logData.getLiteralArgument());
    }
    
    public static boolean mustBeFormatted(final LogData logData, final MetadataProcessor metadata, final Set<MetadataKey<?>> keysToIgnore) {
        return logData.getTemplateContext() != null || metadata.keyCount() > keysToIgnore.size() || !keysToIgnore.containsAll(metadata.keySet());
    }
    
    private static String format(final LogData logData, final MetadataProcessor metadata) {
        return mustBeFormatted(logData, metadata, SimpleMessageFormatter.DEFAULT_KEYS_TO_IGNORE) ? appendFormatted(logData, metadata, SimpleMessageFormatter.DEFAULT_HANDLER, new StringBuilder()).toString() : getLiteralLogMessage(logData);
    }
    
    @Deprecated
    public static void format(final LogData logData, final SimpleLogHandler receiver) {
        final MetadataProcessor metadata = MetadataProcessor.forScopeAndLogSite(Metadata.empty(), logData.getMetadata());
        receiver.handleFormattedLogMessage(logData.getLevel(), format(logData, metadata), metadata.getSingleValue(LogContext.Key.LOG_CAUSE));
    }
    
    @Deprecated
    static void format(final LogData logData, final SimpleLogHandler receiver, final Option option) {
        switch (option) {
            case WITH_LOG_SITE: {
                final StringBuilder buffer = new StringBuilder();
                if (MessageUtils.appendLogSite(logData.getLogSite(), buffer)) {
                    buffer.append(" ");
                }
                final String message = appendFormatted(logData, MetadataProcessor.forScopeAndLogSite(Metadata.empty(), logData.getMetadata()), SimpleMessageFormatter.DEFAULT_HANDLER, buffer).toString();
                final Throwable cause = logData.getMetadata().findValue(LogContext.Key.LOG_CAUSE);
                receiver.handleFormattedLogMessage(logData.getLevel(), message, cause);
                break;
            }
            case DEFAULT: {
                format(logData, receiver);
                break;
            }
        }
    }
    
    private SimpleMessageFormatter() {
    }
    
    static {
        DEFAULT_KEYS_TO_IGNORE = Collections.singleton(LogContext.Key.LOG_CAUSE);
        DEFAULT_HANDLER = MetadataKeyValueHandlers.getDefaultHandler(SimpleMessageFormatter.DEFAULT_KEYS_TO_IGNORE);
        DEFAULT_FORMATTER = new LogMessageFormatter() {
            @Override
            public StringBuilder append(final LogData logData, final MetadataProcessor metadata, final StringBuilder out) {
                return SimpleMessageFormatter.appendFormatted(logData, metadata, SimpleMessageFormatter.DEFAULT_HANDLER, out);
            }
            
            @Override
            public String format(final LogData logData, final MetadataProcessor metadata) {
                return format(logData, metadata);
            }
        };
    }
    
    @Deprecated
    enum Option
    {
        DEFAULT, 
        WITH_LOG_SITE;
    }
    
    @Deprecated
    public interface SimpleLogHandler
    {
        void handleFormattedLogMessage(final Level p0, final String p1, @NullableDecl final Throwable p2);
    }
}