using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using NLog;
using Sony.Filtr.ApolloAPI.Models;
using Sony.Filtr.Utility.Extensions;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Threading.Tasks;
using System.Web;

namespace Sony.Filtr.ApolloAPI
{
    public class ApolloWebApi : ApolloWebApiBase, IApolloWebApi
    {
        private readonly ApolloApiSettings Settings;

        public const int SpotifyMaxTracksPerRequest = 100;
        public const int MaxArtistBatchSize = 50;
        public const int MaxPlaylistsForUserBatchSize = 50;

        public ApolloWebApi(HttpClient httpClient, ApolloApiSettings settings) : base(httpClient)
        {
            this.Settings = settings;
        }

        protected override string GetLoggerName()
        {
            return "ApolloWebApi";
        }

        private async Task<TItem[]> GetByBatches<TResponse, TItem>(
            int batchSize,
            Func<TResponse, int> getTotalFunc,
            Func<Batch, TimeSpan, Task<TResponse>> spotifyFunc,
            Func<TResponse, IEnumerable<TItem>> getItemsFunc,
            TimeSpan cacheExpiration)
        {
            var initialResponse = await spotifyFunc(new Batch(0, batchSize), cacheExpiration);

            if (initialResponse == null) { return Array.Empty<TItem>(); }

            var result = new List<TItem>(getItemsFunc(initialResponse));

            if (getTotalFunc(initialResponse) > result.Count)
            {
                var responses = await this.GetBatchResponses(
                    getTotalFunc(initialResponse).Batch(batchSize).Skip(1),
                    async (batch, expiration) => getItemsFunc(await spotifyFunc(batch, expiration)),
                    cacheExpiration);

                result.AddRange(responses);
            }

            return result.ToArray();
        }

        private async Task<TResponse[]> GetBatchResponses<TResponse>(
            IEnumerable<Batch> batches,
            Func<Batch, TimeSpan, Task<IEnumerable<TResponse>>> spotifyFunc,
            TimeSpan cacheExpiration)
        {
            var tasks = batches.Select(async b =>
            {
                var response = await spotifyFunc(b, cacheExpiration);

                return BatchResponse<TResponse>.CreateSuccess(response, b);
            }).ToArray();

            await tasks.EnsureAllSuccessAsync();

            return tasks.Select(t => t.Result).OrderBy(r => r.Batch.Offset).SelectMany(r => r.Items).ToArray();
        }

        public async Task<SpotifyBrowseCategory[]> GetAllBrowseCategoriesAsync(string region = null)
        {
            return await this.GetAllBrowseCategoriesAsync(NoCacheTime, region);
        }

        public async Task<SpotifyBrowseCategory[]> GetAllBrowseCategoriesAsync(TimeSpan cacheExpiration, string region = null)
        {
            return await this.GetByBatches(
                MaxPlaylistsForUserBatchSize,
                r => r.categories.total,
                async (batch, expiration) => await GetBrowseCategoriesAsync(expiration, region, limit: batch.Limit, offset: batch.Offset),
                r => r.categories.items,
                cacheExpiration);
        }

        public async Task<PlaylistFavorites> GetPlaylistFavorites()
        {
            string url = "user-data-api/v1/joint/favorites/?application=apollo&type=playlist";

            FavoritePlaylistsResponse response = await this.GetFromApollo(url, ParseResponse<FavoritePlaylistsResponse>, NoCacheTime);

            return response.Normalize();
        }

        public async Task<SpotifyBrowseCategoriesResponse> GetBrowseCategoriesAsync(TimeSpan cacheExpiration, string country = null, int? limit = null, int? offset = null)
        {
            string pathAndQuery = "vendor-api/spotify/v1/browse/categories";

            var parameters = HttpUtility.ParseQueryString(String.Empty);
            if (!string.IsNullOrWhiteSpace(country))
            {
                parameters["country"] = country;
            }

            if (limit.HasValue)
            {
                parameters["limit"] = limit.ToString();
            }

            if (offset.HasValue)
            {
                parameters["offset"] = offset.ToString();
            }

            pathAndQuery += $"?{parameters.ToString()}";

            return await this.GetFromApollo(pathAndQuery, ParseResponse< SpotifyBrowseCategoriesResponse>, cacheExpiration);
        }

