﻿using System;
/*
 * 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.
 */
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Linq;
using DotCMIS;
using DotCMIS.Client;
using DotCMIS.Client.Impl;
using DotCMIS.Data;
using DotCMIS.Data.Impl;
using DotCMIS.Enums;
using DotCMIS.Exceptions;
using NUnit.Framework;

namespace DotCMISUnitTest
{
    [TestFixture]
    class SmokeTest : TestFramework
    {
        [Test]
        public void SmokeTestSession()
        {
            Assert.NotNull(Session);
            Assert.NotNull(Session.Binding);
            Assert.NotNull(Session.RepositoryInfo);
            Assert.NotNull(Session.RepositoryInfo.Id);
            Assert.NotNull(Session.RepositoryInfo.RootFolderId);
            Assert.NotNull(Session.DefaultContext);
            Assert.NotNull(Session.ObjectFactory);

            Assert.AreEqual("test", Session.CreateObjectId("test").Id);
        }

        [Test]
        public void SmokeTestTypes()
        {
            // getTypeDefinition
            IObjectType documentType = Session.GetTypeDefinition("cmis:document");
            Assert.NotNull(documentType);
            Assert.True(documentType is DocumentType);
            Assert.AreEqual("cmis:document", documentType.Id);
            Assert.AreEqual(BaseTypeId.CmisDocument, documentType.BaseTypeId);
            Assert.True(documentType.IsBaseType);
            Assert.IsNullOrEmpty(documentType.ParentTypeId);
            Assert.NotNull(documentType.PropertyDefinitions);
            Assert.True(documentType.PropertyDefinitions.Count >= 9);

            IObjectType folderType = Session.GetTypeDefinition("cmis:folder");
            Assert.NotNull(folderType);
            Assert.True(folderType is FolderType);
            Assert.AreEqual("cmis:folder", folderType.Id);
            Assert.AreEqual(BaseTypeId.CmisFolder, folderType.BaseTypeId);
            Assert.True(folderType.IsBaseType);
            Assert.IsNullOrEmpty(folderType.ParentTypeId);
            Assert.NotNull(folderType.PropertyDefinitions);
            Assert.True(folderType.PropertyDefinitions.Count >= 9);

            // getTypeChildren
            Session.Clear();

            IItemEnumerable<IObjectType> children = Session.GetTypeChildren(null, true);
            Assert.NotNull(children);

            int count;
            count = 0;
            foreach (IObjectType type in children)
            {
                Assert.NotNull(type);
                Assert.NotNull(type.Id);
                Assert.True(type.IsBaseType);
                Assert.IsNullOrEmpty(type.ParentTypeId);
                Assert.NotNull(type.PropertyDefinitions);

                Session.Clear();
                IObjectType type2 = Session.GetTypeDefinition(type.Id);
                AssertAreEqual(type, type2);

                Session.GetTypeChildren(type.Id, true);

                count++;
            }

            Assert.True(count >= 2);
            Assert.True(count <= 4);

            // getTypeDescendants
            Session.Clear();

            IList<ITree<IObjectType>> descendants = Session.GetTypeDescendants(null, -1, true);

            count = 0;
            foreach (ITree<IObjectType> tree in descendants)
            {
                Assert.NotNull(tree);
                Assert.NotNull(tree.Item);

                IObjectType type = tree.Item;
                Assert.NotNull(type);
                Assert.NotNull(type.Id);
                Assert.True(type.IsBaseType);
                Assert.IsNullOrEmpty(type.ParentTypeId);
                Assert.NotNull(type.PropertyDefinitions);

                Session.Clear();
                IObjectType type2 = Session.GetTypeDefinition(type.Id);
                AssertAreEqual(type, type2);

                Session.GetTypeDescendants(type.Id, 2, true);

                count++;
            }

            Assert.True(count >= 2);
            Assert.True(count <= 4);
        }

