/*
 * 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.tools.specexamples;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileFilter;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

import org.apache.chemistry.opencmis.client.bindings.CmisBindingFactory;
import org.apache.chemistry.opencmis.commons.PropertyIds;
import org.apache.chemistry.opencmis.commons.SessionParameter;
import org.apache.chemistry.opencmis.commons.data.Ace;
import org.apache.chemistry.opencmis.commons.data.Acl;
import org.apache.chemistry.opencmis.commons.data.CmisExtensionElement;
import org.apache.chemistry.opencmis.commons.data.ContentStream;
import org.apache.chemistry.opencmis.commons.data.ExtensionsData;
import org.apache.chemistry.opencmis.commons.data.ObjectInFolderData;
import org.apache.chemistry.opencmis.commons.data.ObjectInFolderList;
import org.apache.chemistry.opencmis.commons.data.Properties;
import org.apache.chemistry.opencmis.commons.data.PropertyData;
import org.apache.chemistry.opencmis.commons.data.RepositoryInfo;
import org.apache.chemistry.opencmis.commons.enums.AclPropagation;
import org.apache.chemistry.opencmis.commons.enums.BaseTypeId;
import org.apache.chemistry.opencmis.commons.enums.BindingType;
import org.apache.chemistry.opencmis.commons.enums.IncludeRelationships;
import org.apache.chemistry.opencmis.commons.enums.VersioningState;
import org.apache.chemistry.opencmis.commons.exceptions.CmisBaseException;
import org.apache.chemistry.opencmis.commons.impl.IOUtils;
import org.apache.chemistry.opencmis.commons.impl.dataobjects.BindingsObjectFactoryImpl;
import org.apache.chemistry.opencmis.commons.impl.dataobjects.CmisExtensionElementImpl;
import org.apache.chemistry.opencmis.commons.impl.dataobjects.ContentStreamImpl;
import org.apache.chemistry.opencmis.commons.impl.dataobjects.ExtensionDataImpl;
import org.apache.chemistry.opencmis.commons.spi.AclService;
import org.apache.chemistry.opencmis.commons.spi.BindingsObjectFactory;
import org.apache.chemistry.opencmis.commons.spi.CmisBinding;
import org.apache.chemistry.opencmis.commons.spi.DiscoveryService;
import org.apache.chemistry.opencmis.commons.spi.Holder;
import org.apache.chemistry.opencmis.commons.spi.MultiFilingService;
import org.apache.chemistry.opencmis.commons.spi.NavigationService;
import org.apache.chemistry.opencmis.commons.spi.ObjectService;
import org.apache.chemistry.opencmis.commons.spi.RepositoryService;
import org.apache.chemistry.opencmis.commons.spi.VersioningService;
import org.apache.commons.io.filefilter.WildcardFileFilter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class SpecExamples {

    private static final int BUFSIZE = 32 * 1024;
    private static final int SLEEP_TIME = 200;
    private static final String MULTIFILED_DOCUMENT = "MultifiledDocument";
    private static final String MULTIFILED_FOLDER_2 = "MultifiledFolder2";
    private static final String MULTIFILED_FOLDER_1 = "MultifiledFolder1";
    private static final Logger LOG = LoggerFactory.getLogger(SpecExamples.class.getName());
    private static final BigInteger TYPE_DEPTH_ALL = BigInteger.valueOf(-1);
    private static final BigInteger MAX_ITEMS = null;
    private static final BigInteger SKIP_COUNT = BigInteger.valueOf(0);
    private static final String TOPLEVEL_TYPE = "DocumentTopLevel";
    private static final String VERSIONED_TYPE = "VersionableType";
    private static final String VERSIONED_PROP = "VersionedStringProp";
    private static final String LOGDIR = System.getProperty("java.io.tmpdir");// +
                                                                        // File.separator;
    private static final String ROOT_URL = "http://localhost:8080/inmemory";
    private static final String ROOT_URL_OASIS = "http://www.example.com:8080/inmemory"; 
      // required by OASIS rules, add this host to your hosts file
    
    static int NO_FILES_LOGGED = 0;

    private String targetDir = System.getProperty("java.io.tmpdir");
    private BindingsObjectFactory objFactory = new BindingsObjectFactoryImpl();
    private BindingType bindingType;
    private String rootFolderId;
    private String repositoryId;
    private ObjectService objSvc;
    private NavigationService navSvc;
    private RepositoryService repSvc;
    private VersioningService verSvc;
    private MultiFilingService multiSvc;
    private DiscoveryService discSvc;
    private AclService aclSvc;

    private List<String> idsToDelete = new ArrayList<String>();
    private String multiFiledDoc;
    private String multiFiledFolder2;
    private String changeToken;

    private static final String[] URLS = { ROOT_URL + "/atom", ROOT_URL + "/services", ROOT_URL + "/browser" };
    private static final BindingType[] BINDINGS = { BindingType.ATOMPUB, BindingType.WEBSERVICES, BindingType.BROWSER };

    public SpecExamples() {
    }

    public void runAllBindings() {
        cleanLogFilterDir(); // delete directory where Logging filter writes to
                             // ensure not to include unwanted files

        for (int i = 0; i < BINDINGS.length; i++) {
            bindingType = BINDINGS[i];
            init(URLS[i], BINDINGS[i]);
            run();
        }
        String dirs[] = { BindingType.ATOMPUB.value(), BindingType.WEBSERVICES.value(), BindingType.BROWSER.value() };
        createZipFile("CMIS-Spec-Examples.zip", dirs);

    }

    public void run() {
        LOG.debug("Generating spec examples for Binding: " + bindingType.value());

        try {
            // Repository Service:
            getRepositories();

            repositoryId = "A1";
            getRepositoryInfo(); // get root folder id here!

            getTypeDefinition("cmis:folder");

            String docId = getTestDocId();
            String folderId = getTestFolderId();

            getTypeChildren(TOPLEVEL_TYPE);

            // Navigation Service:
            getChildren(folderId);
            getDescendants(folderId);
            getObjectParents(folderId);
            removeObjectFromFolder();

            // Object Service:
            getObject(docId);
            getAcl(docId);
            String id1 = createDocument("SampleDocument", TOPLEVEL_TYPE, rootFolderId, VersioningState.NONE);
            updateProperties(id1, PropertyIds.NAME, "RenamedDocument");
            getAllowableActions(id1);

            deleteObject(id1);

            // Discovery Service:
            doQuery();
            getContentChanges(changeToken);

            // Versioning Service
            String id2 = prepareVersionSeries("VersionedDocument", VERSIONED_TYPE, rootFolderId);
            checkOut(id2);
            checkIn(id2, true, "final version in series");
            getAllVersions(id2);

            // collect all captured files and store them in a ZIP file
        } catch (Exception e) {
            LOG.error("Failed to create spec examples: ", e);
        }

        // delete all generated objects
        cleanup();
    }

    private void init(String url, BindingType bindingType) {
        LOG.debug("Initializing connection to InMemory server: ");
        LOG.debug("   Binding: " + bindingType.value());
        LOG.debug("   URL: " + url);

        Map<String, String> parameters = new HashMap<String, String>();
        parameters.put(SessionParameter.USER, "admin");
        parameters.put(SessionParameter.PASSWORD, "admin");

        parameters.put(SessionParameter.BINDING_TYPE, bindingType.value());

        // get factory and create binding
        CmisBindingFactory factory = CmisBindingFactory.newInstance();
        CmisBinding binding = null;

        if (bindingType == BindingType.ATOMPUB) {
            parameters.put(SessionParameter.ATOMPUB_URL, url);
            binding = factory.createCmisAtomPubBinding(parameters);
        } else if (bindingType == BindingType.WEBSERVICES) {
            parameters.put(SessionParameter.WEBSERVICES_ACL_SERVICE, url + "/ACLService?wsdl");
            parameters.put(SessionParameter.WEBSERVICES_DISCOVERY_SERVICE, url + "/DiscoveryService?wsdl");
            parameters.put(SessionParameter.WEBSERVICES_MULTIFILING_SERVICE, url + "/MultiFilingService?wsdl");
            parameters.put(SessionParameter.WEBSERVICES_NAVIGATION_SERVICE, url + "/NavigationService?wsdl");
            parameters.put(SessionParameter.WEBSERVICES_OBJECT_SERVICE, url + "/ObjectService?wsdl");
            parameters.put(SessionParameter.WEBSERVICES_POLICY_SERVICE, url + "/PolicyService?wsdl");
            parameters.put(SessionParameter.WEBSERVICES_RELATIONSHIP_SERVICE, url + "/RelatinshipService?wsdl");
            parameters.put(SessionParameter.WEBSERVICES_REPOSITORY_SERVICE, url + "/RepositoryService?wsdl");
            parameters.put(SessionParameter.WEBSERVICES_VERSIONING_SERVICE, url + "/VersioningService?wsdl");
            binding = factory.createCmisWebServicesBinding(parameters);
        } else if (bindingType == BindingType.BROWSER) {
            parameters.put(SessionParameter.BROWSER_URL, url);
            binding = factory.createCmisBrowserBinding(parameters);
        } else {
            LOG.error("Unknown binding type: " + bindingType.value());
            return;
        }
        objFactory = binding.getObjectFactory();
        repSvc = binding.getRepositoryService();
        objSvc = binding.getObjectService();
        navSvc = binding.getNavigationService();
        verSvc = binding.getVersioningService();
        multiSvc = binding.getMultiFilingService();
        discSvc = binding.getDiscoveryService();
        aclSvc = binding.getAclService();

        // create a folder where target files will be stored:
        targetDir = bindingType.value();
        File in = new File(targetDir);
        deleteDirRecursive(in); // avoid that there are unwanted files from
                                // previous runs
        boolean ok = in.mkdir();

        LOG.debug("creating target directory for files: " + ok);
        LOG.debug("Initializing done. ");
    }

    private void getRepositories() {
        LOG.debug("getRepositories()");
        List<RepositoryInfo> repositories = repSvc.getRepositoryInfos(null);
        this.repositoryId = repositories.get(0).getId();
        renameFiles("getRepositoryInfos");
        LOG.debug("getRepositoryInfo() done.");
    }

    private void getRepositoryInfo() {
        LOG.debug("getting repository info for repository " + repositoryId);

        // Because some bindings silently retrieve all repositories on the first
        // request we call it twice
        // and use a dummy extension data element to prevent caching
        RepositoryInfo repoInfo = repSvc.getRepositoryInfo(repositoryId, null);
        ExtensionDataImpl dummyExt = new ExtensionDataImpl();
        @SuppressWarnings("serial")
        List<CmisExtensionElement> extList = new ArrayList<CmisExtensionElement>() {
            {
                add(new CmisExtensionElementImpl("foo", "foo", null, "bar"));
            }
        };
        dummyExt.setExtensions(extList);
        repoInfo = repSvc.getRepositoryInfo(repositoryId, dummyExt);

        LOG.debug("repository id is: " + repoInfo.getId());
        rootFolderId = repoInfo.getRootFolderId();
        changeToken = repoInfo.getLatestChangeLogToken();
        LOG.debug("root folder id is: " + repoInfo.getRootFolderId());
        renameFiles("getRepositoryInfo");
        LOG.debug("getRepositoryInfo() done.");
    }

    private void getObject(String objectId) {
        LOG.debug("getObject " + objectId);
        objSvc.getObject(repositoryId, objectId, "*", true /* includeAllowableActions */,
                IncludeRelationships.NONE /* includeRelationships */, null /* renditionFilter */,
                false /* includePolicyIds */, true /* includeAcl */, null);
        renameFiles("getObject");
        LOG.debug("getObject() done.");
    }

    private void getChildren(String folderId) {
        LOG.debug("getChildren " + folderId);
        navSvc.getChildren(repositoryId, folderId, "*", null /* orderBy */, true /* includeAllowableActions */,
                IncludeRelationships.NONE, null /* renditionFilter */, true /* includePathSegment */, MAX_ITEMS,
                SKIP_COUNT, null);
        renameFiles("getChildren");
        LOG.debug("getChildren() done.");
    }

    private void getDescendants(String folderId) {
        final BigInteger depth = BigInteger.valueOf(3);
        LOG.debug("getDescendants " + folderId);
        navSvc.getDescendants(repositoryId, folderId, depth, "*", true /* includeAllowableActions */,
                IncludeRelationships.NONE, null /* renditionFilter */, true /* includePathSegment */, null);
        renameFiles("getDescendants");
        LOG.debug("getDescendants() done.");
    }

    private void getObjectParents(String folderId) {
        String multiFiledFolder1;
        // get object parents first add object to two folders then get parents
        LOG.debug("getObjectsParents " + folderId);
        multiFiledFolder1 = createFolderIntern(MULTIFILED_FOLDER_1, BaseTypeId.CMIS_FOLDER.value(), folderId);
        idsToDelete.add(multiFiledFolder1);
        multiFiledFolder2 = createFolderIntern(MULTIFILED_FOLDER_2, BaseTypeId.CMIS_FOLDER.value(), folderId);
        idsToDelete.add(multiFiledFolder2);
        multiFiledDoc = createDocumentIntern(MULTIFILED_DOCUMENT, BaseTypeId.CMIS_DOCUMENT.value(), multiFiledFolder1,
                VersioningState.NONE);
        idsToDelete.add(0, multiFiledDoc); // add at the beginning must be
                                           // removed before folders!
        multiSvc.addObjectToFolder(repositoryId, multiFiledDoc, multiFiledFolder2, true, null);
        navSvc.getObjectParents(repositoryId, multiFiledDoc, "*", false, IncludeRelationships.NONE, null, true, null);
        renameFiles("getObjectParents");
        LOG.debug("getObjectParents() done.");
    }

    private void removeObjectFromFolder() {
        LOG.debug("removeObjectFromFolder");
        multiSvc.removeObjectFromFolder(repositoryId, multiFiledDoc, multiFiledFolder2, null);
        renameFiles("removeObjectFromFolder");
        try {
            Thread.sleep(SLEEP_TIME);
        } catch (InterruptedException e) {
            LOG.error("Thread interrupted: ", e);
        }
        LOG.debug("removeObjectFromFolder() done.");
    }

    private void doQuery() {
        LOG.debug("doQuery ");
        String statement = "SELECT * from cmis:document WHERE IN_FOLDER('" + rootFolderId + "')";
        discSvc.query(repositoryId, statement, false /* searchAllVersions */, true /* includeAllowableActions */,
                IncludeRelationships.NONE, null, MAX_ITEMS, SKIP_COUNT, null);
        renameFiles("doQuery");
        LOG.debug("doQuery() done.");
    }

    private void getContentChanges(String token) {
        LOG.debug("getContentChanges");
        Holder<String> changeLogToken = new Holder<String>("token");
        discSvc.getContentChanges(repositoryId, changeLogToken, false, "*", false, false, null, null);
        renameFiles("getContentChanges");
        LOG.debug("getContentChanges() done.");
    }

    private void getTypeChildren(String typeId) {
        LOG.debug("getTypeChildren " + typeId);
        repSvc.getTypeChildren(repositoryId, typeId, true /* includePropertyDefinitions */, MAX_ITEMS, SKIP_COUNT, null);
        renameFiles("getTypeChildren");
        LOG.debug("getTypeChildren() done.");
    }

    private String createDocument(String name, String typeId, String folderId, VersioningState versioningState) {
        LOG.debug("createDocument " + typeId);

        String id = createDocumentIntern(name, typeId, folderId, versioningState);
        renameFiles("createDocument");
        LOG.debug("createDocument() done.");

        return id;
    }

    private String createDocumentIntern(String name, String typeId, String folderId, VersioningState versioningState) {
        ContentStream contentStream = null;
        List<String> policies = null;
        Acl addACEs = null;
        Acl removeACEs = null;
        ExtensionsData extension = null;

        List<PropertyData<?>> properties = new ArrayList<PropertyData<?>>();
        properties.add(objFactory.createPropertyIdData(PropertyIds.NAME, name));
        properties.add(objFactory.createPropertyIdData(PropertyIds.OBJECT_TYPE_ID, typeId));
        Properties props = objFactory.createPropertiesData(properties);

        contentStream = createContent();

        String id = null;
        try {
            id = objSvc.createDocument(repositoryId, props, folderId, contentStream, versioningState, policies,
                    addACEs, removeACEs, extension);
        } catch (CmisBaseException e) {
            // folder already there, get it:
            ObjectInFolderList result = navSvc.getChildren(repositoryId, folderId, "*", null, false,
                    IncludeRelationships.NONE, null, true, MAX_ITEMS, SKIP_COUNT, null);

            List<ObjectInFolderData> children = result.getObjects();
            LOG.debug(" found " + children.size() + " folders in getChildren()");
            for (ObjectInFolderData child : children) {
                String nameChild = (String) child.getObject().getProperties().getProperties().get(PropertyIds.NAME)
                        .getFirstValue();
                if (name.equals(nameChild)) {
                    return child.getObject().getId();
                }
            }
        }
        return id;
    }

    private String createFolderIntern(String name, String typeId, String parentFolderId) {
        List<String> policies = null;
        Acl addACEs = null;
        Acl removeACEs = null;
        ExtensionsData extension = null;

        List<PropertyData<?>> properties = new ArrayList<PropertyData<?>>();
        properties.add(objFactory.createPropertyIdData(PropertyIds.NAME, name));
        properties.add(objFactory.createPropertyIdData(PropertyIds.OBJECT_TYPE_ID, typeId));
        Properties props = objFactory.createPropertiesData(properties);

        String id = null;
        try {
            id = objSvc.createFolder(repositoryId, props, parentFolderId, policies, addACEs, removeACEs, extension);
        } catch (CmisBaseException e) {
            // folder already there, get it:
            ObjectInFolderList result = navSvc.getChildren(repositoryId, parentFolderId, "*", null, false,
                    IncludeRelationships.NONE, null, true, MAX_ITEMS, SKIP_COUNT, null);

            List<ObjectInFolderData> children = result.getObjects();
            LOG.debug(" found " + children.size() + " folders in getChildren()");
            for (ObjectInFolderData child : children) {
                String nameChild = (String) child.getObject().getProperties().getProperties().get(PropertyIds.NAME)
                        .getFirstValue();
                if (name.equals(nameChild)) {
                    return child.getObject().getId();
                }
            }
        }
        return id;
    }

    private ContentStream createContent() {
        ContentStreamImpl content = new ContentStreamImpl();
        content.setFileName("data.txt");
        content.setMimeType("text/plain");
        int len = BUFSIZE;
        byte[] b = { 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x0c, 0x0a,
                0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x0c, 0x0a }; // 32
        // Bytes
        ByteArrayOutputStream ba = new ByteArrayOutputStream(len);
        try {
            for (int i = 0; i < 1024; i++) {
                ba.write(b);
            }
        } catch (IOException e) {
            LOG.error("Failed to fill content stream with data", e);
            return null;
        }
        content.setStream(new ByteArrayInputStream(ba.toByteArray()));
        content.setLength(BigInteger.valueOf(len));
        return content;
    }

    private void updateProperties(String id, String propertyId, String propertyValue) {
        LOG.debug("updateProperties " + id);
        List<PropertyData<?>> properties = new ArrayList<PropertyData<?>>();
        properties.add(objFactory.createPropertyStringData(propertyId, propertyValue));
        Properties newProps = objFactory.createPropertiesData(properties);

        Holder<String> idHolder = new Holder<String>(id);
        Holder<String> changeTokenHolder = new Holder<String>();
        objSvc.updateProperties(repositoryId, idHolder, changeTokenHolder, newProps, null);
        renameFiles("updateProperties");
        LOG.debug("updateProperties() done.");
    }

    private void deleteObject(String id) {
        LOG.debug("deleteObject " + id);
        objSvc.deleteObject(repositoryId, id, true, null);
        renameFiles("deleteObject");
        LOG.debug("deleteObject() done.");
    }

    private void cleanup() {
        LOG.debug("cleaning up...");
        for (String id : idsToDelete) {
            LOG.debug("deleting object " + id);
            objSvc.deleteObject(repositoryId, id, true, null);
        }
        idsToDelete.clear();
        LOG.debug("... cleaning up done");
    }

    /**
     * enumerate the children of the root folder and return the id of the first
     * document
     * 
     * @return id of first doc in root folder
     */
    private String getTestDocId() {
        return getTestId(BaseTypeId.CMIS_DOCUMENT);
    }

    /**
     * enumerate the children of the root folder and return the id of the first
     * sub-folder
     * 
     * @return id of first doc in root folder
     */
    private String getTestFolderId() {
        return getTestId(BaseTypeId.CMIS_FOLDER);
    }

    private String getTestId(BaseTypeId baseTypeId) {
        LOG.debug("getTestDocId()");
        ObjectInFolderList result = navSvc.getChildren(repositoryId, rootFolderId, "*", null, false,
                IncludeRelationships.NONE, null, true, MAX_ITEMS, SKIP_COUNT, null);

        List<ObjectInFolderData> children = result.getObjects();
        LOG.debug(" found " + children.size() + " folders in getChildren()");
        for (ObjectInFolderData child : children) {
            if (baseTypeId.equals(child.getObject().getBaseTypeId())) {
                return child.getObject().getId();
            }
        }
        return null;
    }

    private String prepareVersionSeries(String name, String typeId, String folderId) {
        String id = createDocumentIntern(name, typeId, folderId, VersioningState.MAJOR);
        Holder<Boolean> contentCopied = new Holder<Boolean>();
        Holder<String> idHolder = new Holder<String>(id);

        verSvc.checkOut(repositoryId, idHolder, null, contentCopied);
        String checkinComment = "Checkin V2.0";
        verSvc.checkIn(repositoryId, idHolder, true /* major */, null /* properties */, null /* content */,
                checkinComment, null/* policies */, null/* addAcl */, null /* removeAcl */, null /* extension */);

        verSvc.checkOut(repositoryId, idHolder, null, contentCopied);
        checkinComment = "Checkin V2.1";
        verSvc.checkIn(repositoryId, idHolder, false /* major */, null /* properties */, null /* content */,
                checkinComment, null/* policies */, null/* addAcl */, null /* removeAcl */, null /* extension */);

        return idHolder.getValue();
    }

    private void checkOut(String id) {
        LOG.debug("checkOut()");
        Holder<String> idHolder = new Holder<String>(id);
        Holder<Boolean> contentCopied = new Holder<Boolean>(true);
        verSvc.checkOut(repositoryId, idHolder, null, contentCopied);
        renameFiles("checkOut");
        LOG.debug("checkOut done.");
    }

    private void checkIn(String id, boolean major, String checkinComment) {
        LOG.debug("checkIn()");
        List<PropertyData<?>> properties = new ArrayList<PropertyData<?>>();
        properties.add(objFactory.createPropertyStringData(VERSIONED_PROP, "updated value"));
        Properties newProps = objFactory.createPropertiesData(properties);

        Holder<String> idHolder = new Holder<String>(id);
        verSvc.checkIn(repositoryId, idHolder, major /* major */, newProps /* properties */, null /* content */,
                checkinComment, null/* policies */, null/* addAcl */, null /* removeAcl */, null /* extension */);
        renameFiles("checkIn");
        LOG.debug("checkIn done.");
    }

    private void getAllVersions(String id) {
        LOG.debug("getAllVersions()");
        verSvc.getAllVersions(repositoryId, id/* object id */, id/* series id */, "*"/* filter */,
                false /* includeAllowableActions */, null /* extension */);
        renameFiles("getAllVersions");
        LOG.debug("getAllVersions done.");
    }

    private void getAcl(String objectId) {
        LOG.debug("getting Acl() " + objectId);

        // get old ACL first:
        Acl oldAcl = aclSvc.getAcl(repositoryId, objectId, true, null);

        // create a new ACL for the test doc
        List<Ace> aces = new ArrayList<Ace>();
        aces.add(objFactory.createAccessControlEntry("Alice", Collections.singletonList("cmis:read")));
        aces.add(objFactory.createAccessControlEntry("Bob", Collections.singletonList("cmis:write")));
        aces.add(objFactory.createAccessControlEntry("admin", Collections.singletonList("cmis:all")));
        Acl acl = objFactory.createAccessControlList(aces);

        // add the new ACL and remove the old one
        aclSvc.applyAcl(repositoryId, objectId, acl, oldAcl, AclPropagation.OBJECTONLY, null);

        aclSvc.getAcl(repositoryId, objectId, true, null);
        renameFiles("getAcl");
        LOG.debug("getting Acl() done.");
    }

    private void getTypeDefinition(String typeId) {
        LOG.debug("getTypeDefinition " + typeId);
        repSvc.getTypeDefinition(repositoryId, typeId, null);
        renameFiles("getTypeDefinition");
        LOG.debug("getTypeDefinition() done.");
    }

    private void getTypeDescendants(String typeId) {
        LOG.debug("getTypeDescendants " + typeId);
        repSvc.getTypeDescendants(repositoryId, typeId, TYPE_DEPTH_ALL, true /* includePropertyDefinitions */, null);
        renameFiles("getTypeDescendants");
        LOG.debug("getTypeDescendants() done.");
    }

    private void getAllowableActions(String objectId) {
        LOG.debug("getAllowableActions " + objectId);
        objSvc.getAllowableActions(repositoryId, objectId, null);
        renameFiles("getAllowableActions");
        LOG.debug("getAllowableActions() done.");
    }

    private void renameFiles(String name) {
        String fileNameInReq = findLastFile(LOGDIR, "*-request.log");
        String fileNameInResp = findLastFile(LOGDIR, "*-response.log");
        if (null == fileNameInReq) {
            LOG.error("Failed to find captured request file for " + name);
            return;
        }
        if (null == fileNameInResp) {
            LOG.error("Failed to find captured response file for " + name);
            return;
        }
        File in = new File(fileNameInReq);
        File out = new File(targetDir + File.separator + name + "-request.log");
        if (out.exists()) {
            out.delete();
        }
        boolean ok = in.renameTo(out);
        if (ok) {
            LOG.debug("Renaming file " + in.getAbsolutePath() + " to " + out.getAbsolutePath() + " succeeded.");
        } else {
            LOG.warn("Renaming file " + in.getAbsolutePath() + " to " + out.getAbsolutePath() + " failed.");
        }

        in = new File(fileNameInResp);
        out = new File(targetDir + File.separator + name + "-response.log");
        if (out.exists()) {
            out.delete();
        }
        ok = in.renameTo(out);
        if (ok) {
            LOG.debug("Renaming file " + in.getAbsolutePath() + "to " + out.getAbsolutePath() + " succeeded.");
        } else {
            LOG.warn("Renaming file " + in.getAbsolutePath() + " to " + out.getAbsolutePath() + " failed.");
        }
    }

    private void createZipFile(String zipFileName, String[] dirs) {

        File out = new File(zipFileName);
        if (out.exists()) {
            out.delete();
        }

        FileOutputStream fout = null;
        ZipOutputStream zout = null;
        try {
            fout = new FileOutputStream(zipFileName);
            zout = new ZipOutputStream(fout);
            for (String dir : dirs) {
                File dirToZip = new File(dir);
                addDirectory(zout, dir, dirToZip);
            }
        } catch (Exception e) {
            LOG.error("Creating ZIP file failed: " + e);
        } finally {
            IOUtils.closeQuietly(zout);
            IOUtils.closeQuietly(fout);
        }
    }

    private static void addDirectory(ZipOutputStream zout, String prefix, File sourceDir) throws IOException {

        File[] files = sourceDir.listFiles();
        LOG.debug("Create Zip, adding directory " + sourceDir.getName());

        if (null != files) {
            for (int i = 0; i < files.length; i++) {
                if (files[i].isDirectory()) {
                    addDirectory(zout, prefix + File.separator + files[i].getName(), files[i]);
                } else {
                    LOG.debug("Create Zip, adding file " + files[i].getName());
                    byte[] buffer = new byte[BUFSIZE];
                    FileInputStream fin = new FileInputStream(files[i]);
                    try {
                        String zipEntryName = prefix + File.separator + files[i].getName();
                        LOG.debug("   adding entry " + zipEntryName);
                        zout.putNextEntry(new ZipEntry(zipEntryName));

                        int length;
                        while ((length = fin.read(buffer)) > 0) {
                            zout.write(buffer, 0, length);
                        }
                    } finally {
                        IOUtils.closeQuietly(fin);
                        zout.closeEntry();
                    }
                }
            }
        }
    }

    public static void clean() {
        LOG.debug("Cleaning generated and captured request and response logs...");

        cleanFilesWithFilter(LOGDIR, "*-request.log");
        cleanFilesWithFilter(LOGDIR, "*-response.log");
        for (int i = 0; i < BINDINGS.length; i++) {
            String dir = BINDINGS[i].value();

            cleanFilesWithFilter(dir, "*-request.log");
            cleanFilesWithFilter(dir, "*-response.log");

            File dirToDelete = new File(dir);
            boolean ok = dirToDelete.delete();
            if (ok) {
                LOG.debug("Deleting dir " + dirToDelete.getAbsolutePath() + " succeeded.");
            } else {
                LOG.warn("Deleting dir " + dirToDelete.getAbsolutePath() + " failed.");
            }
        }
        new File("./target/logs/log4j.log").delete();
        LOG.debug("... done.");
    }

    private static void cleanFilesWithFilter(String directoryPath, String wildcardFilter) {
        File dir = new File(directoryPath);
        FileFilter fileFilter = new WildcardFileFilter(wildcardFilter);
        File[] files = dir.listFiles(fileFilter);
        if (files != null) {
            for (int i = 0; i < files.length; i++) {
                boolean ok = files[i].delete();
                LOG.debug("Deleting file: " + files[i] + ", success: " + ok);
            }
        }
    }

    private static String findLastFile(String directoryPath, String wildcardFilter) {
        File dir = new File(directoryPath);
        FileFilter fileFilter = new WildcardFileFilter(wildcardFilter);
        File[] files = dir.listFiles(fileFilter);
        LOG.debug("Number of files in filter dir " + files.length);
        if (files.length < NO_FILES_LOGGED) {
            LOG.warn("WARNING TOO FEW FILES!");
            // There might be some problem with disk caching, seems that
            // listFiles
            // does not always get the most recent state, ugly workaround
            try {
                Thread.sleep(SLEEP_TIME);
            } catch (InterruptedException e) {
                LOG.error("Thread interrupted: ", e);
            }
            files = dir.listFiles(fileFilter);
            if (files.length < NO_FILES_LOGGED) {
                LOG.error("WARNING TOO FEW FILES EVEN AFTER SECOND TRY!!!");
            }
        }
        NO_FILES_LOGGED = files.length;
        Arrays.sort(files);
        if (files.length == 0) {
            return null;
        } else {
            return files[files.length - 1].getAbsolutePath();
        }
    }

    public static void main(String[] args) {
        if (args.length > 0 && args[0].equals("-clean")) {
            LOG.debug("Cleaning up generated files...");
            SpecExamples.clean();
            LOG.debug("... cleaning up done.");
        } else {
            LOG.debug("Starting generating spec examples...");
            SpecExamples main = new SpecExamples();
            main.runAllBindings();
            LOG.debug("... finished generating spec examples.");
        }
    }

    private static boolean deleteDirRecursive(File path) {
        if (path.exists()) {
            File[] files = path.listFiles();
            for (int i = 0; i < files.length; i++) {
                if (files[i].isDirectory()) {
                    deleteDirRecursive(files[i]);
                } else {
                    files[i].delete();
                }
            }
        }
        return (path.delete());
    }

    private void cleanLogFilterDir() {
        File dir = new File(LOGDIR);
        FileFilter fileFilter = new WildcardFileFilter("*-request.log");
        File[] files = dir.listFiles(fileFilter);
        for (File f : files) {
            f.delete();
        }
        fileFilter = new WildcardFileFilter("*-response.log");
        files = dir.listFiles(fileFilter);
        for (File f : files) {
            f.delete();
        }
    }
}