/// <summary>
        /// Create a folder on the filesytem
        /// </summary>
        /// <param name="name">Folder name</param>
        /// <param name="parent">Parent node to attach created folder</param>
        /// <exception cref="NotSupportedException">Not logged in</exception>
        /// <exception cref="ApiException">Mega.co.nz service reports an error</exception>
        /// <exception cref="ArgumentNullException">name or parent is null</exception>
        /// <exception cref="ArgumentException">parent is not valid (all types are allowed expect <see cref="NodeType.File" />)</exception>
        public INode CreateFolder(string name, INode parent)
        {
            if (string.IsNullOrEmpty(name))
            {
                throw new ArgumentNullException("name");
            }

            if (parent == null)
            {
                throw new ArgumentNullException("parent");
            }

            if (parent.Type == NodeType.File)
            {
                throw new ArgumentException("Invalid parent node");
            }

            EnsureLoggedIn();

            byte[] key          = Crypto.CreateAesKey();
            byte[] attributes   = Crypto.EncryptAttributes(new Attributes(name), key);
            byte[] encryptedKey = Crypto.EncryptAes(key, masterKey);

            CreateNodeRequest request  = CreateNodeRequest.CreateFolderNodeRequest(parent, attributes.ToBase64(), encryptedKey.ToBase64(), key);
            GetNodesResponse  response = Request <GetNodesResponse>(request, masterKey);

            return(response.Nodes[0]);
        }
        /// <summary>
        /// Upload a stream on Mega.co.nz and attach created node to selected parent
        /// </summary>
        /// <param name="stream">Data to upload</param>
        /// <param name="name">Created node name</param>
        /// <param name="parent">Node to attach the uploaded file (all types except <see cref="NodeType.File" /> are supported)</param>
        /// <returns>Created node</returns>
        /// <exception cref="NotSupportedException">Not logged in</exception>
        /// <exception cref="ApiException">Mega.co.nz service reports an error</exception>
        /// <exception cref="ArgumentNullException">stream or name or parent is null</exception>
        /// <exception cref="ArgumentException">parent is not valid (all types except <see cref="NodeType.File" /> are supported)</exception>
        public INode Upload(Stream stream, string name, INode parent, DateTime?modificationDate = null, CancellationToken?cancellationToken = null)
        {
            if (stream == null)
            {
                throw new ArgumentNullException("stream");
            }

            if (string.IsNullOrEmpty(name))
            {
                throw new ArgumentNullException("name");
            }

            if (parent == null)
            {
                throw new ArgumentNullException("parent");
            }

            if (parent.Type == NodeType.File)
            {
                throw new ArgumentException("Invalid parent node");
            }

            EnsureLoggedIn();

            if (cancellationToken.HasValue)
            {
                stream = new CancellableStream(stream, cancellationToken.Value);
            }

            string completionHandle = string.Empty;
            int    requestDelay     = options.ApiRequestDelay;
            int    remainingRetry   = options.ApiRequestAttempts;

            while (remainingRetry-- > 0)
            {
                // Retrieve upload URL
                UploadUrlRequest  uploadRequest  = new UploadUrlRequest(stream.Length);
                UploadUrlResponse uploadResponse = Request <UploadUrlResponse>(uploadRequest);

                ApiResultCode apiResult = ApiResultCode.Ok;
                using (MegaAesCtrStreamCrypter encryptedStream = new MegaAesCtrStreamCrypter(stream))
                {
                    var chunkStartPosition  = 0;
                    var chunksSizesToUpload = ComputeChunksSizesToUpload(encryptedStream.ChunksPositions, encryptedStream.Length).ToArray();
                    Uri uri = null;
                    for (int i = 0; i < chunksSizesToUpload.Length; i++)
                    {
                        completionHandle = string.Empty;

                        int    chunkSize   = chunksSizesToUpload[i];
                        byte[] chunkBuffer = new byte[chunkSize];
                        encryptedStream.Read(chunkBuffer, 0, chunkSize);

                        using (MemoryStream chunkStream = new MemoryStream(chunkBuffer))
                        {
                            uri = new Uri(uploadResponse.Url + "/" + chunkStartPosition);
                            chunkStartPosition += chunkSize;
                            try
                            {
                                completionHandle = webClient.PostRequestRaw(uri, chunkStream);
                                if (string.IsNullOrEmpty(completionHandle))
                                {
                                    apiResult = ApiResultCode.Ok;
                                    continue;
                                }

                                long retCode;
                                if (completionHandle.FromBase64().Length != 27 && long.TryParse(completionHandle, out retCode))
                                {
                                    apiResult = (ApiResultCode)retCode;
                                    break;
                                }
                            }
                            catch (Exception ex)
                            {
                                apiResult = ApiResultCode.RequestFailedRetry;
                                ApiRequestFailed?.Invoke(this, new ApiRequestFailedEventArgs(uri, remainingRetry, requestDelay, apiResult, ex));

                                break;
                            }
                        }
                    }

                    if (apiResult != ApiResultCode.Ok)
                    {
                        ApiRequestFailed?.Invoke(this, new ApiRequestFailedEventArgs(uri, remainingRetry, requestDelay, apiResult, completionHandle));

                        if (apiResult == ApiResultCode.RequestFailedRetry || apiResult == ApiResultCode.RequestFailedPermanetly || apiResult == ApiResultCode.TooManyRequests)
                        {
                            // Restart upload from the beginning
                            Thread.Sleep(requestDelay = (int)Math.Round(requestDelay * options.ApiRequestDelayExponentialFactor));

                            // Reset steam position
                            stream.Seek(0, SeekOrigin.Begin);

                            continue;
                        }

                        throw new ApiException(apiResult);
                    }

                    // Encrypt attributes
                    byte[] cryptedAttributes = Crypto.EncryptAttributes(new Attributes(name, stream, modificationDate), encryptedStream.FileKey);

                    // Compute the file key
                    byte[] fileKey = new byte[32];
                    for (int i = 0; i < 8; i++)
                    {
                        fileKey[i]      = (byte)(encryptedStream.FileKey[i] ^ encryptedStream.Iv[i]);
                        fileKey[i + 16] = encryptedStream.Iv[i];
                    }

                    for (int i = 8; i < 16; i++)
                    {
                        fileKey[i]      = (byte)(encryptedStream.FileKey[i] ^ encryptedStream.MetaMac[i - 8]);
                        fileKey[i + 16] = encryptedStream.MetaMac[i - 8];
                    }

                    byte[] encryptedKey = Crypto.EncryptKey(fileKey, masterKey);

                    CreateNodeRequest createNodeRequest  = CreateNodeRequest.CreateFileNodeRequest(parent, cryptedAttributes.ToBase64(), encryptedKey.ToBase64(), fileKey, completionHandle);
                    GetNodesResponse  createNodeResponse = Request <GetNodesResponse>(createNodeRequest, masterKey);
                    return(createNodeResponse.Nodes[0]);
                }
            }

            throw new UploadException(completionHandle);
        }