#region
/* -----------------------------------------------------------------------
 * <copyright file="ICloudClient.cs" company="GRNet">
 * 
 * Copyright 2011-2012 GRNET S.A. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or
 * without modification, are permitted provided that the following
 * conditions are met:
 *
 *   1. Redistributions of source code must retain the above
 *      copyright notice, this list of conditions and the following
 *      disclaimer.
 *
 *   2. Redistributions in binary form must reproduce the above
 *      copyright notice, this list of conditions and the following
 *      disclaimer in the documentation and/or other materials
 *      provided with the distribution.
 *
 *
 * THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 * The views and conclusions contained in the software and
 * documentation are those of the authors and should not be
 * interpreted as representing official policies, either expressed
 * or implied, of GRNET S.A.
 * </copyright>
 * -----------------------------------------------------------------------
 */
#endregion
using System;
using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Net;
using System.Threading;
using System.Threading.Tasks;
using Pithos.Interfaces;

namespace Pithos.Network
{
    [ContractClass(typeof(ICloudClientContract))]
    public interface ICloudClient
    {

        string ApiKey { get; set; }
        string UserName { get; set; }
        Uri StorageUrl { get; set; }

        string Token { get; set; }

        bool UsePithos { get; set; }
        Task<AccountInfo> Authenticate();
        //WebProxy Proxy { get; set; }
        double DownloadPercentLimit { get; set; }
        double UploadPercentLimit { get; set; }
        string AuthenticationUrl { get; set; }

        #region Container operations

        Task<IList<ContainerInfo>> ListContainers(string account);
        IList<ObjectInfo> ListObjects(string account, Uri container, DateTimeOffset? since = null);
        IList<ObjectInfo> ListObjects(string account, Uri container, Uri folder, DateTimeOffset? since = null);
        Task<bool> ContainerExists(string account, Uri container);
        Task<ContainerInfo> GetContainerInfo(string account, Uri container);
        Task CreateContainer(string account, Uri container);
        Task DeleteContainer(string account, Uri container);
        #endregion

        #region Object operations        
        Task GetObject(string account, Uri container, Uri objectName, string fileName, CancellationToken cancellationToken);
        Task PutObject(string account, Uri container, Uri objectName, string fileName, string hash = null, string contentType = "application/octet-stream");
        Task DeleteObject(string account, Uri container, Uri objectName, bool isDirectory);
        //void DeleteObject(string container, string objectName, string account = null);
        Task MoveObject(string account, Uri sourceContainer, Uri oldObjectName, Uri targetContainer, Uri newObjectName);
        Task<bool> ObjectExists(string account, Uri container, Uri objectName);
        Task<ObjectInfo> GetObjectInfo(string account, Uri container, Uri objectName);
        Task CreateFolder(string account, Uri container, Uri folder);
        #endregion

        #region Hashmap operations        
        Task<TreeHash> GetHashMap(string account, Uri container, Uri objectName);
        Task<IList<string>> PutHashMap(string account, Uri container, Uri objectName, TreeHash hash);
        Task PostBlock(string account, Uri container, byte[] block, int offset, int count,string blockHash, CancellationToken token);
        Task<byte[]> GetBlock(string account, Uri container, Uri relativeUrl, long start, long? end, CancellationToken cancellationToken);
        #endregion

        #region Sharing operations        
        IList<ObjectInfo> ListSharedObjects(HashSet<string> knownContainers, DateTimeOffset? since);
        void ShareObject(string account, Uri container, Uri objectName, string shareTo, bool read, bool write);

        #endregion

        Task<AccountInfo> GetAccountPolicies(AccountInfo accountInfo);

        void UpdateMetadata(ObjectInfo objectInfo);

        void UpdateMetadata(ContainerInfo Container);
        IList<ShareAccountInfo> ListSharingAccounts(DateTime? since=null);
        Task WipeContainer(string account, Uri container);
    }


    [ContractClassFor(typeof(ICloudClient))]
    public abstract class ICloudClientContract:ICloudClient
    {

        public string ApiKey { get; set; }
        public string UserName { get; set; }
        public Uri StorageUrl { get; set; }
        public string Token { get; set; }
        
        public double DownloadPercentLimit { get; set; }
        public double UploadPercentLimit { get; set; }

        public string AuthenticationUrl { get; set; }

        public bool UsePithos { get; set; }

        public Task<AccountInfo> Authenticate()
        {
            Contract.Requires<ArgumentNullException>(!String.IsNullOrWhiteSpace(ApiKey), "ApiKey must be filled before calling Authenticate");
            Contract.Requires<ArgumentNullException>(!String.IsNullOrWhiteSpace(UserName), "UserName must be filled before calling Authenticate");

            return default(Task<AccountInfo>);
        }

        public Task<IList<ContainerInfo>> ListContainers(string account)
        {
            Contract.Requires(!String.IsNullOrWhiteSpace(Token));
            Contract.Requires(StorageUrl!=null);            

            return default(Task<IList<ContainerInfo>>);
        }