        [Test]
        public void SmokeTestRootFolder()
        {
            ICmisObject rootFolderObject = Session.GetRootFolder();

            Assert.NotNull(rootFolderObject);
            Assert.NotNull(rootFolderObject.Id);
            Assert.True(rootFolderObject is IFolder);

            IFolder rootFolder = (IFolder)rootFolderObject;

            Assert.AreEqual("/", rootFolder.Path);
            Assert.AreEqual(1, rootFolder.Paths.Count);

            Assert.NotNull(rootFolder.AllowableActions);
            Assert.True(rootFolder.AllowableActions.Actions.Contains(Actions.CanGetProperties));
            Assert.False(rootFolder.AllowableActions.Actions.Contains(Actions.CanGetFolderParent));

            IItemEnumerable<ICmisObject> children = rootFolder.GetChildren();
            Assert.NotNull(children);
            foreach (ICmisObject child in children)
            {
                Assert.NotNull(child);
                Assert.NotNull(child.Id);
                Assert.NotNull(child.Name);
                Console.WriteLine(child.Name + " (" + child.Id + ")");
            }
        }

        [Test]
        public void SmokeTestQuery()
        {
            IItemEnumerable<IQueryResult> qr = Session.Query("SELECT * FROM cmis:document", false);
            Assert.NotNull(qr);

            foreach (IQueryResult hit in qr)
            {
                Assert.NotNull(hit);
                Assert.NotNull(hit["cmis:objectId"]);
                Console.WriteLine(hit.GetPropertyValueById(PropertyIds.Name) + " (" + hit.GetPropertyValueById(PropertyIds.ObjectId) + ")");

                foreach (IPropertyData prop in hit.Properties)
                {
                    string name = prop.QueryName;
                    object value = prop.FirstValue;
                }
            }
        }

        [Test]
        public void SmokeTestCreateDocument()
        {
            IDictionary<string, object> properties = new Dictionary<string, object>();
            properties[PropertyIds.Name] = "test-smoke.txt";
            properties[PropertyIds.ObjectTypeId] = DefaultDocumentType;

            byte[] content = UTF8Encoding.UTF8.GetBytes("Hello World!");

            ContentStream contentStream = new ContentStream();
            contentStream.FileName = properties[PropertyIds.Name] as string;
            contentStream.MimeType = "text/plain";
            contentStream.Length = content.Length;
            contentStream.Stream = new MemoryStream(content);

            IDocument doc = TestFolder.CreateDocument(properties, contentStream, null);

            // check doc
            Assert.NotNull(doc);
            Assert.NotNull(doc.Id);
            Assert.AreEqual(properties[PropertyIds.Name], doc.Name);
            Assert.AreEqual(BaseTypeId.CmisDocument, doc.BaseTypeId);
            Assert.True(doc.AllowableActions.Actions.Contains(Actions.CanGetProperties));
            Assert.False(doc.AllowableActions.Actions.Contains(Actions.CanGetChildren));

            // check type
            IObjectType type = doc.ObjectType;
            Assert.NotNull(type);
            Assert.NotNull(type.Id);
            Assert.AreEqual(properties[PropertyIds.ObjectTypeId], type.Id);

            // check versions
            IList<IDocument> versions = doc.GetAllVersions();
            Assert.NotNull(versions);
            Assert.AreEqual(1, versions.Count);
            //Assert.AreEqual(doc.Id, versions[0].Id);

            // check content
            IContentStream retrievedContentStream = doc.GetContentStream();
            Assert.NotNull(retrievedContentStream);
            Assert.NotNull(retrievedContentStream.Stream);

            MemoryStream byteStream = new MemoryStream();
            byte[] buffer = new byte[4096];
            int b = 1;
            while (b > 0)
            {
                b = retrievedContentStream.Stream.Read(buffer, 0, buffer.Length);
                byteStream.Write(buffer, 0, b);
            }

            byte[] retrievedContent = byteStream.ToArray();
            Assert.NotNull(retrievedContent);
            Assert.AreEqual(content.Length, retrievedContent.Length);
            for (int i = 0; i < content.Length; i++)
            {
                Assert.AreEqual(content[i], retrievedContent[i]);
            }

            // update name
            properties = new Dictionary<string, object>();
            properties[PropertyIds.Name] = "test2-smoke.txt";

            IObjectId newId = doc.UpdateProperties(properties);
            IDocument doc2 = Session.GetObject(newId) as IDocument;

            Assert.NotNull(doc2);

            doc2.Refresh();
            Assert.AreEqual(properties[PropertyIds.Name], doc2.Name);
            Assert.AreEqual(properties[PropertyIds.Name], doc2.GetPropertyValue(PropertyIds.Name));

            IProperty nameProperty = doc2[PropertyIds.Name];
            Assert.NotNull(nameProperty.PropertyType);
            Assert.AreEqual(properties[PropertyIds.Name], nameProperty.Value);
            Assert.AreEqual(properties[PropertyIds.Name], nameProperty.FirstValue);


            byte[] content2 = UTF8Encoding.UTF8.GetBytes("Hello Universe!");

            ContentStream contentStream2 = new ContentStream();
            contentStream2.FileName = properties[PropertyIds.Name] as string;
            contentStream2.MimeType = "text/plain";
            contentStream2.Length = content2.Length;
            contentStream2.Stream = new MemoryStream(content2);

            // doc.SetContentStream(contentStream2, true);

            doc2.Delete(true);

            try
            {
                doc.Refresh();
                Assert.Fail("Document shouldn't exist anymore!");
            }
            catch (CmisObjectNotFoundException) { }
        }

