/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF 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.apache.uima.aae.error;

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

import org.apache.uima.UIMAFramework;
import org.apache.uima.aae.InputChannel;
import org.apache.uima.aae.UIMAEE_Constants;
import org.apache.uima.aae.controller.AggregateAnalysisEngineController;
import org.apache.uima.aae.controller.AnalysisEngineController;
import org.apache.uima.aae.controller.Endpoint;
import org.apache.uima.aae.controller.PrimitiveAnalysisEngineController;
import org.apache.uima.aae.message.AsynchAEMessage;
import org.apache.uima.aae.monitor.Monitor;
import org.apache.uima.aae.monitor.statistics.LongNumericStatistic;
import org.apache.uima.aae.monitor.statistics.Statistic;
import org.apache.uima.util.Level;

public abstract class ErrorHandlerBase {
  private static final Class CLASS_NAME = ErrorHandlerBase.class;

  protected Map endpointThresholdMap;

  public ErrorHandlerBase(Map anEndpointThreasholdMap) {
    endpointThresholdMap = anEndpointThreasholdMap;
  }

  public ErrorHandlerBase() {
    endpointThresholdMap = new HashMap();
  }

  public Map getEndpointThresholdMap() {
    return endpointThresholdMap;
  }

  protected String getAction(String aThresholdToCheck, String endpoint) {
    Threshold threshold = getThreshold(aThresholdToCheck, endpoint);
    if (threshold != null) {
      return threshold.getAction();
    }
    return null;
  }

  protected String getDelegateKey(Endpoint anEndpoint, AnalysisEngineController aController) {
    String key = null;
    if (aController instanceof PrimitiveAnalysisEngineController
            && aController.isTopLevelComponent()) {
      key = aController.getServiceEndpointName();
    } else if (anEndpoint != null) {
      key = anEndpoint.getEndpoint();

    }
    return key;

  }

  protected boolean isValidActionForController(String anAction, AnalysisEngineController aController) {
    if (aController instanceof PrimitiveAnalysisEngineController) {
      if (ErrorHandler.DISABLE.equalsIgnoreCase(anAction)) {
        return false;
      }
    }
    return true;
  }

  protected Threshold getThreshold(String aThresholdToCheck, String endpoint) {
    if (endpointThresholdMap.containsKey(endpoint)) {
      EndpointThresholds endpointThresholds = (EndpointThresholds) endpointThresholdMap
              .get(endpoint);
      Threshold threshold = endpointThresholds.getThreshold(aThresholdToCheck);
      return threshold;
    }
    return null;
  }

  protected boolean exceedsThreshold(String aThresholdToCheck, String endpoint,
          AnalysisEngineController controller) {
    Threshold threshold = getThreshold(aThresholdToCheck, endpoint);
    if (threshold != null) {
      Monitor monitor = controller.getMonitor();
      Statistic statistic = null;
      if ((statistic = monitor.getStatistic(endpoint, aThresholdToCheck)) == null) {
        statistic = new LongNumericStatistic(aThresholdToCheck);
        monitor.addStatistic(endpoint, statistic);
      }
      if (statistic instanceof LongNumericStatistic) {
        ((LongNumericStatistic) statistic).increment();
        if (threshold.exceeded(((LongNumericStatistic) statistic).getValue())) {
          return true;
        }
      }
    }
    return false;
  }

  protected boolean exceedsThreshold(Threshold aThreshold, String aThresholdToCheck,
          String endpoint, AnalysisEngineController controller) {
    if (aThreshold != null) {
      Monitor monitor = controller.getMonitor();
      Statistic statistic = null;

      if ((statistic = monitor.getStatistic(endpoint, aThresholdToCheck)) == null) {
        statistic = new LongNumericStatistic(aThresholdToCheck);
        monitor.addStatistic(endpoint, statistic);
      }
      if (Monitor.GetMetaErrorRetryCount.equals(aThresholdToCheck)
              || Monitor.ProcessErrorRetryCount.equals(aThresholdToCheck)) {
        return aThreshold.maxRetriesExceeded(((LongNumericStatistic) statistic).getValue());
      } else {
        return aThreshold.exceeded(((LongNumericStatistic) statistic).getValue());
      }
    }
    return false;
  }