        public IList<ObjectInfo> ListSharedObjects(HashSet<string> knownContainers, DateTimeOffset? since)
        {

            Contract.Requires(knownContainers!=null);
            Contract.Requires(!String.IsNullOrWhiteSpace(Token));
            Contract.Requires(StorageUrl != null);

            return default(IList<ObjectInfo>);
        }

        public void ShareObject(string account, Uri container, Uri objectName, string shareTo, bool read, bool write)
        {
            
            Contract.Requires(!String.IsNullOrWhiteSpace(Token));
            Contract.Requires(StorageUrl != null);
            Contract.Requires(container!=null);
            Contract.Requires(!container.IsAbsoluteUri);
            Contract.Requires(objectName != null);
            Contract.Requires(!objectName.IsAbsoluteUri);
            Contract.Requires(!String.IsNullOrWhiteSpace(account));
            Contract.Requires(!String.IsNullOrWhiteSpace(shareTo));
   
        }

        public Task<AccountInfo> GetAccountPolicies(AccountInfo accountInfo)
        {
            Contract.Requires(accountInfo!=null);

            return default(Task<AccountInfo>);
        }

        public void UpdateMetadata(ObjectInfo objectInfo)
        {
            Contract.Requires(objectInfo!=null);

            return ;
        }
        
        public void UpdateMetadata(ContainerInfo objectInfo)
        {
            Contract.Requires(objectInfo!=null);

            return ;
        }

        public IList<ShareAccountInfo> ListSharingAccounts(DateTime? since = new DateTime?())
        {
            return default(IList<ShareAccountInfo>);
        }

        public Task WipeContainer(string account, Uri container)
        {
            Contract.Requires(!String.IsNullOrWhiteSpace(Token));
            Contract.Requires(StorageUrl != null);
            Contract.Requires(container != null);
            Contract.Requires(!container.IsAbsoluteUri);

            return default(Task);
        }


        public IList<ObjectInfo> ListObjects(string account, Uri container, DateTimeOffset? since = null)
        {
            
            Contract.Requires(!String.IsNullOrWhiteSpace(Token));
            Contract.Requires(StorageUrl != null);
            Contract.Requires(container != null);
            Contract.Requires(!container.IsAbsoluteUri);

            return default(IList<ObjectInfo>);
        }

        public IList<ObjectInfo> ListObjects(string account, Uri container, Uri folder, DateTimeOffset? since = null)
        {
            
            Contract.Requires(!String.IsNullOrWhiteSpace(Token));
            Contract.Requires(StorageUrl != null);
            Contract.Requires(container != null);
            Contract.Requires(!container.IsAbsoluteUri);

            //Contract.Requires(!String.IsNullOrWhiteSpace(folder));

            return default(IList<ObjectInfo>);
        }

        public Task<bool> ContainerExists(string account, Uri container)
        {
            
            Contract.Requires(!String.IsNullOrWhiteSpace(Token));
            Contract.Requires(StorageUrl!=null);
            Contract.Requires(container != null);
            Contract.Requires(!container.IsAbsoluteUri);

            return default(Task<bool>);
        }

        public Task<ContainerInfo> GetContainerInfo(string account, Uri container)
        {
            
            Contract.Requires(!String.IsNullOrWhiteSpace(Token));
            Contract.Requires(StorageUrl!=null);
            Contract.Requires(container != null);
            Contract.Requires(!container.IsAbsoluteUri);

            return default(Task<ContainerInfo>);
        }

        public Task CreateContainer(string account, Uri container)
        {
            
            Contract.Requires(!String.IsNullOrWhiteSpace(Token));
            Contract.Requires(StorageUrl!=null);
            Contract.Requires(container != null);
            Contract.Requires(!container.IsAbsoluteUri);

            return default(Task);
        }

        public Task DeleteContainer(string account, Uri container)
        {
            
            Contract.Requires(!String.IsNullOrWhiteSpace(Token));
            Contract.Requires(StorageUrl!=null);
            Contract.Requires(container != null);
            Contract.Requires(!container.IsAbsoluteUri);

            return default(Task);
        }

        public Task GetObject(string account, Uri container, Uri objectName, string fileName, CancellationToken cancellationToken)
        {
            
            Contract.Requires(!String.IsNullOrWhiteSpace(Token));
            Contract.Requires(StorageUrl!=null);
            Contract.Requires(container != null);
            Contract.Requires(!container.IsAbsoluteUri);
            Contract.Requires(objectName != null);
            Contract.Requires(!objectName.IsAbsoluteUri);

            return default(Task);
        }

        public Task PutObject(string account, Uri container, Uri objectName, string fileName, string hash = null, string contentType = "application/octet-stream")
        {
            
            Contract.Requires(!String.IsNullOrWhiteSpace(Token));
            Contract.Requires(StorageUrl!=null);
            Contract.Requires(!String.IsNullOrWhiteSpace(fileName));
            Contract.Requires(container != null);
            Contract.Requires(!container.IsAbsoluteUri);
            Contract.Requires(objectName != null);
            Contract.Requires(!objectName.IsAbsoluteUri);
            Contract.Requires(!String.IsNullOrWhiteSpace(contentType));

            return default(Task);
        }