        public async Task<SpotifySimplifiedPlaylist[]> GetAllBrowseCategoryPlaylistsAsync(string categoryId, string region = null)
        {
            return await this.GetAllBrowseCategoryPlaylistsAsync(categoryId, NoCacheTime, region);
        }

        public async Task<SpotifySimplifiedPlaylist[]> GetAllBrowseCategoryPlaylistsAsync(string categoryId, TimeSpan cacheExpiration, string region = null)
        {
            return await this.GetByBatches(
                MaxPlaylistsForUserBatchSize,
                r => r.playlists.total,
                async (batch, expiration) => await GetBrowseCategoryPlaylistsAsync(categoryId, expiration, region, limit: batch.Limit, offset: batch.Offset),
                r => r?.playlists?.items,
                cacheExpiration);
        }

        public async Task<SpotifyBrowsePlaylistsResponse> GetBrowseCategoryPlaylistsAsync(string categoryId, TimeSpan cacheExpiration, string country = null, int? limit = null, int? offset = null)
        {
            string pathAndQuery = $"vendor-api/spotify/v1/browse/categories/{categoryId}/playlists";

            var parameters = HttpUtility.ParseQueryString(String.Empty);
            if (!string.IsNullOrWhiteSpace(country))
            {
                parameters["country"] = country;
            }

            if (limit.HasValue)
            {
                parameters["limit"] = limit.ToString();
            }

            if (offset.HasValue)
            {
                parameters["offset"] = offset.ToString();
            }

            pathAndQuery += $"?{parameters.ToString()}";


            return await this.GetFromApollo(pathAndQuery, ParseResponse< SpotifyBrowsePlaylistsResponse>, cacheExpiration);
        }

        public async Task<SpotifyBrowsePlaylistsResponse> GetBrowseFeaturedPlaylistsAsync(string country = null)
        {
            return await this.GetBrowseFeaturedPlaylistsAsync(NoCacheTime, country);
        }

        public async Task<SpotifyBrowsePlaylistsResponse> GetBrowseFeaturedPlaylistsAsync(TimeSpan cacheExpiration, string country = null)
        {
            string pathAndQuery = "vendor-api/spotify/v1/browse/featured-playlists";

            var parameters = HttpUtility.ParseQueryString(String.Empty);
            if (!string.IsNullOrWhiteSpace(country))
            {
                parameters["country"] = country;
            }

            parameters["limit"] = 50.ToString(); // 50 is max as specified in the API documentation 2015-02-17

            pathAndQuery += $"?{parameters.ToString()}";

            return await this.GetFromApollo(pathAndQuery, ParseResponse< SpotifyBrowsePlaylistsResponse>, cacheExpiration);

        }

        public async Task<SpotifyUserResponse> GetUserAsync(string spotifyUsername, string fields = null)
        {
            return await this.GetUserAsync(spotifyUsername, NoCacheTime, fields);
        }

        public async Task<SpotifyUserResponse> GetUserAsync(string spotifyUsername, TimeSpan cacheExpiration, string fields = null)
        {
            string pathAndQuery = "vendor-api/spotify/v1/users/";
            var parameters = HttpUtility.ParseQueryString(String.Empty);

            if (!String.IsNullOrWhiteSpace(fields))
            {
                parameters["fields"] = fields;
            }

            pathAndQuery += $"?{parameters.ToString()}";

            return await this.GetFromApollo(pathAndQuery, ParseResponse< SpotifyUserResponse>, cacheExpiration);
        }

        public async Task<SpotifyPlaylistItem[]> GetAllPublicPlaylistsAsync(string userName, string fields = null)
        {
            return await this.GetAllPublicPlaylistsAsync(userName, NoCacheTime, fields);
        }

        public async Task<SpotifyPlaylistItem[]> GetAllPublicPlaylistsAsync(string userName, TimeSpan cacheExpiration, string fields = null)
        {
            return await this.GetByBatches(
                MaxPlaylistsForUserBatchSize,
                r => r.total,
                async (batch, expiration) => await GetPublicPlaylistsAsync(userName, expiration, fields, limit: batch.Limit, offset: batch.Offset),
                r => r.items,
                cacheExpiration);
        }

