using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net;
using AppLimit.CloudComputing.SharpBox.Common.Extensions;
using AppLimit.CloudComputing.SharpBox.Common.Net.Web;
using AppLimit.CloudComputing.SharpBox.Common.Net.oAuth;
using AppLimit.CloudComputing.SharpBox.Common.Net.oAuth.Context;
using AppLimit.CloudComputing.SharpBox.Common.Net.oAuth.Token;
using AppLimit.CloudComputing.SharpBox.Exceptions;
using AppLimit.CloudComputing.SharpBox.StorageProvider.API;
using AppLimit.CloudComputing.SharpBox.StorageProvider.BaseObjects;

namespace AppLimit.CloudComputing.SharpBox.StorageProvider.GoogleDocs.Logic
{
    internal class GoogleDocsStorageProviderService : GenericStorageProviderService
    {
        public enum RemoveMode
        {
            Trash,
            Delete,
            FromParentCollection
        };

        #region GoogleDocs Specific

        public void RefreshDirectoryContent(IStorageProviderSession session, BaseDirectoryEntry entry)
        {
            if (entry == null)
                return;

            var url = string.Format(GoogleDocsConstants.GoogleDocsContentsUrlFormat, entry.Id.ReplaceFirst("_", "%3a"));
            var parameters = new Dictionary<string, string> { { "max-results", "1000" } };
            try
            {
                while (!string.IsNullOrEmpty(url))
                {
                    var request = CreateWebRequest(session, url, "GET", parameters);
                    using (var response = (HttpWebResponse)request.GetResponse())
                    using (var rs = response.GetResponseStream())
                    using (var streamReader = new StreamReader(rs))
                    {
                        var feedXml = streamReader.ReadToEnd();
                        var childs = GoogleDocsXmlParser.ParseEntriesXml(session, feedXml);
                        entry.AddChilds(childs);

                        url = GoogleDocsXmlParser.ParseNext(feedXml);
                    }
                }
            }
            catch (WebException)
            {
            }
        }

        public bool RemoveResource(IStorageProviderSession session, ICloudFileSystemEntry resource, RemoveMode mode)
        {
            string url;
            Dictionary<string, string> parameters = null;

            if (mode == RemoveMode.FromParentCollection)
            {
                var pId = (resource.Parent != null ? resource.Parent.Id : GoogleDocsConstants.RootFolderId).ReplaceFirst("_", "%3a");
                url = string.Format("{0}/{1}/contents/{2}", GoogleDocsConstants.GoogleDocsFeedUrl, pId, resource.Id.ReplaceFirst("_", "%3a"));
            }
            else
            {
                url = string.Format(GoogleDocsConstants.GoogleDocsResourceUrlFormat, resource.Id.ReplaceFirst("_", "%3a"));
                parameters = new Dictionary<string, string> { { "delete", "true" } };
            }

            var request = CreateWebRequest(session, url, "DELETE", parameters);
            request.Headers.Add("If-Match", "*");

            try
            {
                using (var response = (HttpWebResponse)request.GetResponse())
                    if (response.StatusCode == HttpStatusCode.OK)
                        return true;
            }
            catch (WebException)
            {
            }

            return false;
        }

        public bool AddToCollection(IStorageProviderSession session, ICloudFileSystemEntry resource, ICloudDirectoryEntry collection)
        {
            var url = string.Format(GoogleDocsConstants.GoogleDocsContentsUrlFormat, collection.Id.ReplaceFirst("_", "%3a"));
            var request = CreateWebRequest(session, url, "POST", null);
            GoogleDocsXmlParser.WriteAtom(request, GoogleDocsXmlParser.EntryElement(null, GoogleDocsXmlParser.IdElement(resource.Id.ReplaceFirst("_", "%3a"))));

            try
            {
                var response = (HttpWebResponse)request.GetResponse();
                if (response.StatusCode == HttpStatusCode.Created)
                    return true;
            }
            catch (WebException)
            {
            }

            return false;
        }

        #endregion

        #region GenericStorageProviderService members

        public override bool VerifyAccessTokenType(ICloudStorageAccessToken token)
        {
            return token is GoogleDocsToken;
        }