        [Test]
        public void SmokeTestVersioning()
        {
            IDictionary<string, object> properties = new Dictionary<string, object>();
            properties[PropertyIds.Name] = "test-version-smoke.txt";
            properties[PropertyIds.ObjectTypeId] = DefaultDocumentType;

            IDocument doc = TestFolder.CreateDocument(properties, null, VersioningState.Major);
            Assert.NotNull(doc);
            Assert.NotNull(doc.Id);
            Assert.AreEqual(properties[PropertyIds.Name], doc.Name);

            IList<IDocument> versions = doc.GetAllVersions();
            Assert.NotNull(versions);
            Assert.AreEqual(1, versions.Count);

            IObjectId pwcId = doc.CheckOut();
            Assert.NotNull(pwcId);

            IDocument pwc = Session.GetObject(pwcId) as IDocument;

            // check PWC
            Assert.NotNull(pwc);
            Assert.NotNull(pwc.Id);
            Assert.AreEqual(BaseTypeId.CmisDocument, doc.BaseTypeId);

            IDictionary<string, object> newProperties = new Dictionary<string, object>();
            newProperties[PropertyIds.Name] = "test-version2-smoke.txt";

            IObjectId doc2Id = pwc.CheckIn(true, newProperties, null, "new DotCMIS version");
            Assert.NotNull(doc2Id);

            IDocument doc2 = Session.GetObject(doc2Id) as IDocument;
            doc2.Refresh();

            // check new version
            Assert.NotNull(doc2);
            Assert.NotNull(doc2.Id);
            // Assert.AreEqual(newProperties[PropertyIds.Name], doc2.Name);
            Assert.AreEqual(BaseTypeId.CmisDocument, doc2.BaseTypeId);

            versions = doc2.GetAllVersions();
            Assert.NotNull(versions);
            Assert.AreEqual(2, versions.Count);

            IDocument last1 = doc.GetObjectOfLatestVersion(false);
            Assert.AreEqual(doc2.Id, last1.Id);

            IOperationContext oc = Session.CreateOperationContext();
            oc.CacheEnabled = false;
            IDocument last2 = Session.GetLatestDocumentVersion(doc.Id, oc);
            Assert.AreEqual(doc2.Id, last2.Id);

            doc2.DeleteAllVersions();

            try
            {
                doc2.Refresh();
                Assert.Fail("Document shouldn't exist anymore!");
            }
            catch (CmisObjectNotFoundException) { }
        }