        public async Task<SpotifyPublicPlaylistsResponse> GetPublicPlaylistsAsync(string username, TimeSpan cacheExpiration, string fields = null, int? limit = null, int? offset = null)
        {
            string pathAndQuery = $"vendor-api/spotify/v1/users/{username}/playlists";

            var parameters = HttpUtility.ParseQueryString(String.Empty);

            if (limit != null)
            {
                parameters["limit"] = limit.Value.ToString();
            }

            if (offset != null)
            {
                parameters["offset"] = offset.Value.ToString();
            }

            if (!String.IsNullOrWhiteSpace(fields))
            {
                parameters["fields"] = fields;
            }

            pathAndQuery += $"?{parameters.ToString()}";

            return await this.GetFromApollo(pathAndQuery, ParseResponse< SpotifyPublicPlaylistsResponse>, cacheExpiration);
        }

        public async Task<List<SpotifyArtist>> GetAllArtistsAsync(IEnumerable<string> spotifyArtistIds)
        {
            return await this.GetAllArtistsAsync(spotifyArtistIds, NoCacheTime);
        }

        public async Task<List<SpotifyArtist>> GetAllArtistsAsync(IEnumerable<string> spotifyArtistIds, TimeSpan cacheExpiration)
        {
            var responses = await this.GetBatches(
                spotifyArtistIds.SplitOnBatches(MaxArtistBatchSize),
                async (batch, expiration) => await this.GetArtistsByIdsAsync(batch, expiration),
                cacheExpiration);

            return responses
                .Where(r => r.artists != null && r.artists.Any() && r.artists.First() != null)
                .SelectMany(r => r.artists)
                .ToList();
        }

        private async Task<ArtistResponse> GetArtistsByIdsAsync(IEnumerable<string> ids, TimeSpan cacheExpiration)
        {
            string pathAndQuery = $"vendor-api/spotify/v1/artists?";
            pathAndQuery += $"ids={String.Join(",", ids)}";

            return await this.GetFromApollo(pathAndQuery, ParseResponse< ArtistResponse>, cacheExpiration);
        }

        public async Task<SearchArtistResponse> SearchArtistsAsync(string artistName, string fields = null, int? limit = null, int? offset = null)
        {
            return await this.SearchArtistsAsync(artistName, NoCacheTime, fields, limit, offset);
        }

        public async Task<SearchArtistResponse> SearchArtistsAsync(string artistName, TimeSpan cacheExpiration, string fields = null, int? limit = null, int? offset = null)
        {
            var pathAndQuery = "vendor-api/spotify/v1/search";

            var parameters = HttpUtility.ParseQueryString(String.Empty);
            parameters["type"] = "artist";
            parameters["q"] = artistName;

            if (limit != null)
            {
                parameters["limit"] = limit.Value.ToString();
            }

            if (offset != null)
            {
                parameters["offset"] = offset.Value.ToString();
            }

            if (fields != null)
            {
                parameters["fields"] = fields;
            }

            pathAndQuery += $"?{parameters.ToString()}";

            return await this.GetFromApollo(pathAndQuery, ParseResponse<SearchArtistResponse>, cacheExpiration);
        }

        public async Task<IsSonyTrack[]> IsSonyTrack(IEnumerable<string> trackIds, string market)
        {
            return await this.IsSonyTrack(trackIds, market, NoCacheTime);
        }

        public async Task<IsSonyTrack[]> IsSonyTrack(IEnumerable<string> trackIds, string market, TimeSpan cacheExpiration)
        {
            var responses = await this.GetBatches(
                trackIds.SplitOnBatches(this.Settings.MaxSpotifyIdsInIsSonyRequest),
                async (batch, expiration) => await this.IsSonyTrackBatchAsync(batch, market, expiration),
                cacheExpiration);

            return responses.SelectMany(r => r).ToArray();
        }

        public async Task<GetTracksResponse> GetSpotifyTracks(IEnumerable<string> trackIds, string market)
        {
            return await this.GetSpotifyTracks(trackIds, market, NoCacheTime);
        }

        public async Task<GetTracksResponse> GetSpotifyTracks(IEnumerable<string> trackIds, string market, TimeSpan cacheExpiration)
        {
            var responses = await this.GetBatches(
                trackIds.SplitOnBatches(this.Settings.MaxSpotifyIdsInGetTracksRequest),
                async (batch, expiration) => await this.GetTracksBatchAsync(batch, market, expiration),
                cacheExpiration);

            var response = new GetTracksResponse() { tracks = responses.SelectMany(r => r.tracks).ToArray() };

            foreach (var r in responses)
            {
                foreach (var requestToHeader in r.RequestHeaders)
                {
                    response.AddHeaders(requestToHeader.Key, requestToHeader.Value);
                }
            }

            return response;
        }