        public override IStorageProviderSession CreateSession(ICloudStorageAccessToken token, ICloudStorageConfiguration configuration)
        {
            var gdToken = token as GoogleDocsToken;
            return new GoogleDocsStorageProviderSession(this,
                                                        configuration,
                                                        new OAuthConsumerContext(gdToken.ConsumerKey, gdToken.ConsumerSecret),
                                                        gdToken);
        }

        public override ICloudFileSystemEntry RequestResource(IStorageProviderSession session, string name, ICloudDirectoryEntry parent)
        {
            if (GoogleDocsResourceHelper.IsNoolOrRoot(parent) && GoogleDocsResourceHelper.IsRootName(name))
            {
                var root = new BaseDirectoryEntry("/", 0, DateTime.Now, session.Service, session) { Id = GoogleDocsConstants.RootFolderId };
                root.SetPropertyValue(GoogleDocsConstants.ResCreateMediaProperty, GoogleDocsConstants.RootResCreateMediaUrl);
                RefreshDirectoryContent(session, root);
                return root;
            }

            if (name.Equals("/"))
            {
                RefreshDirectoryContent(session, parent as BaseDirectoryEntry);
            }

            if (GoogleDocsResourceHelper.IsResorceId(name))
            {
                var url = string.Format(GoogleDocsConstants.GoogleDocsResourceUrlFormat, name.ReplaceFirst("_", "%3a"));
                var request = CreateWebRequest(session, url, "GET", null);
                try
                {
                    string xml;
                    using (var response = (HttpWebResponse)request.GetResponse())
                    using (var rs = response.GetResponseStream())
                    using (var streamReader = new StreamReader(rs))
                    {
                        xml = streamReader.ReadToEnd();
                    }
                    var entry = GoogleDocsXmlParser.ParseEntriesXml(session, xml).FirstOrDefault();

                    if (entry == null)
                        throw new SharpBoxException(SharpBoxErrorCodes.ErrorFileNotFound);

                    if (parent != null)
                        (parent as BaseDirectoryEntry).AddChild(entry);

                    var dirEntry = entry as BaseDirectoryEntry;

                    if (dirEntry == null)
                        return entry;

                    RefreshDirectoryContent(session, dirEntry);
                    return dirEntry;
                }
                catch (WebException)
                {
                    throw new SharpBoxException(SharpBoxErrorCodes.ErrorFileNotFound);
                }
            }

            throw new SharpBoxException(SharpBoxErrorCodes.ErrorInvalidFileOrDirectoryName);
        }

        public override void RefreshResource(IStorageProviderSession session, ICloudFileSystemEntry resource)
        {
            if (resource == null)
                return;

            if (resource.Id.Equals(GoogleDocsConstants.RootFolderId))
            {
                RefreshDirectoryContent(session, resource as BaseDirectoryEntry);
                return;
            }

            var resourceUrl = string.Format(GoogleDocsConstants.GoogleDocsResourceUrlFormat, resource.Id.ReplaceFirst("_", "%3a"));
            var request = CreateWebRequest(session, resourceUrl, "GET", null);
            request.Headers.Add("If-None-Match", resource.GetPropertyValue(GoogleDocsConstants.EtagProperty));

            try
            {
                using (var response = (HttpWebResponse)request.GetResponse())
                {
                    if (response.StatusCode != HttpStatusCode.NotModified)
                    {
                        using (var s = response.GetResponseStream())
                        using (var streamReader = new StreamReader(s))
                        {
                            var xml = streamReader.ReadToEnd();

                            GoogleDocsResourceHelper.UpdateResourceByXml(session, out resource, xml);
                        }
                    }
                }

                var dirEntry = resource as BaseDirectoryEntry;

                if (dirEntry == null || dirEntry.HasChildrens == nChildState.HasChilds)
                    return;

                RefreshDirectoryContent(session, dirEntry);
            }
            catch (WebException)
            {

            }
        }

