/*
    * This file is part of Waarp Project (named also Waarp or GG).
    *
    *  Copyright (c) 2019, Waarp SAS, and individual contributors by the @author
    *  tags. See the COPYRIGHT.txt in the distribution for a full listing of
    * individual contributors.
    *
    *  All Waarp Project is free software: you can redistribute it and/or
    * modify it under the terms of the GNU General Public License as published by
   * the Free Software Foundation, either version 3 of the License, or (at your
   * option) any later version.
   *
   * Waarp is distributed in the hope that it will be useful, but WITHOUT ANY
   * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
   * A PARTICULAR PURPOSE. See the GNU General Public License for more details.
   *
   *  You should have received a copy of the GNU General Public License along with
   * Waarp . If not, see <http://www.gnu.org/licenses/>.
   */
  
  /*
   * Copyright 2012 The Netty Project
   * The Netty Project licenses this file to you under the Apache License,
   * version 2.0 (the "License"); you may not use this file except in compliance
   * with the License. You may obtain a copy of the License at:
   * http://www.apache.org/licenses/LICENSE-2.0
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
   * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
   * License for the specific language governing permissions and limitations
   * under the License.
   */
  package org.waarp.common.logging;
  
  import java.io.Serializable;
  
  /**
   * A skeletal implementation of {@link WaarpLogger}. This class implements all
   * methods that have a
   * {@link WaarpLogLevel} parameter by default to call specific logger methods
   * such as {@link #info(String)} or
   * {@link #isInfoEnabled()}.
   */
  public abstract class AbstractWaarpLogger implements WaarpLogger, Serializable {
  
    private static final long serialVersionUID = -6382972526573193470L;
  
    private static final String EXCEPTION_MESSAGE = "Unexpected exception:";
  
    private final String name;
  
    /**
     * Creates a new instance.
     */
    protected AbstractWaarpLogger(final String name) {
      if (name == null) {
        throw new IllegalArgumentException("name");
      }
      this.name = name;
    }
  
    @Override
    public final String name() {
      return name;
    }
  
    @Override
    public final boolean isEnabled(final WaarpLogLevel level) {
      switch (level) {
        case TRACE:
          return isTraceEnabled();
        case DEBUG:
          return isDebugEnabled();
        case INFO:
          return isInfoEnabled();
        case WARN:
          return isWarnEnabled();
        case ERROR:
          return isErrorEnabled();
        default:
          return false;
      }
    }
  
    @Override
    public final void trace(final Throwable t) {
      trace(EXCEPTION_MESSAGE, t);
    }
  
    @Override
    public final void debug(final Throwable t) {
      debug(EXCEPTION_MESSAGE, t);
    }
  
    @Override
    public final void info(final Throwable t) {
      info(EXCEPTION_MESSAGE, t);
    }
  
   @Override
   public final void warn(final Throwable t) {
     warn(EXCEPTION_MESSAGE, t);
   }
 
   @Override
   public final void error(final Throwable t) {
     error(EXCEPTION_MESSAGE, t);
   }
 
   @Override
   public final void log(final WaarpLogLevel level, final String msg,
                         final Throwable cause) {
     switch (level) {
       case TRACE:
         trace(msg, cause);
         break;
       case DEBUG:
         debug(msg, cause);
         break;
       case INFO:
         info(msg, cause);
         break;
       case WARN:
         warn(msg, cause);
         break;
       case ERROR:
         error(msg, cause);
         break;
       default:
     }
   }
 
   @Override
   public final void log(final WaarpLogLevel level, final Throwable cause) {
     switch (level) {
       case TRACE:
         trace(cause);
         break;
       case DEBUG:
         debug(cause);
         break;
       case INFO:
         info(cause);
         break;
       case WARN:
         warn(cause);
         break;
       case ERROR:
         error(cause);
         break;
       default:
     }
   }
 
   @Override
   public final void log(final WaarpLogLevel level, final String msg) {
     switch (level) {
       case TRACE:
         trace(msg);
         break;
       case DEBUG:
         debug(msg);
         break;
       case INFO:
         info(msg);
         break;
       case WARN:
         warn(msg);
         break;
       case ERROR:
         error(msg);
         break;
       default:
     }
   }
 
   @Override
   public final void log(final WaarpLogLevel level, final String format,
                         final Object arg) {
     switch (level) {
       case TRACE:
         trace(format, arg);
         break;
       case DEBUG:
         debug(format, arg);
         break;
       case INFO:
         info(format, arg);
         break;
       case WARN:
         warn(format, arg);
         break;
       case ERROR:
         error(format, arg);
         break;
       default:
     }
   }
 
   @Override
   public final void log(final WaarpLogLevel level, final String format,
                         final Object argA, final Object argB) {
     switch (level) {
       case TRACE:
         trace(format, argA, argB);
         break;
       case DEBUG:
         debug(format, argA, argB);
         break;
       case INFO:
         info(format, argA, argB);
         break;
       case WARN:
         warn(format, argA, argB);
         break;
       case ERROR:
         error(format, argA, argB);
         break;
       default:
     }
   }
 
   @Override
   public final void log(final WaarpLogLevel level, final String format,
                         final Object... arguments) {
     switch (level) {
       case TRACE:
         trace(format, arguments);
         break;
       case DEBUG:
         debug(format, arguments);
         break;
       case INFO:
         info(format, arguments);
         break;
       case WARN:
         warn(format, arguments);
         break;
       case ERROR:
         error(format, arguments);
         break;
       default:
     }
   }
 
   protected final Object readResolve() {
     return WaarpLoggerFactory.getInstance(name());
   }
 
   /**
    * @param o
    *
    * @return the simple Class Name
    */
   public static String simpleClassName(final Object o) {
     if (o == null) {
       return "null_object";
     } else {
       return simpleClassName(o.getClass());
     }
   }
 
   /**
    * @param clazz
    *
    * @return the simple Class Name
    */
   public static String simpleClassName(final Class<?> clazz) {
     if (clazz == null) {
       return "null_class";
     }
     final Package pkg = clazz.getPackage();
     if (pkg != null) {
       return clazz.getName().substring(pkg.getName().length() + 1);
     } else {
       return clazz.getName();
     }
   }
 
   @Override
   public String toString() {
     return simpleClassName(this) + '(' + name() + ')';
   }
 
   private static final int BASELEVEL;
   private static final int LOGLEVEL;
 
   /**
    * Determine the good level
    *
    * @return the default base level
    */
   private static int detectLoggingBaseLevel() {
     final StackTraceElement[] elt = Thread.currentThread().getStackTrace();
     int i;
     for (i = 0; i < elt.length; i++) {
       if ("detectLoggingBaseLevel".equalsIgnoreCase(elt[i].getMethodName())) {
         break;
       }
     }
     return i;
   }
 
   static {
     BASELEVEL = detectLoggingBaseLevel();
     LOGLEVEL = BASELEVEL + 2;
   }
 
   /**
    * To be used in message for logger (rank 2) like
    * logger.warn(code,"message:"+getImmediateMethodAndLine(),null);
    *
    * @return "ClassAndMethodName(FileName:LineNumber)"
    */
   public static String getImmediateMethodAndLine() {
     final StackTraceElement elt =
         Thread.currentThread().getStackTrace()[BASELEVEL + 1];
     return getMethodAndLine(elt);
   }
 
   // FIXME TODO for JDK6 IBM add 1 (2->3 and 3->4)
 
   /**
    * To be used only by Logger (rank 5)
    *
    * @return "MethodName(FileName:LineNumber)"
    */
   public static String getLoggerMethodAndLine() {
     final StackTraceElement elt =
         Thread.currentThread().getStackTrace()[LOGLEVEL];
     return getMethodAndLine(elt);
   }
 
   /**
    * To be used only by Logger (rank 5)
    *
    * @return "MethodName(FileName:LineNumber)"
    */
   public static String getLoggerMethodAndLineCallee(final int deep) {
     final StackTraceElement elt =
         Thread.currentThread().getStackTrace()[LOGLEVEL + deep];
     return getMethodAndLine(elt);
   }
 
   /**
    * @param rank is the current depth of call+1 (immediate = 1+1=2)
    *
    * @return "ClassAndMethodName(FileName:LineNumber)"
    */
   protected static String getRankMethodAndLine(final int rank) {
     final StackTraceElement elt = Thread.currentThread().getStackTrace()[rank];
     return getMethodAndLine(elt);
   }
 
 
   /**
    * @param elt
    *
    * @return "MethodName(FileName:LineNumber) " from elt
    */
   private static String getMethodAndLine(final StackTraceElement elt) {
     final StringBuilder builder =
         new StringBuilder(elt.getClassName()).append('.')
                                              .append(elt.getMethodName())
                                              .append('(')
                                              .append(elt.getFileName())
                                              .append(':')
                                              .append(elt.getLineNumber())
                                              .append(") : ");
     if (WaarpLoggerFactory.localName != null) {
       builder.append('[').append(WaarpLoggerFactory.localName).append("] ");
     }
     return builder.toString();
   }
 
 }