        public async Task<SpotifyPlaylist> GetSpotifyPlaylistByIdAsync(string playlistId, string fields = null)
        {
            return await this.GetSpotifyPlaylistByIdAsync(playlistId, NoCacheTime, fields);
        }

        public async Task<SpotifyPlaylist> GetSpotifyPlaylistByIdAsync(string playlistId, TimeSpan cacheExpiration, string fields = null)
        {
            string pathAndQuery = $"vendor-api/spotify/v1/playlists/{playlistId}";
            if (fields != null)
            {
                var parameters = HttpUtility.ParseQueryString(String.Empty);
                parameters["fields"] = fields;

                pathAndQuery += $"?{parameters.ToString()}";
            }

            return await this.GetFromApollo(
                pathAndQuery,
                ParseResponse< SpotifyPlaylist>,
                cacheExpiration);
        }

        private static bool DoNotSkipTracksLoad(SpotifyPlaylist r) { return false; }

        public async Task<SpotifyPlaylist> GetPlaylistByIdWithAllTracksAsync(string playlistId, string playlistFields = null, string market = null)
        {
            return await this.GetPlaylistByIdWithAllTracksAsync(playlistId, NoCacheTime, playlistFields, market);
        }

        public async Task<SpotifyPlaylist> GetPlaylistByIdWithAllTracksAsync(string playlistId, TimeSpan cacheExpiration, string playlistFields = null, string market = null)
        {
            return await this.GetPlaylistByIdWithAllTracksWithFilterAsync(playlistId,
                playlistFields,
                market,
                cacheExpiration,
                DoNotSkipTracksLoad);
        }

        public async Task<SpotifyPlaylist> GetPlaylistByIdWithAllTracksHavingSnapshotIdAsync(string playlistId, string snapshotId, string playlistFields = null, string market = null)
        {
            return await this.GetPlaylistByIdWithAllTracksHavingSnapshotIdAsync(playlistId, snapshotId, NoCacheTime, playlistFields, market);
        }

        public async Task<SpotifyPlaylist> GetPlaylistByIdWithAllTracksHavingSnapshotIdAsync(string playlistId, string snapshotId, TimeSpan cacheExpiration, string playlistFields = null, string market = null)
        {
            var response =  await this.GetPlaylistByIdWithAllTracksWithFilterAsync(playlistId,
                playlistFields,
                market,
                cacheExpiration,
                p => !String.IsNullOrWhiteSpace(p.snapshot_id) && p.snapshot_id.Equals(snapshotId));

            if (response != null)
            {
                response.HasSnapshotIdChanged = !String.Equals(response.snapshot_id, snapshotId);
            }

            return response;
        }

        private async Task<SpotifyPlaylist> GetPlaylistByIdWithAllTracksWithFilterAsync(string playlistId, string playlistFields, string market, TimeSpan cacheExpiration, Func<SpotifyPlaylist, bool> shouldSkipLoadingTracksForPlaylist)
        {
            SpotifyPlaylist playlist = await this.GetSpotifyPlaylistByIdAsync(playlistId, cacheExpiration, playlistFields);

            if (playlist == null) { return null; }

            if (shouldSkipLoadingTracksForPlaylist(playlist))
            {
                return playlist;
            }

            //Spotify returns first SpotifyMaxTracksPerRequest tracks, if present
            if (playlist.Tracks.total <= SpotifyMaxTracksPerRequest) { return playlist; }

            var responses = await this.GetBatchResponses<SpotifyPlaylistTracks>(
                playlist.Tracks.total.Batch(SpotifyMaxTracksPerRequest).Skip(1).ToArray(),
                async (batch, expiration) => new SpotifyPlaylistTracks[] {
                    await GetPlaylistTracksByIdAsync(playlistId, expiration, limit: batch.Limit, offset: batch.Offset, market: market)
                },
                cacheExpiration);

            foreach (var response in responses)
            {
                foreach (var requestToHeader in response.RequestHeaders)
                {
                    playlist.AddHeaders(requestToHeader.Key, requestToHeader.Value);
                }
                
                playlist.AddRawResponseToModel(response.RawResponse.Key, response.RawResponse.Value);
            }

            playlist.Tracks.items.AddRange(responses.SelectMany(r => r.items));
            playlist.Tracks.offset = 0;
            playlist.Tracks.limit = playlist.Tracks.items.Count();

            return playlist;
        }