        public override ICloudFileSystemEntry CreateResource(IStorageProviderSession session, string name, ICloudDirectoryEntry parent)
        {
            if (string.IsNullOrEmpty(name))
            {
                throw new ArgumentException("Name cannot be empty");
            }

            var url = GoogleDocsResourceHelper.IsNoolOrRoot(parent)
                          ? GoogleDocsConstants.GoogleDocsFeedUrl
                          : string.Format(GoogleDocsConstants.GoogleDocsContentsUrlFormat, parent.Id.ReplaceFirst("_", "%3a"));

            var request = CreateWebRequest(session, url, "POST", null);
            GoogleDocsXmlParser.WriteAtom(request, GoogleDocsXmlParser.EntryElement(GoogleDocsXmlParser.CategoryElement(), GoogleDocsXmlParser.TitleElement(name)));

            try
            {
                using (var response = (HttpWebResponse)request.GetResponse())
                {
                    if (response.StatusCode == HttpStatusCode.Created)
                    {
                        using (var rs = response.GetResponseStream())
                        using (var streamReader = new StreamReader(rs))
                        {
                            var xml = streamReader.ReadToEnd();
                            var entry = GoogleDocsXmlParser.ParseEntriesXml(session, xml).First();

                            if (parent != null)
                                (parent as BaseDirectoryEntry).AddChild(entry);

                            return entry;
                        }
                    }
                }
            }
            catch (WebException)
            {
                throw new SharpBoxException(SharpBoxErrorCodes.ErrorCreateOperationFailed);
            }

            return null;
        }

        public override bool RenameResource(IStorageProviderSession session, ICloudFileSystemEntry fsentry, string newName)
        {
            if (string.IsNullOrEmpty(newName) || GoogleDocsResourceHelper.IsNoolOrRoot(fsentry))
                return false;

            var url = string.Format(GoogleDocsConstants.GoogleDocsResourceUrlFormat, fsentry.Id.ReplaceFirst("_", "%3a"));

            var request = CreateWebRequest(session, url, "PUT", null);
            request.Headers.Add("If-Match", fsentry.GetPropertyValue(GoogleDocsConstants.EtagProperty));
            GoogleDocsXmlParser.WriteAtom(request, GoogleDocsXmlParser.EntryElement(GoogleDocsXmlParser.TitleElement(newName)));

            try
            {
                var response = (HttpWebResponse)request.GetResponse();
                if (response.StatusCode == HttpStatusCode.OK)
                {
                    //check if extension added
                    if (!(fsentry is ICloudDirectoryEntry) && string.IsNullOrEmpty(Path.GetExtension(newName)))
                        newName = newName + Path.GetExtension(fsentry.Name);
                    (fsentry as BaseFileEntry).Name = newName;
                    return true;
                }
            }
            catch (WebException)
            {
            }

            return false;
        }

        public override bool DeleteResource(IStorageProviderSession session, ICloudFileSystemEntry entry)
        {
            if (GoogleDocsResourceHelper.IsNoolOrRoot(entry))
                return false;

            if (RemoveResource(session, entry, RemoveMode.Delete))
            {
                var parent = entry.Parent as BaseDirectoryEntry;
                if (parent != null)
                    parent.RemoveChildById(entry.Id);

                return true;
            }

            return false;
        }

        public override bool MoveResource(IStorageProviderSession session, ICloudFileSystemEntry fsentry, ICloudDirectoryEntry newParent)
        {
            if (fsentry == null || newParent == null || GoogleDocsResourceHelper.IsNoolOrRoot(fsentry))
                return false;

            if (RemoveResource(session, fsentry, RemoveMode.FromParentCollection) && AddToCollection(session, fsentry, newParent))
            {
                if (fsentry.Parent != null)
                    (fsentry.Parent as BaseDirectoryEntry).RemoveChild(fsentry as BaseFileEntry);
                (newParent as BaseDirectoryEntry).AddChild(fsentry as BaseFileEntry);

                return true;
            }

            return false;
        }

        public override bool CopyResource(IStorageProviderSession session, ICloudFileSystemEntry fsentry, ICloudDirectoryEntry newParent)
        {
            if (AddToCollection(session, fsentry, newParent))
            {
                (newParent as BaseDirectoryEntry).AddChild(fsentry as BaseFileEntry);
                return true;
            }
            return false;
        }

