/*
    * 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.chemistry.opencmis.client.runtime;
  
  import static org.apache.chemistry.opencmis.commons.impl.CollectionsHelper.isNullOrEmpty;
  
  import java.math.BigInteger;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.List;
  import java.util.Map;
  
  import org.apache.chemistry.opencmis.client.api.CmisObject;
  import org.apache.chemistry.opencmis.client.api.Document;
  import org.apache.chemistry.opencmis.client.api.FileableCmisObject;
  import org.apache.chemistry.opencmis.client.api.Folder;
  import org.apache.chemistry.opencmis.client.api.FolderType;
  import org.apache.chemistry.opencmis.client.api.Item;
  import org.apache.chemistry.opencmis.client.api.ItemIterable;
  import org.apache.chemistry.opencmis.client.api.ObjectFactory;
  import org.apache.chemistry.opencmis.client.api.ObjectId;
  import org.apache.chemistry.opencmis.client.api.ObjectType;
  import org.apache.chemistry.opencmis.client.api.OperationContext;
  import org.apache.chemistry.opencmis.client.api.Policy;
  import org.apache.chemistry.opencmis.client.api.Tree;
  import org.apache.chemistry.opencmis.client.runtime.util.AbstractPageFetcher;
  import org.apache.chemistry.opencmis.client.runtime.util.CollectionIterable;
  import org.apache.chemistry.opencmis.client.runtime.util.TreeImpl;
  import org.apache.chemistry.opencmis.commons.PropertyIds;
  import org.apache.chemistry.opencmis.commons.data.Ace;
  import org.apache.chemistry.opencmis.commons.data.ContentStream;
  import org.apache.chemistry.opencmis.commons.data.ObjectData;
  import org.apache.chemistry.opencmis.commons.data.ObjectInFolderContainer;
  import org.apache.chemistry.opencmis.commons.data.ObjectInFolderData;
  import org.apache.chemistry.opencmis.commons.data.ObjectInFolderList;
  import org.apache.chemistry.opencmis.commons.data.ObjectList;
  import org.apache.chemistry.opencmis.commons.data.PropertyData;
  import org.apache.chemistry.opencmis.commons.data.PropertyId;
  import org.apache.chemistry.opencmis.commons.data.PropertyString;
  import org.apache.chemistry.opencmis.commons.enums.IncludeRelationships;
  import org.apache.chemistry.opencmis.commons.enums.UnfileObject;
  import org.apache.chemistry.opencmis.commons.enums.VersioningState;
  import org.apache.chemistry.opencmis.commons.exceptions.CmisRuntimeException;
  import org.apache.chemistry.opencmis.commons.spi.NavigationService;
  
  public class FolderImpl extends AbstractFilableCmisObject implements Folder {
  
      private static final long serialVersionUID = 1L;
  
      /**
       * Constructor.
       */
      public FolderImpl(SessionImpl session, ObjectType objectType, ObjectData objectData, OperationContext context) {
          initialize(session, objectType, objectData, context);
      }
  
      @Override
      public FolderType getFolderType() {
          ObjectType objectType = super.getType();
          if (objectType instanceof FolderType) {
              return (FolderType) objectType;
          } else {
              throw new ClassCastException("Object type is not a folder type.");
          }
      }
  
      @Override
      public Document createDocument(Map<String, ?> properties, ContentStream contentStream,
              VersioningState versioningState, List<Policy> policies, List<Ace> addAces, List<Ace> removeAces,
              OperationContext context) {
  
          ObjectId newId = getSession().createDocument(properties, this, contentStream, versioningState, policies,
                  addAces, removeAces);
  
          // if no context is provided the object will not be fetched
          if (context == null || newId == null) {
              return null;
          }
  
          // get the new object
          CmisObject object = getSession().getObject(newId, context);
          if (!(object instanceof Document)) {
              throw new CmisRuntimeException("Newly created object is not a document! New id: " + newId);
         }
 
         return (Document) object;
     }
 
     @Override
     public Document createDocumentFromSource(ObjectId source, Map<String, ?> properties,
             VersioningState versioningState, List<Policy> policies, List<Ace> addAces, List<Ace> removeAces,
             OperationContext context) {
 
         ObjectId newId = getSession().createDocumentFromSource(source, properties, this, versioningState, policies,
                 addAces, removeAces);
 
         // if no context is provided the object will not be fetched
         if (context == null || newId == null) {
             return null;
         }
 
         // get the new object
         CmisObject object = getSession().getObject(newId, context);
         if (!(object instanceof Document)) {
             throw new CmisRuntimeException("Newly created object is not a document! New id: " + newId);
         }
 
         return (Document) object;
     }
 
     @Override
     public Folder createFolder(Map<String, ?> properties, List<Policy> policies, List<Ace> addAces,
             List<Ace> removeAces, OperationContext context) {
 
         ObjectId newId = getSession().createFolder(properties, this, policies, addAces, removeAces);
 
         // if no context is provided the object will not be fetched
         if (context == null || newId == null) {
             return null;
         }
 
         // get the new object
         CmisObject object = getSession().getObject(newId, context);
         if (!(object instanceof Folder)) {
             throw new CmisRuntimeException("Newly created object is not a folder! New id: " + newId);
         }
 
         return (Folder) object;
     }
 
     @Override
     public Policy createPolicy(Map<String, ?> properties, List<Policy> policies, List<Ace> addAces,
             List<Ace> removeAces, OperationContext context) {
 
         ObjectId newId = getSession().createPolicy(properties, this, policies, addAces, removeAces);
 
         // if no context is provided the object will not be fetched
         if (context == null || newId == null) {
             return null;
         }
 
         // get the new object
         CmisObject object = getSession().getObject(newId, context);
         if (!(object instanceof Policy)) {
             throw new CmisRuntimeException("Newly created object is not a policy! New id: " + newId);
         }
 
         return (Policy) object;
     }
 
     @Override
     public Item createItem(Map<String, ?> properties, List<Policy> policies, List<Ace> addAces, List<Ace> removeAces,
             OperationContext context) {
 
         ObjectId newId = getSession().createItem(properties, this, policies, addAces, removeAces);
 
         // if no context is provided the object will not be fetched
         if (context == null || newId == null) {
             return null;
         }
 
         // get the new object
         CmisObject object = getSession().getObject(newId, context);
         if (!(object instanceof Item)) {
             throw new CmisRuntimeException("Newly created object is not an item! New id: " + newId);
         }
 
         return (Item) object;
     }
 
     @Override
     public List<String> deleteTree(boolean allVersions, UnfileObject unfile, boolean continueOnFailure) {
         return getSession().deleteTree(this, allVersions, unfile, continueOnFailure);
     }
 
     @Override
     public String getParentId() {
         return getPropertyValue(PropertyIds.PARENT_ID);
     }
 
     @Override
     public List<ObjectType> getAllowedChildObjectTypes() {
         List<ObjectType> result = new ArrayList<ObjectType>();
 
         readLock();
         try {
             List<String> otids = getPropertyValue(PropertyIds.ALLOWED_CHILD_OBJECT_TYPE_IDS);
             if (otids == null) {
                 return result;
             }
 
             for (String otid : otids) {
                 result.add(getSession().getTypeDefinition(otid));
             }
         } finally {
             readUnlock();
         }
 
         return result;
     }
 
     @Override
     public ItemIterable<Document> getCheckedOutDocs() {
         return getCheckedOutDocs(getSession().getDefaultContext());
     }
 
     @Override
     public ItemIterable<Document> getCheckedOutDocs(OperationContext context) {
         final String objectId = getObjectId();
         final NavigationService navigationService = getBinding().getNavigationService();
         final ObjectFactory objectFactory = getSession().getObjectFactory();
         final OperationContext ctxt = new OperationContextImpl(context);
 
         return new CollectionIterable<Document>(new AbstractPageFetcher<Document>(ctxt.getMaxItemsPerPage()) {
 
             @Override
             protected AbstractPageFetcher.Page<Document> fetchPage(long skipCount) {
 
                 // get checked out documents for this folder
                 ObjectList checkedOutDocs = navigationService.getCheckedOutDocs(getRepositoryId(), objectId,
                         ctxt.getFilterString(), ctxt.getOrderBy(), ctxt.isIncludeAllowableActions(),
                         ctxt.getIncludeRelationships(), ctxt.getRenditionFilterString(),
                         BigInteger.valueOf(this.maxNumItems), BigInteger.valueOf(skipCount), null);
 
                 // convert objects
                 List<Document> page = new ArrayList<Document>();
                 if (checkedOutDocs.getObjects() != null) {
                     for (ObjectData objectData : checkedOutDocs.getObjects()) {
                         CmisObject doc = objectFactory.convertObject(objectData, ctxt);
                         if (!(doc instanceof Document)) {
                             // should not happen...
                             continue;
                         }
 
                         page.add((Document) doc);
                     }
                 }
 
                 return new AbstractPageFetcher.Page<Document>(page, checkedOutDocs.getNumItems(),
                         checkedOutDocs.hasMoreItems());
             }
         });
     }
 
     @Override
     public ItemIterable<CmisObject> getChildren() {
         return getChildren(getSession().getDefaultContext());
     }
 
     @Override
     public ItemIterable<CmisObject> getChildren(OperationContext context) {
         final String objectId = getObjectId();
         final NavigationService navigationService = getBinding().getNavigationService();
         final ObjectFactory objectFactory = getSession().getObjectFactory();
         final OperationContext ctxt = new OperationContextImpl(context);
 
         return new CollectionIterable<CmisObject>(new AbstractPageFetcher<CmisObject>(ctxt.getMaxItemsPerPage()) {
 
             @Override
             protected AbstractPageFetcher.Page<CmisObject> fetchPage(long skipCount) {
 
                 // get the children
                 ObjectInFolderList children = navigationService.getChildren(getRepositoryId(), objectId,
                         ctxt.getFilterString(), ctxt.getOrderBy(), ctxt.isIncludeAllowableActions(),
                         ctxt.getIncludeRelationships(), ctxt.getRenditionFilterString(), ctxt.isIncludePathSegments(),
                         BigInteger.valueOf(this.maxNumItems), BigInteger.valueOf(skipCount), null);
 
                 // convert objects
                 List<CmisObject> page = new ArrayList<CmisObject>();
                 List<ObjectInFolderData> childObjects = children.getObjects();
                 if (childObjects != null) {
                     for (ObjectInFolderData objectData : childObjects) {
                         if (objectData.getObject() != null) {
                             page.add(objectFactory.convertObject(objectData.getObject(), ctxt));
                         }
                     }
                 }
 
                 return new AbstractPageFetcher.Page<CmisObject>(page, children.getNumItems(), children.hasMoreItems());
             }
         });
     }
 
     @Override
     public List<Tree<FileableCmisObject>> getDescendants(int depth) {
         return getDescendants(depth, getSession().getDefaultContext());
     }
 
     @Override
     public List<Tree<FileableCmisObject>> getDescendants(int depth, OperationContext context) {
         String objectId = getObjectId();
 
         // get the descendants
         List<ObjectInFolderContainer> providerContainerList = getBinding().getNavigationService().getDescendants(
                 getRepositoryId(), objectId, BigInteger.valueOf(depth), context.getFilterString(),
                 context.isIncludeAllowableActions(), context.getIncludeRelationships(),
                 context.getRenditionFilterString(), context.isIncludePathSegments(), null);
 
         return convertBindingContainer(providerContainerList, context);
     }
 
     @Override
     public List<Tree<FileableCmisObject>> getFolderTree(int depth) {
         return getFolderTree(depth, getSession().getDefaultContext());
     }
 
     @Override
     public List<Tree<FileableCmisObject>> getFolderTree(int depth, OperationContext context) {
         String objectId = getObjectId();
 
         // get the folder tree
         List<ObjectInFolderContainer> providerContainerList = getBinding().getNavigationService().getFolderTree(
                 getRepositoryId(), objectId, BigInteger.valueOf(depth), context.getFilterString(),
                 context.isIncludeAllowableActions(), context.getIncludeRelationships(),
                 context.getRenditionFilterString(), context.isIncludePathSegments(), null);
 
         return convertBindingContainer(providerContainerList, context);
     }
 
     /**
      * Converts a binding container into an API container.
      */
     private List<Tree<FileableCmisObject>> convertBindingContainer(List<ObjectInFolderContainer> bindingContainerList,
             OperationContext context) {
         if (bindingContainerList == null) {
             return null;
         }
 
         ObjectFactory of = getSession().getObjectFactory();
 
         List<Tree<FileableCmisObject>> result = new ArrayList<Tree<FileableCmisObject>>();
         for (ObjectInFolderContainer oifc : bindingContainerList) {
             if (oifc.getObject() == null || oifc.getObject().getObject() == null) {
                 // shouldn't happen ...
                 continue;
             }
 
             // convert the object
             CmisObject object = of.convertObject(oifc.getObject().getObject(), context);
             if (!(object instanceof FileableCmisObject)) {
                 // the repository must not return objects that are not fileable,
                 // but you never know...
                 continue;
             }
 
             // convert the children
             List<Tree<FileableCmisObject>> children = convertBindingContainer(oifc.getChildren(), context);
 
             // add both to current container
             result.add(new TreeImpl<FileableCmisObject>((FileableCmisObject) object, children));
         }
 
         return result;
     }
 
     @Override
     public boolean isRootFolder() {
         String objectId = getObjectId();
         String rootFolderId = getSession().getRepositoryInfo().getRootFolderId();
 
         return objectId.equals(rootFolderId);
     }
 
     @Override
     public Folder getFolderParent() {
         if (isRootFolder()) {
             return null;
         }
 
         List<Folder> parents = getParents(getSession().getDefaultContext());
         if (isNullOrEmpty(parents)) {
             return null;
         }
 
         return parents.get(0);
     }
 
     @Override
     public String getPath() {
         String path;
 
         readLock();
         try {
             // get the path property
             path = getPropertyValue(PropertyIds.PATH);
 
             // if the path property isn't set, get it
             if (path == null) {
                 String objectId = getObjectId();
                 ObjectData objectData = getBinding().getObjectService().getObject(getRepositoryId(), objectId,
                         getPropertyQueryName(PropertyIds.PATH), false, IncludeRelationships.NONE, "cmis:none", false,
                         false, null);
 
                 if (objectData.getProperties() != null && objectData.getProperties().getProperties() != null) {
                     PropertyData<?> pathProperty = objectData.getProperties().getProperties().get(PropertyIds.PATH);
 
                     if (pathProperty instanceof PropertyString) {
                         path = ((PropertyString) pathProperty).getFirstValue();
                     }
                 }
             }
         } finally {
             readUnlock();
         }
 
         // we still don't know the path ... it's not a CMIS compliant repository
         if (path == null) {
             throw new CmisRuntimeException("Repository didn't return " + PropertyIds.PATH + "!");
         }
 
         return path;
     }
 
     @Override
     public List<Folder> getParents(OperationContext context) {
         if (isRootFolder()) {
             return Collections.emptyList();
         }
 
         String objectId = getObjectId();
 
         ObjectData bindingParent = getBinding().getNavigationService().getFolderParent(getRepositoryId(), objectId,
                 getPropertyQueryName(PropertyIds.OBJECT_ID), null);
 
         if (bindingParent.getProperties() == null) {
             // should not happen...
             throw new CmisRuntimeException("Repository sent invalid data!");
         }
 
         // get id property
         PropertyData<?> idProperty = bindingParent.getProperties().getProperties().get(PropertyIds.OBJECT_ID);
         if (!(idProperty instanceof PropertyId) && !(idProperty instanceof PropertyString)) {
             // the repository sent an object without a valid object id...
             throw new CmisRuntimeException("Repository sent invalid data! No object id!");
         }
 
         // fetch the object and make sure it is a folder
         CmisObject parentFolder = getSession().getObject((String) idProperty.getFirstValue(), context);
         if (!(parentFolder instanceof Folder)) {
             // the repository sent an object that is not a folder...
             throw new CmisRuntimeException("Repository sent invalid data! Object is not a folder!");
         }
 
         return Collections.singletonList((Folder) parentFolder);
     }
 
     @Override
     public List<String> getPaths() {
         return Collections.singletonList(getPath());
     }
 
     @Override
     public Document createDocument(Map<String, ?> properties, ContentStream contentStream,
             VersioningState versioningState) {
         return this.createDocument(properties, contentStream, versioningState, null, null, null, getSession()
                 .getDefaultContext());
     }
 
     @Override
     public Document createDocumentFromSource(ObjectId source, Map<String, ?> properties, VersioningState versioningState) {
         return this.createDocumentFromSource(source, properties, versioningState, null, null, null, getSession()
                 .getDefaultContext());
     }
 
     @Override
     public Folder createFolder(Map<String, ?> properties) {
         return this.createFolder(properties, null, null, null, getSession().getDefaultContext());
     }
 
     @Override
     public Policy createPolicy(Map<String, ?> properties) {
         return this.createPolicy(properties, null, null, null, getSession().getDefaultContext());
     }
 
     @Override
     public Item createItem(Map<String, ?> properties) {
         return this.createItem(properties, null, null, null, getSession().getDefaultContext());
     }
 }