        public Task DeleteObject(string account, Uri container, Uri objectName, bool isDirectory)
        {
            
            Contract.Requires(!String.IsNullOrWhiteSpace(Token));
            Contract.Requires(StorageUrl!=null);
            Contract.Requires(container != null);
            Contract.Requires(!container.IsAbsoluteUri);
            Contract.Requires(objectName != null);
            Contract.Requires(!objectName.IsAbsoluteUri);

            return default(Task);
        }

        public Task MoveObject(string account, Uri sourceContainer, Uri oldObjectName, Uri targetContainer, Uri newObjectName)
        {
            
            Contract.Requires(!String.IsNullOrWhiteSpace(Token));
            Contract.Requires(StorageUrl!=null);
            Contract.Requires(sourceContainer != null);
            Contract.Requires(!sourceContainer.IsAbsoluteUri);
            Contract.Requires(oldObjectName != null);
            Contract.Requires(!oldObjectName.IsAbsoluteUri);

            Contract.Requires(targetContainer != null);
            Contract.Requires(!targetContainer.IsAbsoluteUri);
            Contract.Requires(newObjectName != null);
            Contract.Requires(!newObjectName.IsAbsoluteUri);

            return default(Task);
        }

        public Task<bool> ObjectExists(string account, Uri container, Uri objectName)
        {
            
            Contract.Requires(!String.IsNullOrWhiteSpace(Token));
            Contract.Requires(StorageUrl!=null);
            Contract.Requires(container != null);
            Contract.Requires(!container.IsAbsoluteUri);
            Contract.Requires(objectName != null);
            Contract.Requires(!objectName.IsAbsoluteUri);

            return default(Task<bool>);
        }

        public Task<ObjectInfo> GetObjectInfo(string account, Uri container, Uri objectName)
        {
            
            Contract.Requires(!String.IsNullOrWhiteSpace(Token));
            Contract.Requires(StorageUrl!=null);
            Contract.Requires(container != null);
            Contract.Requires(!container.IsAbsoluteUri);
            Contract.Requires(objectName != null);
            Contract.Requires(!objectName.IsAbsoluteUri);

            return default(Task<ObjectInfo>);
        }

        public Task CreateFolder(string account, Uri container, Uri folder)
        {
            
            Contract.Requires(!String.IsNullOrWhiteSpace(Token));
            Contract.Requires(StorageUrl != null);
            Contract.Requires(container != null);
            Contract.Requires(!container.IsAbsoluteUri);
            Contract.Requires(folder != null);
            Contract.Requires(!folder .IsAbsoluteUri);

            return default(Task);
        }

        public Task<TreeHash> GetHashMap(string account, Uri container, Uri objectName)
        {
            
            Contract.Requires(!String.IsNullOrWhiteSpace(Token));
            Contract.Requires(StorageUrl != null);
            Contract.Requires(container != null);
            Contract.Requires(!container.IsAbsoluteUri);
            Contract.Requires(objectName != null);
            Contract.Requires(!objectName.IsAbsoluteUri);

            return default(Task<TreeHash>);
        }

        public Task<IList<string>> PutHashMap(string account, Uri container, Uri objectName, TreeHash hash)
        {
            
            Contract.Requires(!String.IsNullOrWhiteSpace(Token));
            Contract.Requires(StorageUrl != null);
            Contract.Requires(container != null);
            Contract.Requires(!container.IsAbsoluteUri);
            Contract.Requires(objectName != null);
            Contract.Requires(!objectName.IsAbsoluteUri);
            Contract.Requires(hash != null);

            return default(Task<IList<string>>);
        }

        public Task PostBlock(string account, Uri container, byte[] block, int offset, int count, string blockHash,CancellationToken token)
        {
            
            Contract.Requires(!String.IsNullOrWhiteSpace(Token));
            Contract.Requires(StorageUrl != null);
            Contract.Requires(container != null);
            Contract.Requires(!container.IsAbsoluteUri);
            Contract.Requires(block != null);
            Contract.Requires(offset>=0);
            Contract.Requires(offset < block.Length);
            Contract.Requires(count>=0);
            Contract.Requires(count <= block.Length);
            
            return default(Task);
        }

        public Task<byte[]> GetBlock(string account, Uri container, Uri relativeUrl, long start, long? end, CancellationToken cancellationToken)
        {
            
            Contract.Requires(!String.IsNullOrWhiteSpace(Token));
            Contract.Requires(StorageUrl != null);
            Contract.Requires(container != null);
            Contract.Requires(!container.IsAbsoluteUri);
            Contract.Requires(relativeUrl != null);
            Contract.Requires(start>=0);
            Contract.Requires(end==null || end>=0);

            return default(Task<byte[]>);
        }

    }
}