        [Test]
        public void SmokeTestCreateFolder()
        {
            IDictionary<string, object> properties = new Dictionary<string, object>();
            properties[PropertyIds.Name] = "test-smoke";
            properties[PropertyIds.ObjectTypeId] = DefaultFolderType;

            IFolder folder = TestFolder.CreateFolder(properties);

            // check folder
            Assert.NotNull(folder);
            Assert.NotNull(folder.Id);
            Assert.AreEqual(properties[PropertyIds.Name], folder.Name);
            Assert.AreEqual(BaseTypeId.CmisFolder, folder.BaseTypeId);
            Assert.AreEqual(TestFolder.Id, folder.FolderParent.Id);
            Assert.False(folder.IsRootFolder);
            Assert.True(folder.Path.StartsWith("/"));
            Assert.True(folder.AllowableActions.Actions.Contains(Actions.CanGetProperties));
            Assert.True(folder.AllowableActions.Actions.Contains(Actions.CanGetChildren));
            Assert.False(folder.AllowableActions.Actions.Contains(Actions.CanGetContentStream));

            // rename folder
            folder.Rename("test-smoke-renamed");
            Assert.AreEqual("test-smoke-renamed", folder.Name);

            // check children
            foreach (ICmisObject cmisObject in folder.GetChildren())
            {
                Assert.Fail("Folder shouldn't have children!");
            }

            // check descendants
            bool? descSupport = Session.RepositoryInfo.Capabilities.IsGetDescendantsSupported;
            if (descSupport.HasValue && descSupport.Value)
            {
                IList<ITree<IFileableCmisObject>> list = folder.GetDescendants(-1);

                if (list != null)
                {
                    foreach (ITree<IFileableCmisObject> desc in list)
                    {
                        Assert.Fail("Folder shouldn't have children!");
                    }
                }
            }
            else
            {
                Console.WriteLine("GetDescendants not supported!");
            }

            // check folder tree
            bool? folderTreeSupport = Session.RepositoryInfo.Capabilities.IsGetFolderTreeSupported;
            if (folderTreeSupport.HasValue && folderTreeSupport.Value)
            {
                IList<ITree<IFileableCmisObject>> list = folder.GetFolderTree(-1);

                if (list != null)
                {
                    foreach (ITree<IFileableCmisObject> desc in list)
                    {
                        Assert.Fail("Folder shouldn't have children!");
                    }
                }
            }
            else
            {
                Console.WriteLine("GetFolderTree not supported!");
            }

            // check parents
            IFolder parent = folder.FolderParent;
            Assert.NotNull(parent);
            Assert.AreEqual(TestFolder.Id, parent.Id);

            IList<IFolder> parents = folder.Parents;
            Assert.NotNull(parents);
            Assert.True(parents.Count > 0);

            bool found = false;
            foreach (IFolder p in parents)
            {
                if (TestFolder.Id == p.Id)
                {
                    found = true;
                    break;
                }
            }
            Assert.True(found);

            folder.Delete(true);

            try
            {
                folder.Refresh();
                Assert.Fail("Folder shouldn't exist anymore!");
            }
            catch (CmisObjectNotFoundException) { }
        }

        [Test]
        public void SmokeTestContentChanges()
        {
            if (Session.RepositoryInfo.Capabilities.ChangesCapability != null)
            {
                if (Session.RepositoryInfo.Capabilities.ChangesCapability != CapabilityChanges.None)
                {
                    IChangeEvents changeEvents = Session.GetContentChanges(null, true, 1000);
                    Assert.NotNull(changeEvents);
                }
                else
                {
                    Console.WriteLine("Content changes not supported!");
                }
            }
            else
            {
                Console.WriteLine("ChangesCapability not set!");
            }
        }

        [Test]
        public void SmokeTestCMIS609()
        {
            IFolder rootFolder = Session.GetRootFolder();
            IEnumerable<ICmisObject> children = rootFolder.GetChildren();
            List<ICmisObject> childrenList = children.ToList();
        }
    }
}