  protected String getEndpointName(AnalysisEngineController aController, ErrorContext anErrorContext) {
    String key = null;
    if (aController instanceof PrimitiveAnalysisEngineController) {
      key = aController.getServiceEndpointName();
    } else {
      Endpoint endpoint = (Endpoint) anErrorContext.get(AsynchAEMessage.Endpoint);
      key = endpoint.getEndpoint();
    }

    return key;

  }

  protected boolean isHandlerForError(ErrorContext anErrorContext, int anExpectedCommand) {
    if (anErrorContext != null) {
      int command = (Integer) anErrorContext.get(AsynchAEMessage.Command);
      return (command == anExpectedCommand) ? true : false;
    }
    return false;
  }

  protected boolean shouldRetry(Threshold aThreshold, String aKindOfRetryCount, String aKey,
          AnalysisEngineController aController) {
    return (exceedsThreshold(aThreshold, aKindOfRetryCount, aKey, aController) == true) ? false
            : true;
  }

  protected Threshold getThreshold(Endpoint anEndpoint, Map aDelegateMap,
          AnalysisEngineController aController) {
    Threshold threshold = null;
    if (aController instanceof AggregateAnalysisEngineController && anEndpoint != null) {
      String key = ((AggregateAnalysisEngineController) aController).lookUpDelegateKey(anEndpoint
              .getEndpoint());
      if (aDelegateMap.containsKey(key)) {
        threshold = (Threshold) aDelegateMap.get(key);
      }
    }
    return threshold;
  }

  protected synchronized void incrementStatistic(Monitor aMonitor, String aComponentName,
          String aStatistic) {
    Statistic statistic = aMonitor.getStatistic(aComponentName, aStatistic);
    if (statistic == null) {
      statistic = new LongNumericStatistic(aStatistic);
      aMonitor.addStatistic(aComponentName, statistic);
    }

    if (statistic instanceof LongNumericStatistic) {
      ((LongNumericStatistic) statistic).increment();
    }
  }

  protected boolean retryLastCommand(int aRetryCommand, Endpoint anEndpoint,
          AnalysisEngineController aController, String aKey, Threshold aThreshold,
          ErrorContext anErrorContext) {
    boolean done = false;

    if ( aController == null ) {
    	return false;
    }
    String errorCounterKind = (aRetryCommand == AsynchAEMessage.GetMeta) ? Monitor.GetMetaErrorRetryCount
            : Monitor.ProcessErrorRetryCount;
    // Handle errors in a loop. Retry until retry threshold is reached
    int retryCount = 0;
    while (!done) {
      /*
       * if ( !exceedsThreshold(aThreshold, errorCounterKind, aKey, aController)) { // Increment
       * number of retries incrementStatistic(aController.getMonitor(), aKey, errorCounterKind ); }
       */
      // Check if exceeding threshold
      if (shouldRetry(aThreshold, errorCounterKind, aKey, aController)) {
        incrementStatistic(aController.getMonitor(), aKey, errorCounterKind);
        try {
          switch (aRetryCommand) {
            case AsynchAEMessage.GetMeta:
              if (UIMAFramework.getLogger(CLASS_NAME).isLoggable(Level.INFO)) {
                  UIMAFramework.getLogger(CLASS_NAME).logrb(Level.INFO, CLASS_NAME.getName(),
                          "retryLastCommand", UIMAEE_Constants.JMS_LOG_RESOURCE_BUNDLE,
                          "UIMAEE_retrying_getmeta__INFO", new Object[] { aController.getComponentName(), anEndpoint.getDelegateKey() });
              }

              
              // Retry GetMeta
              ((AggregateAnalysisEngineController) aController).retryMetadataRequest(anEndpoint);
              break;

            case AsynchAEMessage.Process:
              if ( anErrorContext.containsKey(AsynchAEMessage.Endpoint)) {
                Endpoint masterEndpoint = (Endpoint)anErrorContext.get(AsynchAEMessage.Endpoint);

                if (aController instanceof AggregateAnalysisEngineController && (masterEndpoint != null && masterEndpoint.getStatus() == Endpoint.FAILED)) {
                  // Fetch an InputChannel that handles messages for a given delegate
                  InputChannel iC = aController.getReplyInputChannel(masterEndpoint.getDelegateKey());
                  // Create a new Listener, new Temp Queue and associate the listener with the Input Channel
                  iC.createListener(masterEndpoint.getDelegateKey(), null);
                  iC.removeDelegateFromFailedList(masterEndpoint.getDelegateKey());
                  anEndpoint.setDestination(masterEndpoint.getDestination());
                }
                
              }
              String casReferenceId = (String) anErrorContext.get(AsynchAEMessage.CasReference);
              if (UIMAFramework.getLogger(CLASS_NAME).isLoggable(Level.INFO)) {
                  UIMAFramework.getLogger(CLASS_NAME).logrb(Level.INFO, CLASS_NAME.getName(),
                          "retryLastCommand", UIMAEE_Constants.JMS_LOG_RESOURCE_BUNDLE,
                          "UIMAEE_retrying_process_cas__INFO", new Object[] { aController.getComponentName(), casReferenceId, anEndpoint.getDelegateKey() });
              }
              ((AggregateAnalysisEngineController) aController).retryProcessCASRequest(
                      casReferenceId, anEndpoint, true);
              break;
          }
          return true;
        } catch (Exception e) {
          anEndpoint.cancelTimer();
          if (UIMAFramework.getLogger(CLASS_NAME).isLoggable(Level.WARNING)) {
              UIMAFramework.getLogger(CLASS_NAME).logrb(Level.WARNING, CLASS_NAME.getName(),
                      "retryLastCommand", UIMAEE_Constants.JMS_LOG_RESOURCE_BUNDLE,
                      "UIMAEE_service_exception_WARNING", aController.getComponentName());

            UIMAFramework.getLogger(CLASS_NAME).logrb(Level.WARNING, getClass().getName(),
                    "retryLastCommand", UIMAEE_Constants.JMS_LOG_RESOURCE_BUNDLE,
                    "UIMAEE_exception__WARNING", e);
          }
        }
      } else {
        done = true;
      }
    }
    return false;
  }