        public async Task<SpotifyPlaylistTrackItem[]> GetAllPlaylistTracksByIdAsync(string playlistId, string fields = null, string market = null)
        {
            return await this.GetAllPlaylistTracksByIdAsync(playlistId, NoCacheTime, fields, market);
        }

        public async Task<SpotifyPlaylistTrackItem[]> GetAllPlaylistTracksByIdAsync(string playlistId, TimeSpan cacheExpiration, string fields = null, string market = null)
        {
            var playlist = await this.GetPlaylistByIdWithAllTracksAsync(playlistId, cacheExpiration, fields, market);

            return playlist == null ? new SpotifyPlaylistTrackItem[0] : playlist.Tracks.items.ToArray();
        }

        private async Task<SpotifyPlaylistTracks> GetPlaylistTracksByIdAsync(string playlistId, TimeSpan cacheExpiration, string fields = null, string market = null, Nullable<int> offset = null, Nullable<int> limit = null)
        {
            var path = $"vendor-api/spotify/v1/playlists/{playlistId}/tracks";
            var parameters = HttpUtility.ParseQueryString(string.Empty);

            if (fields != null) { parameters["fields"] = fields; }
            if (limit.HasValue) { parameters["limit"] = limit.Value.ToString(); }
            if (offset.HasValue) { parameters["offset"] = offset.Value.ToString(); }
            if (market != null) { parameters["market"] = market; }

            string finalUrl = $"{path}?{parameters.ToString()}";

            return await GetFromApollo(finalUrl, ParseResponse< SpotifyPlaylistTracks>, cacheExpiration);
        }

        public async Task<SpotifyAlbum[]> GetAllAlbumInfoAsync(IEnumerable<string> ids, string market = null, string fields = null)
        {
            return await this.GetAllAlbumInfoAsync(ids, NoCacheTime, market, fields);
        }

        public async Task<SpotifyAlbum[]> GetAllAlbumInfoAsync(IEnumerable<string> ids, TimeSpan cacheExpiration, string market = null, string fields = null)
        {
            var responses = await this.GetBatches(
                ids.SplitOnBatches(this.Settings.MaxAlbumIdsInRequest),
                async (batch, expiration) => await this.GetAlbumInfoBatchAsync(batch, expiration, market),
                cacheExpiration);

            return responses.SelectMany(r => r).ToArray();
        }

        public async Task<SpotifyTrackAudioFeature[]> GetAllAudioFeatureForTracksAsync(IEnumerable<string> trackIds)
        {
            return await this.GetAllAudioFeatureForTracksAsync(trackIds, NoCacheTime);
        }

        public async Task<SpotifyTrackAudioFeature[]> GetAllAudioFeatureForTracksAsync(IEnumerable<string> trackIds, TimeSpan cacheExpiration)
        {
            var responses = await this.GetBatches(
                trackIds.SplitOnBatches(100),
                async (batch, expiration) => await this.GetAudioFeatureForTracksAsync(batch, expiration),
                cacheExpiration);

            return responses.SelectMany(r => r).ToArray();
        }

        private async Task<IEnumerable<SpotifyTrackAudioFeature>> GetAudioFeatureForTracksAsync(IEnumerable<string> ids, TimeSpan cacheExpiration)
        {
            string url = $"/vendor-api/spotify/v1/audio-features?{string.Join("&", ids.Select(id => $"ids={id}"))}";

            return await this.GetFromApollo(
                url,
                this.ParseAudioFeatures,
                cacheExpiration);
        }

        private async Task<IEnumerable<SpotifyAlbum>> GetAlbumInfoBatchAsync(IEnumerable<string> ids, TimeSpan cacheExpiration, string market = null)
        {
            string url = $"/vendor-api/spotify/v1/albums?{string.Join("&", ids.Select(id => $"ids={id}"))}";
            if (!String.IsNullOrWhiteSpace(market))
            {
                url += $"&market={market}";
            }

            return await this.GetFromApollo(
                url,
                this.ParseSpotifyAlbums,
                cacheExpiration);
        }