        public override string GetResourceUrl(IStorageProviderSession session, ICloudFileSystemEntry entry, string path)
        {
            if (!string.IsNullOrEmpty(path))
            {
                var id = path;
                var index = id.LastIndexOf("/");
                if (index != -1)
                {
                    id = id.Substring(index + 1);
                }
                if (GoogleDocsResourceHelper.IsResorceId(id))
                {
                    return id;
                }
            }
            else if (entry != null)
            {
                return entry.Id;
            }
            return base.GetResourceUrl(session, null, path);
        }

        public override Stream CreateDownloadStream(IStorageProviderSession session, ICloudFileSystemEntry fileSystemEntry)
        {
            var url = fileSystemEntry.GetPropertyValue(GoogleDocsConstants.DownloadUrlProperty);

            var format = GoogleDocsResourceHelper.GetStreamExtensionByKind(fileSystemEntry.GetPropertyValue(GoogleDocsConstants.KindProperty));
            if (!string.IsNullOrEmpty(format))
            {
                url = string.Format("{0}&exportFormat={1}", url, format);
                if (format.Equals("docx"))
                    url += "&format=" + format;
            }

            var request = CreateWebRequest(session, url, "GET", null, true);
            var response = (HttpWebResponse)request.GetResponse();

            if (fileSystemEntry.Length > 0)
            {
                return new BaseFileEntryDownloadStream(response.GetResponseStream(), fileSystemEntry);
            }

            var isChukedEncoding = string.Equals(response.Headers.Get("Transfer-Encoding"), "Chunked", StringComparison.OrdinalIgnoreCase);
            if (!isChukedEncoding)
            {
                ((BaseFileEntry)fileSystemEntry).Length = response.ContentLength;
                return new BaseFileEntryDownloadStream(response.GetResponseStream(), fileSystemEntry);
            }

            var tempBuffer = new FileStream(Path.GetTempFileName(), FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.Read, 8096, FileOptions.DeleteOnClose);
            using (var stream = response.GetResponseStream())
            {
                stream.CopyTo(tempBuffer);
            }
            tempBuffer.Flush();
            tempBuffer.Seek(0, SeekOrigin.Begin);
            return tempBuffer;
        }

        public override void CommitStreamOperation(IStorageProviderSession session, ICloudFileSystemEntry fileSystemEntry, nTransferDirection direction, Stream notDisposedStream)
        {
        }

        public override Stream CreateUploadStream(IStorageProviderSession session, ICloudFileSystemEntry fileSystemEntry, long uploadSize)
        {
            var tempStream = new FileStream(Path.GetTempFileName(), FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None, 4096, FileOptions.DeleteOnClose);
            var stream = new WebRequestStream(tempStream, null, null);
            stream.PushPreDisposeOperation(CommitUploadOperation, session, fileSystemEntry, tempStream, uploadSize);
            return stream;
        }

        public override bool SupportsDirectRetrieve
        {
            get { return false; }
        }

        private void CommitUploadOperation(object[] args)
        {
            var session = (IStorageProviderSession)args[0];
            var file = (BaseFileEntry)args[1];
            var stream = (Stream)args[2];
            var contentLength = (long)args[3];

            stream.Flush();
            stream.Seek(0, SeekOrigin.Begin);

            var uploadSession = CreateUploadSession(session, file, contentLength);
            UploadChunk(session, uploadSession, stream, contentLength);
        }

        #region resumable uploads

        public override bool SupportsChunking
        {
            get { return true; }
        }