  protected synchronized boolean exceedsThresholdWithinWindow(Monitor aMonitor, String aStat,
          String aComponent, Threshold aThreshold) {
    LongNumericStatistic currentErrorCountStat = aMonitor
            .getLongNumericStatistic(aComponent, aStat);
    LongNumericStatistic currentProcessCountStat = aMonitor.getLongNumericStatistic(aComponent,
            Monitor.ProcessCount);
    long numberOfErrors = currentErrorCountStat.getValue();
    // Check if threshold exceeded
    if (numberOfErrors > 0 && aThreshold.getThreshold() > 0
            && numberOfErrors % aThreshold.getThreshold() == 0) {
      return true;
    }
    // Check if reached end of window. If so, begin counting against a new window
    if (aThreshold.getThreshold() > 0 && aThreshold.getWindow() > 0
            && currentProcessCountStat.getValue() % aThreshold.getWindow() == 0) {
      aMonitor.resetCountingStatistic(aComponent, aStat);
    }
    return false;
  }

  protected boolean continueOnError(String aDelegateKey, Threshold aThreshold,
          String aCasReferenceId, Throwable t, AnalysisEngineController aController) {
    try {
      if (aThreshold.getContinueOnRetryFailure() == true
              && ((AggregateAnalysisEngineController) aController).continueOnError(aCasReferenceId,
                      aDelegateKey, (Exception) t)) {
        return true;
      }
    } catch (Exception e) {
      if ( aController != null ) {
        UIMAFramework.getLogger(CLASS_NAME).logrb(Level.WARNING, CLASS_NAME.getName(),
                "continueOnError", UIMAEE_Constants.JMS_LOG_RESOURCE_BUNDLE,
                "UIMAEE_service_exception_WARNING", aController.getComponentName());
      }

      if (UIMAFramework.getLogger(CLASS_NAME).isLoggable(Level.WARNING)) {
        UIMAFramework.getLogger(CLASS_NAME).logrb(Level.WARNING, getClass().getName(),
                "continueOnError", UIMAEE_Constants.JMS_LOG_RESOURCE_BUNDLE,
                "UIMAEE_exception__WARNING", e); 
      }

    }
    return false;
  }

}