package jalview.log;

import java.util.HashMap;
import java.util.Map;

import jalview.bin.Console;
import jalview.util.Platform;

public abstract class JLogger implements JLoggerI
{
  protected String name;

  protected LogLevel level;

  private Object logger = null;

  private static Map<String, JLogger> registry = new HashMap<>();

  // implement these abstract methods
  protected abstract void loggerSetup();

  public abstract boolean loggerExists();

  protected abstract void loggerSetLevel(LogLevel level);

  protected abstract void loggerLogMessage(LogLevel level, String message,
          Throwable t);

  public static LogLevel toLevel(String levelString)
  {
    try
    {
      return LogLevel.valueOf(levelString);
    } catch (IllegalArgumentException e)
    {
      Console.error("Could not parse LogLevel '" + levelString + "'", e);
      return LogLevel.INFO;
    }
  }

  public static JLogger getLogger(String name)
  {
    return getLogger(name, LogLevel.INFO);
  }

  public static JLogger getLogger(String name, LogLevel loglevel)
  {
    return registry.containsKey(name) ? (JLogger) registry.get(name) : null;
  }

  protected JLogger()
  {
  }

  protected JLogger(String name, LogLevel level)
  {
    this.name = name;
    this.level = level;
    this.loggerSetup();
    this.registryStore();
  }

  protected void registryStore()
  {
    registry.put(this.name, this);
  }

  protected static boolean registryContainsKey(String name)
  {
    return registry.containsKey(name);
  }

  protected static JLogger registryGet(String name)
  {
    return registry.get(name);
  }

  public LogLevel getLevel()
  {
    return this.level;
  }

  public void setLevel(LogLevel level)
  {
    this.level = level;
    if (loggerExists())
      loggerSetLevel(level);
  }

  private boolean println(LogLevel level, String message, Throwable t)
  {
    if (!loggerExists() || Platform.isJS())
    {
      String logLine = String.format("%s: %s", level.toString(), message);
      System.out.println(logLine);
      if (t != null)
      {
        if (level.compareTo(LogLevel.DEBUG) <= 0)
          t.printStackTrace(System.err);
        else
          System.err.println(t.getMessage());
      }
      return false;
    }
    else
    {
      loggerLogMessage(level, message, t);
      return true;
    }
  }

  public void trace(String message)
  {
    trace(message, null);
  }

  public void trace(String message, Throwable t)
  {
    println(LogLevel.TRACE, message, t);
  }

  public void debug(String message)
  {
    debug(message, null);
  }

  public void debug(String message, Throwable t)
  {
    println(LogLevel.DEBUG, message, t);
  }

  public void info(String message)
  {
    info(message, null);
  }

  public void info(String message, Throwable t)
  {
    println(LogLevel.INFO, message, t);
  }

  public void warn(String message)
  {
    warn(message, null);
  }

  public void warn(String message, Throwable t)
  {
    println(LogLevel.WARN, message, t);
  }

  public void error(String message)
  {
    error(message, null);
  }

  public void error(String message, Throwable t)
  {
    println(LogLevel.ERROR, message, t);
  }

  public void fatal(String message)
  {
    fatal(message, null);
  }

  public void fatal(String message, Throwable t)
  {
    println(LogLevel.FATAL, message, t);
  }

  public boolean isDebugEnabled()
  {
    return level.compareTo(LogLevel.DEBUG) <= 0;
  }

  public boolean isTraceEnabled()
  {
    return level.compareTo(LogLevel.TRACE) <= 0;
  }
}