        public override IResumableUploadSession CreateUploadSession(IStorageProviderSession session, ICloudFileSystemEntry fileSystemEntry, long bytesToTransfer)
        {
            WebRequest request;
            if (GoogleDocsResourceHelper.IsResorceId(fileSystemEntry.Id))
            {
                //request for update
                request = CreateWebRequest(session, fileSystemEntry.GetPropertyValue(GoogleDocsConstants.ResEditMediaProperty), "PUT", null, true);
                request.Headers.Add("If-Match", "*");
            }
            else
            {
                //request for create
                request = CreateWebRequest(session, fileSystemEntry.Parent.GetPropertyValue(GoogleDocsConstants.ResCreateMediaProperty) + "?convert=false", "POST", null, true);
            }

            if (GoogleDocsResourceHelper.OfGoogleDocsKind(fileSystemEntry))
            {
                ((BaseFileEntry)fileSystemEntry).Name = Path.GetFileNameWithoutExtension(fileSystemEntry.Name);
            }

            GoogleDocsXmlParser.WriteAtom(request, GoogleDocsXmlParser.EntryElement(GoogleDocsXmlParser.TitleElement(fileSystemEntry.Name)));
            request.Headers.Add("X-Upload-Content-Type", Common.Net.MimeMapping.GetMimeMapping(fileSystemEntry.Name));
            request.Headers.Add("X-Upload-Content-Length", bytesToTransfer.ToString(CultureInfo.InvariantCulture));


            var response = request.GetResponse();

            var uploadSession = new ResumableUploadSession(fileSystemEntry, bytesToTransfer);
            uploadSession["Location"] = response.Headers["Location"];
            uploadSession.Status = ResumableUploadSessionStatus.Started;

            return uploadSession;
        }

        public override void AbortUploadSession(IStorageProviderSession session, IResumableUploadSession uploadSession)
        {
            if (uploadSession.Status != ResumableUploadSessionStatus.Completed)
            {
                ((ResumableUploadSession)uploadSession).Status = ResumableUploadSessionStatus.Aborted;
            }
        }

        public override void UploadChunk(IStorageProviderSession session, IResumableUploadSession uploadSession, Stream stream, long chunkLength)
        {
            if (stream == null)
                throw new ArgumentNullException("stream");

            if (uploadSession.Status != ResumableUploadSessionStatus.Started)
                throw new InvalidOperationException("Can't upload chunk for given upload session.");

            var request = WebRequest.Create(uploadSession.GetItem<string>("Location"));
            request.Method = "PUT";
            request.ContentLength = chunkLength;
            request.Headers.Add("Content-Range", string.Format("bytes {0}-{1}/{2}",
                                                               uploadSession.BytesTransfered,
                                                               uploadSession.BytesTransfered + chunkLength - 1,
                                                               uploadSession.BytesToTransfer));

            using (var requestStream = request.GetRequestStream())
            {
                stream.CopyTo(requestStream);
            }

            HttpWebResponse response;
            try
            {
                response = (HttpWebResponse)request.GetResponse();
            }
            catch (WebException exception)
            {
                if (exception.Status == WebExceptionStatus.ProtocolError && exception.Response != null && exception.Response.Headers.AllKeys.Contains("Range"))
                {
                    response = (HttpWebResponse)exception.Response;
                }
                else
                {
                    throw;
                }
            }

            if (response.StatusCode != HttpStatusCode.Created)
            {
                var uplSession = (ResumableUploadSession)uploadSession;
                uplSession.BytesTransfered += chunkLength;

                var locationHeader = response.Headers["Location"];
                if (!string.IsNullOrEmpty(locationHeader))
                {
                    uplSession["Location"] = locationHeader;
                }
            }
            else
            {
                ((ResumableUploadSession)uploadSession).Status = ResumableUploadSessionStatus.Completed;

                using (var responseStream = response.GetResponseStream())
                {
                    if (responseStream == null) return;
                    string xml;
                    using (var streamReader = new StreamReader(responseStream))
                    {
                        xml = streamReader.ReadToEnd();
                    }
                    var respFile = GoogleDocsXmlParser.ParseEntriesXml(session, xml).First();
                    var initFile = (BaseFileEntry)uploadSession.File;

                    //replace old file with the file from response
                    initFile.Name = respFile.Name;
                    initFile.Id = respFile.Id;
                    initFile.Length = respFile.Length;
                    initFile.Modified = respFile.Modified;
                    initFile[GoogleDocsConstants.EtagProperty] = respFile[GoogleDocsConstants.EtagProperty];
                    initFile[GoogleDocsConstants.KindProperty] = respFile[GoogleDocsConstants.KindProperty];
                    initFile[GoogleDocsConstants.DownloadUrlProperty] = respFile[GoogleDocsConstants.DownloadUrlProperty];
                    initFile[GoogleDocsConstants.ResEditMediaProperty] = respFile[GoogleDocsConstants.ResEditMediaProperty];

                    var parent = initFile.Parent as BaseDirectoryEntry;
                    if (parent != null)
                    {
                        parent.RemoveChildById(initFile.Name);
                        parent.AddChild(initFile);
                    }
                }
            }

            response.Close();
        }

