using Newtonsoft.Json;
using NUnit.Framework;
using Rhino.Mocks;
using System.Threading.Tasks;
using TINK.Model.Connector;
using TINK.Model.Services.CopriApi;
using TINK.Repository;
using TINK.Repository.Response;
using TINK.Services.CopriApi;

namespace TestTINKLib.Fixtures.ObjectTests.Connector.Query
{
    [TestFixture]
    public class TestCachedQuery
    {
        private const string BIKESAVAILABLE = @"{
              ""copri_version"" : ""4.1.0.0"",
              ""bikes"" : {},
              ""response_state"" : ""OK"",
              ""apiserver"" : ""https://app.tink-konstanz.de"",
              ""authcookie"" : """",
              ""response"" : ""bikes_available"",
              ""bikes"" : {
                                ""2352"" : {
                                ""description"" : ""Cargo Long"",
                                ""state"" : ""available"",
                                ""bike"" : ""1"",
                                ""gps"" : { ""latitude"": ""47.669888"", ""longitude"": ""9.167749"" },
                                ""station"" : ""9""
                                }
            }
        }";

        private const string STATIONSALL = @"{
              ""copri_version"" : ""4.1.0.0"",
              ""stations"" : {
                 ""5"" : {
                    ""station"" : ""5"",
                    ""bike_soll"" : ""0"",
                    ""bike_ist"" : ""7"",
                    ""station_group"" : [ ""TINK"" ],
                    ""gps"" : { ""latitude"": ""47.66756"", ""longitude"": ""9.16477"" },
                    ""state"" : ""available"",
                    ""description"" : """"
                 },
                 ""13"" : {
                    ""station"" : ""13"",
                    ""bike_soll"" : ""4"",
                    ""bike_ist"" : ""1"",
                    ""station_group"" : [ ""TINK"" ],
                    ""gps"" : { ""latitude"": ""47.657756"", ""longitude"": ""9.176084"" },
                    ""state"" : ""available"",
                    ""description"" : """"
                 },
                 ""30"" : {
                    ""station"" : ""30"",
                    ""bike_soll"" : ""5"",
                    ""bike_ist"" : ""0"",
                    ""station_group"" : [ ""TINK"", ""Konrad"" ],
                    ""gps"" : { ""latitude"": ""47.657766"", ""longitude"": ""9.176094"" },
                    ""state"" : ""available"",
                    ""description"" : ""Test für Stadtradstation""
                 }
        },
              ""user_group"" : [ ""Konrad"", ""TINK"" ],
              ""response_state"" : ""OK"",
              ""authcookie"" : ""6103_f782a208d9399291ba8d086b5dcc2509_12345678"",
              ""debuglevel"" : ""2"",
              ""response"" : ""stations_all"",
              ""user_id"" : ""javaminister@gmail.com"",
              ""apiserver"" : ""https://tinkwwp.copri-bike.de""
        }";

        private const string STATIONSALLEMPTY = @"{
              ""copri_version"" : ""4.1.0.0"",
              ""stations"" : {
        },
              ""user_group"" : [ ""Konrad"", ""TINK"" ],
              ""response_state"" : ""OK"",
              ""authcookie"" : ""6103_f782a208d9399291ba8d086b5dcc2509_12345678"",
              ""debuglevel"" : ""2"",
              ""response"" : ""stations_all"",
              ""user_id"" : ""javaminister@gmail.com"",
              ""apiserver"" : ""https://tinkwwp.copri-bike.de""
        }";

        [Test]
        public async Task TestGetStations_StationsFromCache()
        {
            var server = MockRepository.GenerateMock<ICachedCopriServer>();

            server.Stub(x => x.GetStations(Arg<bool>.Matches(fromCache => fromCache == false))).Return(Task.Run(() => new Result<StationsAvailableResponse>(
                typeof(CopriCallsMonkeyStore),
                JsonConvert.DeserializeObject<StationsAvailableResponse>(STATIONSALL),
                new GeneralData(),
                new System.Exception("Bang when getting stations..."))));

            server.Stub(x => x.GetBikesAvailable(Arg<bool>.Matches(fromCache => fromCache == true))).Return(Task.Run(() => new Result<BikesAvailableResponse>(
                typeof(CopriCallsMonkeyStore),
                JsonConvert.DeserializeObject<BikesAvailableResponse>(BIKESAVAILABLE),
                new GeneralData())));

            var result = await new CachedQuery(server).GetBikesAndStationsAsync();

            Assert.AreEqual(3, result.Response.StationsAll.Count);
            Assert.AreEqual(1, result.Response.Bikes.Count);
            Assert.AreEqual(typeof(CopriCallsMonkeyStore), result.Source);
            Assert.AreEqual("Bang when getting stations...", result.Exception.Message);
        }

        [Test]
        public async Task TestGetStations_BikesAvailableFromCache()
        {
            var server = MockRepository.GenerateMock<ICachedCopriServer>();

            server.Stub(x => x.GetStations(Arg<bool>.Matches(fromCache => fromCache == false))).Return(Task.Run(() => new Result<StationsAvailableResponse>(
                typeof(CopriCallsHttps),
                JsonConvert.DeserializeObject<StationsAvailableResponse>(STATIONSALLEMPTY),
                new GeneralData())));

            server.Stub(x => x.GetBikesAvailable(Arg<bool>.Matches(fromCache => fromCache == false))).Return(Task.Run(() => new Result<BikesAvailableResponse>(
                typeof(CopriCallsMonkeyStore),
                JsonConvert.DeserializeObject<BikesAvailableResponse>(BIKESAVAILABLE),
                new GeneralData(),
                new System.Exception("Bang when getting bikes..."))));

            server.Stub(x => x.GetStations(Arg<bool>.Matches(fromCache => fromCache == true))).Return(Task.Run(() => new Result<StationsAvailableResponse>(
                typeof(CopriCallsMonkeyStore),
                JsonConvert.DeserializeObject<StationsAvailableResponse>(STATIONSALL),
                new GeneralData())));

            var result = await new CachedQuery(server).GetBikesAndStationsAsync();

            Assert.AreEqual(3, result.Response.StationsAll.Count);
            Assert.AreEqual(1, result.Response.Bikes.Count);
            Assert.AreEqual(typeof(CopriCallsMonkeyStore), result.Source);
            Assert.AreEqual("Bang when getting bikes...", result.Exception.Message);
        }


        [Test]
        public async Task TestGetStations()
        {
            var server = MockRepository.GenerateMock<ICachedCopriServer>();

            server.Stub(x => x.GetStations(Arg<bool>.Matches(fromCache => fromCache == false))).Return(Task.Run(() => new Result<StationsAvailableResponse>(
                typeof(CopriCallsHttps),
                JsonConvert.DeserializeObject<StationsAvailableResponse>(STATIONSALL),
                new GeneralData())));

            server.Stub(x => x.GetBikesAvailable(Arg<bool>.Matches(fromCache => fromCache == false))).Return(Task.Run(() => new Result<BikesAvailableResponse>(
                typeof(CopriCallsHttps),
                JsonConvert.DeserializeObject<BikesAvailableResponse>(BIKESAVAILABLE),
                new GeneralData())));

            server.Stub(x => x.AddToCache(Arg<Result<StationsAvailableResponse>>.Is.Anything));
            server.Stub(x => x.AddToCache(Arg<Result<BikesAvailableResponse>>.Is.Anything));

            var result = await new CachedQuery(server).GetBikesAndStationsAsync();

            Assert.AreEqual(3, result.Response.StationsAll.Count);
            Assert.AreEqual(1, result.Response.Bikes.Count);
            Assert.AreEqual(typeof(CopriCallsHttps), result.Source);
            Assert.IsNull(result.Exception);
        }

        [Test]
        public async Task TestGetBikes()
        {
            var server = MockRepository.GenerateMock<ICachedCopriServer>();

            server.Stub(x => x.GetBikesAvailable()).Return(Task.Run(() => new Result<BikesAvailableResponse>(
                typeof(CopriCallsHttps), 
                JsonConvert.DeserializeObject<BikesAvailableResponse>(BIKESAVAILABLE),
                new GeneralData())));

            server.Stub(x => x.AddToCache(Arg<Result<BikesAvailableResponse>>.Is.Anything));

            var result = await new CachedQuery(server).GetBikesAsync();

            Assert.AreEqual(1, result.Response.Count);
            Assert.AreEqual(typeof(CopriCallsHttps), result.Source);
            Assert.IsNull(result.Exception);
        }

        [Test]
        public async Task TestGetBikesOccupied()
        {
            var server = MockRepository.GenerateMock<ICachedCopriServer>();

            var result = await new CachedQuery(server).GetBikesOccupiedAsync();

            Assert.AreEqual(0, result.Response.Count);
            Assert.AreEqual(typeof(CopriCallsMonkeyStore), result.Source);
            Assert.AreEqual(result.Exception.Message, "Abfrage der reservierten/ gebuchten Räder nicht möglich. Kein Benutzer angemeldet.");
        }
    }
}