        private async Task<GetTracksResponse> GetTracksBatchAsync(IEnumerable<string> trackIds, string market, TimeSpan cacheExpiration)
        {
            string queryString = $"ids={string.Join(",", trackIds)}";
            if (!String.IsNullOrWhiteSpace(market))
            {
                queryString += $"&market={market}";
            }

            return await this.GetFromApollo(
                $"/vendor-api/spotify/v1/tracks?{queryString}",
                ParseResponse< GetTracksResponse>,
                cacheExpiration);
        }

        private async Task<IEnumerable<IsSonyTrack>> IsSonyTrackBatchAsync(IEnumerable<string> trackIds, string market, TimeSpan cacheExpiration)
        {
            return await this.GetFromApollo(
                $"/apollo-api/is-sony/?{string.Join("&", trackIds.Select(id => $"spotify_ids={id}"))}&market={TreatNullAsGlobal(market)}",
                this.ParseIsSonyTrackJson,
                cacheExpiration);
        }

        private IEnumerable<IsSonyTrack> ParseIsSonyTrackJson(string responseString)
        {
            JObject jObject = null;
            try
            {
                jObject = JObject.Parse(responseString);
            }
            catch (JsonReaderException ex)
            {
                throw new ApolloWebAPIException($"Could not parse 'is-sony' response. Response: '{responseString}'", ex);
            }

            return jObject
                .Children()
                .OfType<JProperty>()
                .Select(p => new IsSonyTrack(p.Name, Boolean.Parse(p.Value.ToString())))
                .ToArray();
        }


        private IEnumerable<SpotifyAlbum> ParseSpotifyAlbums(string responseString)
        {
            try
            {
                var parsed = JsonConvert.DeserializeObject<GetAlbumsResponse>(responseString);

                return parsed == null ? Enumerable.Empty<SpotifyAlbum>() : parsed.albums;
            }
            catch (Exception ex)
            {
                throw new ApolloWebAPIException($"Could not parse 'get albums by ids' response. Response: '{responseString}'");
            }
        }

        private IEnumerable<SpotifyTrackAudioFeature> ParseAudioFeatures(string responseString)
        {
            try
            {
                var parsed = JsonConvert.DeserializeObject<AudioFeatureResponse>(responseString);

                return parsed == null ? Enumerable.Empty<SpotifyTrackAudioFeature>() : parsed.audio_features;
            }
            catch (Exception ex)
            {
                throw new ApolloWebAPIException($"Could not parse 'get audio features by ids' response. Response: '{responseString}'");
            }
        }

        private static string TreatNullAsGlobal(string market)
        {
            return market == null ? "global" : market;
        }

        private async Task<TResponse[]> GetBatches<TInput, TResponse>(IEnumerable<TInput> input, Func<TInput, TimeSpan, Task<TResponse>> spotifyFunc, TimeSpan cacheExpiration)
        {
            var tasks = input.Select(async i => await spotifyFunc(i, cacheExpiration)).ToList();

            await tasks.EnsureAllSuccessAsync();

            return tasks.Select(t => t.Result).ToArray();
        }
    }

    public class GetTracksResponse : HeaderTracker
    {
        public SpotifyTrack[] tracks { get; set; }
    }

    class GetAlbumsResponse
    {
        public SpotifyAlbum[] albums { get; set; }
    }

    class AudioFeatureResponse
    {
        public List<SpotifyTrackAudioFeature> audio_features { get; set; }
    }

    public class BatchResponse<TResponse>
    {
        public readonly TResponse[] Items;
        public readonly Batch Batch;
        public readonly Exception Exception;

        public bool Success { get { return this.Exception == null; } }

        private BatchResponse(IEnumerable<TResponse> items, Batch batch, Exception ex)
        {
            this.Items = items.ToArray();
            this.Exception = ex;
            this.Batch = batch;
        }

        public static BatchResponse<TResponse> CreateSuccess(IEnumerable<TResponse> items, Batch batch)
        {
            return new BatchResponse<TResponse>(items, batch, null);
        }

        public static BatchResponse<TResponse> CreateError(Exception ex, Batch batch)
        {
            return new BatchResponse<TResponse>(new TResponse[0], batch, ex);
        }
    }
}