        #endregion

        #endregion

        #region oAuth

        public override void StoreToken(IStorageProviderSession session, Dictionary<string, string> tokendata, ICloudStorageAccessToken token)
        {
            if (token is GoogleDocsRequestToken)
            {
                var requestToken = token as GoogleDocsRequestToken;
                tokendata.Add(GoogleDocsConstants.TokenGoogleDocsAppKey, requestToken.RealToken.TokenKey);
                tokendata.Add(GoogleDocsConstants.TokenGoogleDocsAppSecret, requestToken.RealToken.TokenSecret);
            }
            else if (token is GoogleDocsToken)
            {
                var gdtoken = token as GoogleDocsToken;
                tokendata.Add(GoogleDocsConstants.TokenGoogleDocsAppKey, gdtoken.ConsumerKey);
                tokendata.Add(GoogleDocsConstants.TokenGoogleDocsAppSecret, gdtoken.ConsumerSecret);
                tokendata.Add(GoogleDocsConstants.TokenGoogleDocsUsername, gdtoken.TokenKey);
                tokendata.Add(GoogleDocsConstants.TokenGoogleDocsPassword, gdtoken.TokenSecret);
            }
        }

        public override ICloudStorageAccessToken LoadToken(Dictionary<string, string> tokendata)
        {
            var type = tokendata[CloudStorage.TokenCredentialType];

            if (type.Equals(typeof (GoogleDocsToken).ToString()))
            {
                var tokenKey = tokendata[GoogleDocsConstants.TokenGoogleDocsUsername];
                var tokenSecret = tokendata[GoogleDocsConstants.TokenGoogleDocsPassword];
                var consumerKey = tokendata[GoogleDocsConstants.TokenGoogleDocsAppKey];
                var consumerSecret = tokendata[GoogleDocsConstants.TokenGoogleDocsAppSecret];

                return new GoogleDocsToken(tokenKey, tokenSecret, consumerKey, consumerSecret);
            }

            if (type.Equals(typeof (GoogleDocsRequestToken).ToString()))
            {
                var tokenKey = tokendata[GoogleDocsConstants.TokenGoogleDocsAppKey];
                var tokenSecret = tokendata[GoogleDocsConstants.TokenGoogleDocsAppSecret];

                return new GoogleDocsRequestToken(new OAuthToken(tokenKey, tokenSecret));
            }

            throw new InvalidCastException("Token type not supported through this provider");
        }

        #endregion

        #region Helpers

        private static WebRequest CreateWebRequest(IStorageProviderSession storageProviderSession, string url, string method, Dictionary<string, string> parameters, bool oAuthParamsAsHeader = false)
        {
            var session = storageProviderSession as GoogleDocsStorageProviderSession;
            var configuration = session.ServiceConfiguration as GoogleDocsConfiguration;
            WebRequest request;
            if (!oAuthParamsAsHeader)
            {
                request = OAuthService.CreateWebRequest(url, method, null, null, session.Context, (GoogleDocsToken)session.SessionToken, parameters);
            }
            else
            {
                request = WebRequest.Create(url);
                request.Method = method;

                String oAuthHeader = OAuthService.GetOAuthAuthorizationHeader(url, session.Context, (GoogleDocsToken)session.SessionToken, null, method);
                request.Headers.Add("Authorization", oAuthHeader);
            }

            //using API's 3.0 version
            request.Headers.Add("GData-Version", configuration.GDataVersion);

            return request;
        }

        private static OAuthService OAuthService
        {
            get { return new OAuthService(); }
        }

        #endregion
    }
}