/*
    * 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;
  
  import java.io.ByteArrayInputStream;
  import java.io.ByteArrayOutputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.UnsupportedEncodingException;
  import java.util.Map;
  
  import javax.xml.transform.stream.StreamResult;
  import javax.xml.transform.stream.StreamSource;
  
  import nl.hippo.client.api.ClientException;
  import nl.hippo.client.api.content.RawResponse;
  import nl.hippo.client.api.service.NOPCachingService;
  import nl.hippo.client.webdav.caching.WebdavCacheHandler;
  import nl.hippo.client.webdav.utils.Converters;
  import nl.hippo.client.webdav.utils.Interpolation;
  import nl.hippo.client.webdav.utils.XslTransformer;
  
  import org.apache.commons.lang.builder.EqualsBuilder;
  import org.apache.commons.lang.builder.HashCodeBuilder;
  import org.xml.sax.helpers.DefaultHandler;
  
  /**
   * Result class returned by the execute() method of WebdavMethod.
   * <p>
   * Implemented as a Value Object meaning:
   * <ul>
   * <li> The identity of an instance is solely based on it's property values:
   * instances with equal values are interchangable. </li>
   * <li> Instances are threadsafe over multiple threads running concurrently, and
   * may be used multiple times in a given session. </li>
   * </ul>
   */
  public class WebdavResponse implements RawResponse {
  
      private static final long serialVersionUID = 1L;
  
      /**
       * The response is stored as a byte[] and not as a Stream.
       * 
       * Partly because the original response stream returned by HttpClient is an
       * AutoCloseInputStream which does what the name imlies and can only be read
       * once. (see comment in Search.PatchedSearchMethod)
       * 
       * Partly because byte arrays are probably easier to cache than streams.
       * 
       * TODO: Think about a streaming WebdavResponse implementation for large
       * binary content (movies etc). This probably either means exposing the
       * commons-httpclient internal AutoCloseInputStream class or something with
       * PipedInput- and -OutputStreams.
       */
      private byte[] responseAsBytes;
  
      /**
       * The Http response code (207, 404, etc.)
       */
      private int responseCode;
  
      private WebdavRequest request;
  
      public WebdavResponse() {
          // Nothing to do
      }
  
      public WebdavResponse(int responseCode) {
          this.responseCode = responseCode;
      }
  
      public WebdavResponse(byte[] responseAsBytes) {
          this.responseCode = 200;
          this.responseAsBytes = responseAsBytes;
      }
  
      public WebdavResponse(int responseCode, byte[] responseAsBytes, WebdavRequest request) {
          this.responseCode = responseCode;
          this.responseAsBytes = responseAsBytes;
          this.request = request;
      }
  
      public boolean isValid() {
          return responseCode >= 200 && responseCode <= 299;
      }
     
     public boolean isDocumentNotFound() {
         return responseCode == 404;
     }
 
     /**
      * Returns the Http response code (207, 404, etc.)
      * 
      * @return The Http response code (207, 404, etc.)
      */
     public int getResponseCode() {
         return responseCode;
     }
 
     public WebdavRequest getRequest() {
         return request;
     }
 
     public byte[] getResponseAsBytes() {
         return responseAsBytes;
     }
 
     public InputStream getResponseAsStream() {
         return Converters.bytes2Stream(responseAsBytes);
     }
 
     public String getResponseAsString(String encoding) throws ClientException {
         try {
             return Converters.bytes2String(responseAsBytes, encoding);
         } catch (UnsupportedEncodingException e) {
             throw new ClientException("Unsupported encoding.", e);
         }
     }
 
     public String getResponseAsPrettyPrintedString(String encoding) throws ClientException {
         try {
             return Converters.bytes2PrettyPrintedString(responseAsBytes, encoding);
         } catch (IOException e) {
             throw new ClientException("Exception while prettyprinting response.", e);
         }
     }
 
     public org.w3c.dom.Document getResponseAsDom() throws ClientException {
         return Converters.bytes2Dom(responseAsBytes);
     }
 
     public void streamResponseToSaxContentHandler(DefaultHandler handler) throws ClientException {
         Converters.bytes2SaxContentHandler(responseAsBytes, handler);
     }
     
     public WebdavResponse transform(WebdavResponse xsl) throws ClientException {
         return transform(xsl, new WebdavCacheHandler(new NOPCachingService()));
     }
 
     public WebdavResponse transform(WebdavResponse xsl, WebdavCacheHandler cache) throws ClientException {
         if (responseAsBytes == null) {
             WebdavLogger.log.warn("Cannot transform empty response");
             return this;
         }
         WebdavResponse transformedResponse = null;
         if (request != null) {
             transformedResponse = cache.getWebdavResponse(request.transformedVariant());
         }
         if (transformedResponse == null) {
             if (WebdavLogger.log.isDebugEnabled()) {
                 WebdavLogger.log.debug("Xsl transform");
             }
             StreamSource source = new StreamSource(new ByteArrayInputStream(responseAsBytes));
             StreamResult target = new StreamResult(new ByteArrayOutputStream());
             XslTransformer.transform(xsl, source, target);
 
             byte[] transformedContent = ((ByteArrayOutputStream) target.getOutputStream()).toByteArray();
 
             if (request != null) {
                 WebdavRequest transformedRequest = request.transformedVariant();
                 transformedResponse = new WebdavResponse(responseCode, transformedContent, transformedRequest);
                 cache.store(transformedResponse);
             } else {
                 transformedResponse = new WebdavResponse(transformedContent);
             }
         }
         return transformedResponse;
     }
 
     public WebdavResponse interpolate(Map params) {
         WebdavResponse result;
         try {
             String content = getResponseAsString("UTF-8");
             String interpolatedContent = Interpolation.interpolate(content, params);
             result = new WebdavResponse(responseCode, interpolatedContent.getBytes(), request);
         } catch (ClientException e) {
             result = this;
         }
         return result;
     }
 
     public String toString() {
         String result;
         try {
             result = getResponseAsString("UTF-8");
         } catch (ClientException e) {
             result = "Exception while converting response to String";
         }
         return result;
     }
 
     public boolean equals(Object obj) {
         boolean eq;
         if (obj == null) {
             eq = false;
         } else if (!(obj instanceof WebdavResponse)) {
             eq = false;
         } else if (this == obj) {
             eq = true;
         } else {
             WebdavResponse rhs = (WebdavResponse) obj;
             eq = new EqualsBuilder().append(getResponseCode(), rhs.getResponseCode()).append(getResponseAsBytes(),
                     rhs.getResponseAsBytes()).isEquals();
         }
         return eq;
     }
 
     public int hashCode() {
         int hash = new HashCodeBuilder(37, 93).append(getResponseCode()).append(getResponseAsBytes()).toHashCode();
         return hash;
     }
 
 }