/*private string ValidateTemperatures(double? temperature)
        {
            if (temperature.HasValue && temperature >= MIN_TEMP && temperature <= MAX_TEMP)
            {
                return $"Temperatura só pode ser entre {MIN_TEMP} e {MAX_TEMP}";
            }
            return "";
        }

        private string ValidateHumidity(double? humidity)
        {
            if (humidity.HasValue && humidity >= MIN_HUMIDITY && humidity <= MAX_HUMIDITY)
            {
                return $"Umidade só pode ser entre {MIN_HUMIDITY} e {MAX_HUMIDITY}";
            }
            return "";
        }*/

        public async Task<BaseUpdateModel<TemperatureReadingDto>> Save(TemperatureReadingDto dto)
        {
            if(dto.Date==DateTime.MinValue)
                throw new InvalidOperationException("Precisa fornecer a data");
/*
            var temperatureErrors = ValidateTemperatures(dto.Temperature1);

            if (dto.Temperature1 < MIN_TEMP || dto.Temperature1 > MAX_TEMP)
                temperatureErrors = $"Temperatura só pode ser entre {MIN_TEMP} e {MAX_TEMP}";*/

            //if(temperatureErrors.IsNullOrEmpty()&& dto.Temperature2.HasValue && dto.Temperature2<)

            var entity = dto.Id.IsNullOrEmpty()
                ? new TemperatureReading()
                : await Session.LoadAsync<TemperatureReading>(dto.Id);

            SetUpdateText(dto);

            Mapper.Map(dto, entity);
            UpdateAuditInfo(entity);

            await Session.StoreAsync(entity);
            await Session.SaveChangesAsync();

            dto.Id = entity.Id;

            return new BaseUpdateModel<TemperatureReadingDto>(dto, $"{UpdateText} leitura de temperatura e umidade", true);
        }
        public async Task Save_should_save_a_temperature_reading()
        {
            using (var store = NewDocumentStore())
            {
                using (var session = store.OpenAsyncSession())
                {
                    // Arrange
                    var readingDate = new DateTime(2015, 4, 1, 15, 0, 0);

                    var dto = new TemperatureReadingDto
                    {
                        Id = null,
                        Date = readingDate,
                        Temperature1 = 29.5,
                        Humidity1 = 76.2,
                        Temperature2 = 33.0,
                        Humidity2 = 65.0,
                        Location = TemperatureReadingLocation.Location1
                    };

                    // Act
                    var service = GetTemperatureReadingService(session);

                    var model = await service.Save(dto);

                    // Assert
                    model.Success.Should().BeTrue();
                    model.Message.Should().Be("Criou leitura de temperatura e umidade");

                    var actual = await session.LoadAsync<TemperatureReading>(model.Entity.Id);
                    actual.Date.Should().Be(readingDate);
                    actual.Temperature1.Should().Be(29.5);
                    actual.Humidity1.Should().Be(76.2);
                    actual.Temperature2.Should().Be(33.0);
                    actual.Humidity2.Should().Be(65.0);
                    actual.Location.Should().Be(TemperatureReadingLocation.Location1);
                    actual.AuditInfo.Username.Should().NotBeNull();
                    actual.AuditInfo.Updated.Should().BeCloseTo(DateTime.Now, 2000);
                }
            }
        }
        public void Save_should_throw_exception_if_date_is_min_value()
        {
            using (var store = NewDocumentStore())
            {
                using (var session = store.OpenAsyncSession())
                {
                    // Arrange
                    var dto = new TemperatureReadingDto
                    {
                        Id = null,
                        Date = DateTime.MinValue
                    };

                    var service = GetTemperatureReadingService(session);

                    // Act
                    Func<Task> act = async () => await service.Save(dto);

                    // Assert
                    act.ShouldThrow<InvalidOperationException>().WithMessage("Precisa fornecer a data");
                }
            }
        }
        public async Task GetById_should_retrieve_a_temperature_reading()
        {
            var readingDate = new DateTime(2015, 4, 1, 15, 0, 0);

            using (var store = NewDocumentStore())
            {
                // Arrange
                using (var session = store.OpenAsyncSession())
                {
                    var dto = new TemperatureReadingDto
                    {
                        Id = null,
                        Date = readingDate,
                        Temperature1 = 29.5,
                        Humidity1 = 76.2,
                        Temperature2 = 33.0,
                        Humidity2 = 65.0,
                        Location = TemperatureReadingLocation.Location1
                    };

                    // Act
                    var service = GetTemperatureReadingService(session);

                    await service.Save(dto);
                }

                // Assert
                using (var session = store.OpenAsyncSession())
                {
                    var service = GetTemperatureReadingService(session);

                    var actual = await service.GetById("TemperatureReadings-1");
                    actual.IdDisplay.Should().Be("00001");
                    actual.Date.Should().Be(readingDate);
                    actual.Temperature1.Should().Be(29.5);
                    actual.Humidity1.Should().Be(76.2);
                    actual.Temperature2.Should().Be(33.0);
                    actual.Humidity2.Should().Be(65.0);
                    actual.Location.Should().Be(TemperatureReadingLocation.Location1);
                }
            }
        }
        public async Task<TemperatureReadingDto> GetById(string id)
        {
            var entity = await Session.LoadAsync<TemperatureReading>(id);

            if(entity == null)
                throw new NotFoundException($"Leitura com Id {id.FromRavenId()} não existe!");

            var dto = new TemperatureReadingDto
            {
                Id = entity.Id,
                Date = entity.Date,
                Location = entity.Location,
                Humidity1 = entity.Humidity1,
                Temperature1 = entity.Temperature1,
                Humidity2 = entity.Humidity2,
                Temperature2 = entity.Temperature2
            };

            return dto;
        }