/*
    * 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.binding.content;
  
  import java.io.IOException;
  import java.io.InputStream;
  import java.util.ArrayList;
  import java.util.Iterator;
  
  import nl.hippo.client.api.ClientException;
  import nl.hippo.client.api.DocumentNotFoundException;
  import nl.hippo.client.api.CollectionNotFoundException;
  import nl.hippo.client.api.content.Document;
  import nl.hippo.client.api.content.DocumentCollection;
  import nl.hippo.client.api.content.DocumentMetadata;
  import nl.hippo.client.api.content.DocumentPath;
  import nl.hippo.client.api.content.RawResponse;
  import nl.hippo.client.webdav.WebdavConfig;
  import nl.hippo.client.webdav.WebdavResponse;
  import nl.hippo.client.webdav.caching.WebdavCacheHandler;
  import nl.hippo.client.webdav.method.Get;
  import nl.hippo.client.webdav.method.PropFind;
  import nl.hippo.client.webdav.method.Search;
  import nl.hippo.client.webdav.method.SearchDocumentById;
  import nl.hippo.client.webdav.utils.Converters;
  
  import org.jibx.runtime.BindingDirectory;
  import org.jibx.runtime.IBindingFactory;
  import org.jibx.runtime.IUnmarshallingContext;
  import org.jibx.runtime.JiBXException;
  
  /**
   * A factory of Documents
   */
  public class DocumentFactory {
  
      private static final String SEARCHRESULT_XSLT = "resources/searchresult.xslt";
      public static final WebdavResponse xslt;
  
      private static IBindingFactory searchResultXMLBindingFactory;
      static {
          try {
              searchResultXMLBindingFactory = BindingDirectory.getFactory(DocumentCollectionImpl.class);
          } catch (JiBXException e) {
              throw new ExceptionInInitializerError("Exception while initializing DocumentBindingFactory: "
                      + e.getMessage());
          }
          InputStream in = DocumentFactory.class.getResourceAsStream(SEARCHRESULT_XSLT);
          try {
              xslt = new WebdavResponse(Converters.stream2Bytes(in));
          } catch (IOException e) {
              throw new ExceptionInInitializerError("Exception while initializing searchresult transformer: "
                      + e.getMessage());
          }
      }
  
      private WebdavConfig config;
  
      public DocumentFactory(WebdavConfig config) {
          if (config == null) {
              throw new IllegalArgumentException("DocumentFactory constructor parameter config may not be null.");
          }
          this.config = config;
      }
  
      public Document fetchDocument(WebdavCacheHandler cache, DocumentPath docPath) throws ClientException {
          WebdavResponse response = new PropFind(config).execute(cache, docPath);
          Document boundDoc = bindDocument(cache, response);
  
          if (boundDoc == null) {
              throw new DocumentNotFoundException("Document not found at: " + docPath.getFullPath());
          }
          RawResponse content = new Get(config).execute(cache, docPath);
          return new DocumentImpl(docPath, boundDoc.getMetadata(), content);
      }
  
      public DocumentMetadata fetchMetadata(WebdavCacheHandler cache, DocumentPath docPath) throws ClientException {
          WebdavResponse response = new PropFind(config).execute(cache, docPath);
          Document boundDoc = bindDocument(cache, response);
          if (boundDoc == null) {
              throw new DocumentNotFoundException("Document not found at: " + docPath.getFullPath());
          }
          return boundDoc.getMetadata();
      }
  
      public DocumentCollection fetchCollection(WebdavCacheHandler cache, DocumentPath targetPath, InputStream dasl,
             boolean includeContent) throws ClientException {
         if (dasl == null) {
             throw new IllegalArgumentException("Parameter dasl may not be null");
         }
         try {
             String daslAsString = new String(Converters.stream2Bytes(dasl));
             return fetchCollection(cache, targetPath, daslAsString, includeContent);
 
         } catch (IOException e) {
             throw new ClientException("Exception while reading dasl from InputStream" + e.getMessage());
         }
     }
 
     public DocumentCollection fetchCollection(WebdavCacheHandler cache, DocumentPath targetPath, String dasl,
             boolean includeContent) throws ClientException {
         Search search = new Search(config);
         WebdavResponse response = search.execute(cache, targetPath, dasl);
         DocumentCollection result = bindSearch(cache, response);
 
         if (result != null && includeContent) {
             Iterator it = result.getDocuments().iterator();
             while (it.hasNext()) {
                 DocumentImpl doc = (DocumentImpl) it.next();
                 doc.content = new Get(config).execute(cache, doc.getPath());
             }
         }
         
         if (result == null) {
             throw new CollectionNotFoundException("Collection not found at: " + targetPath.getFullPath());
         }
         return result;
     }
 
     public DocumentPath resolvePath(WebdavCacheHandler cache, String documentId) throws ClientException {
         DocumentPath path = new SearchDocumentById(config).execute(cache, this, documentId);
         
         if (path == null) {
             throw new DocumentNotFoundException("Document not found with id: " + documentId);
         }
         
         return path;
     }
 
     public Document bindDocument(WebdavCacheHandler cache, WebdavResponse response) throws ClientException {
         DocumentCollection searchResult = bindSearch(cache, response);
         if (searchResult == null || searchResult.getDocuments() == null || searchResult.getDocuments().size() == 0) {
             return null;
         }
         return (Document) searchResult.getDocuments().get(0);
     }
 
     private DocumentCollection bindSearch(WebdavCacheHandler cache, WebdavResponse response) throws ClientException {
         if (!response.isValid()) {
             return null;
         }
 
         WebdavResponse transformedResponse = response.transform(xslt, cache);
 
         // Unmarshal the XML to a DocumentCollection instance
         DocumentCollection binding;
         try {
             IUnmarshallingContext context = searchResultXMLBindingFactory.createUnmarshallingContext();
             binding = (DocumentCollection) context.unmarshalDocument(transformedResponse.getResponseAsStream(), null);
         } catch (JiBXException e) {
             throw new ClientException("Unmarshalling XML to DocumentCollection failed.", e);
         }
 
         // This is a hack to set the 'path' attribute of each Document/DocumentMetadata object 
         // in the DocumentCollection which is not set automatically by the unmarshalling.
         // TODO: Refactor the unmarshalling so that it does set the path attribute directly and then remove this loop.
         ArrayList documentsWithPath = new ArrayList();
         Iterator it = binding.getDocuments().iterator();
         while (it.hasNext()) {
             DocumentImpl docWithoutPath = (DocumentImpl) it.next();
             DocumentPath docPath = config.getBasePath().createAbsolutePath(docWithoutPath.tmpPath);
             DocumentMetadataImpl metadataWithoutPath = (DocumentMetadataImpl) docWithoutPath.getMetadata();
 
             DocumentMetadata metadataWithPath = new DocumentMetadataImpl(metadataWithoutPath, docPath);
             Document documentWithPath = new DocumentImpl(docPath, metadataWithPath, null);
 
             documentsWithPath.add(documentWithPath);
         }
         return new DocumentCollectionImpl(documentsWithPath);
     }
 
 }