#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; }
        AccountInfo Authenticate();
        //WebProxy Proxy { get; set; }
        double DownloadPercentLimit { get; set; }
        double UploadPercentLimit { get; set; }
        string AuthenticationUrl { get; set; }

        #region Container operations

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

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

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

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

        #endregion

        AccountInfo GetAccountPolicies(AccountInfo accountInfo);

        void UpdateMetadata(ObjectInfo objectInfo);

        void UpdateMetadata(ContainerInfo Container);
        IList<ShareAccountInfo> ListSharingAccounts(DateTime? since=null);
    }


    [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 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(AccountInfo);
        }

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

            return default(IList<ContainerInfo>);
        }

        public IList<ObjectInfo> ListSharedObjects(DateTime? since)
        {

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

            return default(IList<ObjectInfo>);
        }

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

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

            return default(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 IList<ObjectInfo> ListObjects(string account, string container, DateTime? since = null)
        {
            
            Contract.Requires(!String.IsNullOrWhiteSpace(Token));
            Contract.Requires(StorageUrl != null);
            Contract.Requires(!String.IsNullOrWhiteSpace(container));

            return default(IList<ObjectInfo>);
        }

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

            return default(IList<ObjectInfo>);
        }

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

            return default(bool);
        }

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

            return default(ContainerInfo);
        }

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

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

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

            return default(Task);
        }

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

            return default(Task);
        }

        public void DeleteObject(string account, string container, string objectName)
        {
            
            Contract.Requires(!String.IsNullOrWhiteSpace(Token));
            Contract.Requires(StorageUrl!=null);
            Contract.Requires(!String.IsNullOrWhiteSpace(container));
            Contract.Requires(!String.IsNullOrWhiteSpace(objectName));            
        }

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

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

            return default(bool);
        }

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

            return default(ObjectInfo);
        }

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

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

            return default(Task<TreeHash>);
        }

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

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

        public Task PostBlock(string account, string container, byte[] block, int offset, int count,CancellationToken token)
        {
            
            Contract.Requires(!String.IsNullOrWhiteSpace(Token));
            Contract.Requires(StorageUrl != null);
            Contract.Requires(!String.IsNullOrWhiteSpace(container));
            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, string container, Uri relativeUrl, long start, long? end,CancellationToken cancellationToken)
        {
            
            Contract.Requires(!String.IsNullOrWhiteSpace(Token));
            Contract.Requires(StorageUrl != null);
            Contract.Requires(!String.IsNullOrWhiteSpace(container));
            Contract.Requires(relativeUrl!=null);
            Contract.Requires(start>=0);
            Contract.Requires(end==null || end>=0);

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

    }
}