/*
    * Copyright 2007 Hippo
    *
    * Licensed 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 nl.hippo.client.webdav.method;
  
  import java.io.IOException;
  
  import nl.hippo.client.api.ClientException;
  import nl.hippo.client.api.DocumentNotFoundException;
  import nl.hippo.client.webdav.HttpClientPool;
  import nl.hippo.client.webdav.WebdavConfig;
  import nl.hippo.client.webdav.WebdavLogger;
  import nl.hippo.client.webdav.WebdavRequest;
  import nl.hippo.client.webdav.WebdavResponse;
  import nl.hippo.client.webdav.caching.WebdavCacheHandler;
  
  import org.apache.commons.httpclient.DefaultMethodRetryHandler;
  import org.apache.commons.httpclient.HttpClient;
  import org.apache.commons.httpclient.HttpMethodBase;
  
  /**
   * Abstract base class for all Webdav methods.
   */
  abstract class WebdavMethod {
  
      interface WebdavMethodCallback {
          WebdavResponse doExec(HttpClient client) throws ClientException;
      }
  
      /**
       * Configuration of this WebdavMethod
       */
      protected WebdavConfig config;
  
      protected WebdavMethod(WebdavConfig config) {
          this.config = config;
      }
  
      /**
       * This is for HttpMethods like PUT which don't need a cache
       * @param callback
       * @return WebdavResponse
       * @throws ClientException
       */
      protected WebdavResponse execute(WebdavMethodCallback callback, WebdavRequest request) throws ClientException {
          WebdavResponse result = null;
          HttpClient client = null;
          try {
              try {
                  client = (HttpClient) HttpClientPool.getPool().borrowObject(config);
              } catch (Exception e) {
                  throw new ClientException("Exception while initializing HttpClient", e);
              }
              result = callback.doExec(client);
              if (result.isDocumentNotFound()) {
                  WebdavLogger.log.info(
                          new StringBuffer("Document not found : ")
                              .append("(")
                              .append(request.getMethod())
                              .append(") ")
                              .append(request.getPath().getFullPath())
                              .toString());
                  throw new DocumentNotFoundException("Document not found: " + request.getPath().getFullPath());
              } else if (!result.isValid()) {
                  WebdavLogger.log.error(
                       new StringBuffer("Server response is not valid, HTTP response code is ")
                           .append(result.getResponseCode())
                           .append(" (")
                           .append(request.getMethod())
                           .append(": ")
                           .append(request.getPath().getFullPath())
                           .append(")")
                           .toString());
              }
              
          } finally {
              try {
                  HttpClientPool.getPool().returnObject(config, client);
              } catch (Exception e) {
                  throw new ClientException("Exception while returning HttpClient to pool.", e);
              }
          }
  
          return result;
      }
  
      protected WebdavResponse execute(WebdavMethodCallback callback, WebdavRequest request, WebdavCacheHandler cache)
             throws ClientException {
         WebdavResponse result = cache.getWebdavResponse(request);
         
         // cached result
         if (result != null) {
             if (WebdavLogger.log.isDebugEnabled()) {
                 WebdavLogger.log.debug(new StringBuffer("Serving from cache: ").append("(").append(
                     request.getMethod()).append(") ").append(request.getPath().getFullPath()).toString());
             }
             if (result.isDocumentNotFound()) {
                 throw new DocumentNotFoundException("Document not found: " + request.getPath().getFullPath());
             }
             return result;
         }
         
 
         if (WebdavLogger.log.isDebugEnabled()) {
             WebdavLogger.log.debug(new StringBuffer("Trying to fetch from repository: ").append("(").append(
                 request.getMethod()).append(") ").append(request.getPath().getFullPath()).toString());
         }
         
         HttpClient client = null;
 
         try {
             client = (HttpClient) HttpClientPool.getPool().borrowObject(config);
         } catch (Exception e) {
             throw new ClientException("Exception while initializing HttpClient", e);
         }
         
         try {
             result = callback.doExec(client);
             if (!result.isValid()) {
                 if (result.isDocumentNotFound()) {
                     WebdavLogger.log.warn(new StringBuffer("Document not found : ").append("(").append(
                             request.getMethod()).append(") ").append(request.getPath().getFullPath()).toString());
                 } else {
                     WebdavLogger.log.info(new StringBuffer("Request to server failed, HTTP response code is ")
                             .append(result.getResponseCode()).append(" (").append(request.getMethod()).append(": ")
                             .append(request.getPath().getFullPath()).append(")").toString());
                     if (WebdavLogger.log.isDebugEnabled()) {
                         StringBuffer debugLog = new StringBuffer("Server response is:\n");
                         try {
                             debugLog.append(result.getResponseAsPrettyPrintedString("UTF-8"));
                         } catch (ClientException e) {
                             debugLog.append("Failed to log server response: ").append(e.getMessage());
                         }
                         WebdavLogger.log.debug(debugLog.toString());
                     }
                 }
             }
         } finally {
             try {
                 HttpClientPool.getPool().returnObject(config, client);
             } catch (Exception e) {
                 throw new ClientException("Exception while returning HttpClient to pool.", e);
             }
         }
         
         cache.store(result);
         if (result.isDocumentNotFound()) {
             throw new DocumentNotFoundException("Document not found: " + request.getPath().getFullPath());
         }
         return result;
     }
     
 
     /**
     * Retries up to three times
     *
     * @return httpclient response code
     */
     protected int executeMethod(HttpClient httpclient, HttpMethodBase method) throws IOException {
         DefaultMethodRetryHandler retryHandler = new DefaultMethodRetryHandler();
         retryHandler.setRetryCount(3);
         method.setMethodRetryHandler(retryHandler);
         return httpclient.executeMethod(method);
     }
 
 }