diff --git a/base/base.pro b/base/base.pro
index 2a51dde35b..14becbf3a3 100644
--- a/base/base.pro
+++ b/base/base.pro
@@ -21,6 +21,7 @@ SOURCES += \
     string_format.cpp \
     string_utils.cpp \
     strings_bundle.cpp \
+    sunrise_sunset.cpp \
     thread.cpp \
     thread_checker.cpp \
     thread_pool.cpp \
@@ -63,6 +64,7 @@ HEADERS += \
     string_format.hpp \
     string_utils.hpp \
     strings_bundle.hpp \
+    sunrise_sunset.hpp \
     swap.hpp \
     thread.hpp \
     thread_checker.hpp \
diff --git a/base/base_tests/base_tests.pro b/base/base_tests/base_tests.pro
index b21cfe7d65..3635c684d4 100644
--- a/base/base_tests/base_tests.pro
+++ b/base/base_tests/base_tests.pro
@@ -30,6 +30,7 @@ SOURCES += \
   stl_add_test.cpp \
   string_format_test.cpp \
   string_utils_test.cpp \
+  sunrise_sunset_test.cpp \
   thread_pool_tests.cpp \
   threaded_list_test.cpp \
   threads_test.cpp \
diff --git a/base/base_tests/sunrise_sunset_test.cpp b/base/base_tests/sunrise_sunset_test.cpp
new file mode 100644
index 0000000000..241f7835be
--- /dev/null
+++ b/base/base_tests/sunrise_sunset_test.cpp
@@ -0,0 +1,488 @@
+#include "testing/testing.hpp"
+
+#include "base/sunrise_sunset.hpp"
+
+#include "base/timegm.hpp"
+
+// Test site for sunrise and sunset is
+// http://voshod-solnca.ru/
+
+UNIT_TEST(SunriseSunsetAlgorithm_Moscow_April)
+{
+  // Moscow (utc +3), date 2015/4/12:
+  // Sunrise utc time: 2015/4/12,2:34
+  // Sunset utc time: 2015/4/12,16:29
+  double const lat = 55.7522222;
+  double const lon = 37.6155556;
+
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 4, 12, 2, 10, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 4, 12, 2, 45, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 4, 12, 16, 15, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 4, 12, 16, 45, 0), lat, lon), ());
+}
+
+UNIT_TEST(SunriseSunsetAlgorithm_Moscow_July)
+{
+  // Moscow (utc +3), date 2015/7/13:
+  // Sunrise utc time: 2015/7/13,1:04
+  // Sunset utc time: 2015/7/13,18:09
+  double const lat = 55.7522222;
+  double const lon = 37.6155556;
+
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 7, 13, 0, 50, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 7, 13, 1, 45, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 7, 13, 18, 0, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 7, 13, 18, 30, 0), lat, lon), ());
+}
+
+UNIT_TEST(SunriseSunsetAlgorithm_Moscow_September)
+{
+  // Moscow (utc +3), date 2015/9/17:
+  // Sunrise utc time: 2015/9/17,3:05
+  // Sunset utc time: 2015/9/17,15:46
+  double const lat = 55.7522222;
+  double const lon = 37.6155556;
+
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 9, 17, 2, 55, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 9, 17, 3, 15, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 9, 17, 15, 0, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 9, 17, 16, 0, 0), lat, lon), ());
+}
+
+UNIT_TEST(SunriseSunsetAlgorithm_Moscow_December)
+{
+  // Moscow (utc +3), date 2015/12/25:
+  // Sunrise utc time: 2015/12/25,06:00
+  // Sunset utc time: 2015/12/25,13:01
+  double const lat = 55.7522222;
+  double const lon = 37.6155556;
+
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 12, 25, 5, 55, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 12, 25, 6, 10, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 12, 25, 12, 55, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 12, 25, 13, 10, 0), lat, lon), ());
+}
+
+UNIT_TEST(SunriseSunsetAlgorithm_Moscow_NewYear)
+{
+  // Moscow (utc +3), date 2016/1/1:
+  // Sunrise utc time: 2016/1/1,6:1
+  // Sunset utc time: 2016/1/1,13:7
+  double const lat = 55.7522222;
+  double const lon = 37.6155556;
+
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2016, 1, 1, 5, 55, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2016, 1, 1, 6, 10, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2016, 1, 1, 13, 0, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2016, 1, 1, 13, 15, 0), lat, lon), ());
+}
+
+UNIT_TEST(SunriseSunsetAlgorithm_Paris_NewYear)
+{
+  // Paris (utc +1)
+  // Sunrise utc time: 2016/1/1,7:45
+  // Sunset utc time: 2016/1/1,16:04
+  double const lat = 48.875649;
+  double const lon = 2.344428;
+
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2016, 1, 1, 7, 35, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2016, 1, 1, 7, 55, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2016, 1, 1, 16, 0, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2016, 1, 1, 16, 10, 0), lat, lon), ());
+}
+
+UNIT_TEST(SunriseSunsetAlgorithm_Honolulu_February)
+{
+  // Honolulu (utc -10), date 2015/2/12:
+  // Sunrise utc time: 2015/2/12,17:05
+  // Sunset utc time: 2015/2/13,4:29
+  double const lat = 21.307431;
+  double const lon = -157.848568;
+
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 2, 12, 17, 0, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 2, 12, 17, 15, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 2, 13, 4, 10, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 2, 13, 4, 35, 0), lat, lon), ());
+}
+
+UNIT_TEST(SunriseSunsetAlgorithm_Honolulu_July)
+{
+  // Honolulu (utc -10). For date 2015/7/13:
+  // Sunrise utc time: 2015/7/13,15:58
+  // Sunset utc time: 2015/7/14,5:18
+  double const lat = 21.307431;
+  double const lon = -157.848568;
+
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 7, 13, 15, 40, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 7, 13, 16, 10, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 7, 14, 5, 5, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 7, 14, 5, 25, 0), lat, lon), ());
+}
+
+UNIT_TEST(SunriseSunsetAlgorithm_Honolulu_June)
+{
+  // Honolulu (utc -10). For date 2015/6/22:
+  // Sunrise utc time: 2015/6/22,15:51
+  // Sunset utc time: 2015/6/23,5:17
+  double const lat = 21.307431;
+  double const lon = -157.848568;
+
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 6, 22, 15, 40, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 6, 22, 16, 0, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 6, 23, 5, 5, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 6, 23, 5, 25, 0), lat, lon), ());
+}
+
+UNIT_TEST(SunriseSunsetAlgorithm_Honolulu_December)
+{
+  // Honolulu (utc -10). For date 2015/12/23:
+  // Sunrise utc time: 2015/12/23,17:06
+  // Sunset utc time: 2015/12/24,3:56
+  double const lat = 21.307431;
+  double const lon = -157.848568;
+
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 12, 23, 16, 40, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 12, 23, 17, 10, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 12, 23, 3, 50, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 12, 23, 4, 5, 0), lat, lon), ());
+}
+
+UNIT_TEST(SunriseSunsetAlgorithm_Melbourne_Ferbuary)
+{
+  // Melbourne (utc +11). For date 2015/2/12:
+  // Sunrise utc time: 2015/2/11,19:46
+  // Sunset utc time: 2015/2/12,9:24
+  double const lat = -37.829188;
+  double const lon = 144.957976;
+
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 2, 11, 19, 30, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 2, 11, 19, 50, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 2, 12, 9, 15, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 2, 12, 9, 30, 0), lat, lon), ());
+}
+
+UNIT_TEST(SunriseSunsetAlgorithm_Melbourne_NewYear)
+{
+  // Melbourne (utc +11). For date 2016/1/1:
+  // Sunrise utc time: 2015/12/31,19:02
+  // Sunset utc time: 2016/1/1,9:46
+  double const lat = -37.829188;
+  double const lon = 144.957976;
+
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 12, 31, 18, 55, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 12, 31, 19, 5, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2016, 1, 1, 9, 40, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2016, 1, 1, 9, 55, 0), lat, lon), ());
+}
+
+UNIT_TEST(SunriseSunsetAlgorithm_GetDayTime_Melbourne_August)
+{
+  // Melbourne (utc +11), 2015/8/12
+  // prev sunset utc 2015/8/11,7:41
+  // sunrise utc 2015/8/11,21:10
+  // sunset utc 2015/8/12,7:42
+  // next sunrise utc 2015/8/12,21:09
+  double const lat = -37.829188;
+  double const lon = 144.957976;
+
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 8, 11, 7, 30, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 8, 11, 7, 50, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 8, 11, 21, 0, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 8, 11, 21, 20, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 8, 12, 7, 35, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 8, 12, 7, 55, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 8, 12, 21, 0, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 8, 12, 21, 15, 0), lat, lon), ());
+}
+
+UNIT_TEST(SunriseSunsetAlgorithm_Wellington_October)
+{
+  // Melbourne (utc +13). For date 2015/10/20:
+  // Sunrise utc time: 2015/10/19,17:26
+  // Sunset utc time: 2015/10/20,6:47
+  double const lat = -41.287481;
+  double const lon = 174.774189;
+
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 10, 19, 17, 15, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 10, 19, 17, 35, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 10, 20, 6, 40, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 10, 20, 6, 55, 0), lat, lon), ());
+}
+
+UNIT_TEST(SunriseSunsetAlgorithm_BuenosAires_March)
+{
+  // Buenos Aires (utc -3). For date 2015/3/8:
+  // Sunrise utc time: 2015/3/8,9:48
+  // Sunset utc time: 2015/3/8,22:23
+  double const lat = -34.607639;
+  double const lon = -58.438095;
+
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 3, 8, 9, 40, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 3, 8, 10, 5, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 3, 8, 22, 20, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 3, 8, 22, 28, 0), lat, lon), ());
+}
+
+UNIT_TEST(SunriseSunsetAlgorithm_Seattle_May)
+{
+  // Seattle (utc -8). For date 2015/5/9:
+  // Sunrise utc time: 2015/5/9,12:41
+  // Sunset utc time: 2015/5/10,3:32
+  double const lat = 47.597482;
+  double const lon = -122.334590;
+
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 5, 9, 12, 35, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 5, 9, 12, 45, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 5, 10, 3, 20, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 5, 10, 3, 40, 0), lat, lon), ());
+}
+
+UNIT_TEST(SunriseSunsetAlgorithm_Reykjavik_May)
+{
+  // Reykjavik (utc 0). For date 2015/5/9:
+  // Sunrise utc time: 2015/5/9,4:34
+  // Sunset utc time: 2015/5/9,22:15
+  double const lat = 64.120467;
+  double const lon = -21.809448;
+
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 5, 9, 4, 30, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 5, 9, 4, 40, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 5, 9, 22, 10, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 5, 9, 22, 20, 0), lat, lon), ());
+}
+
+UNIT_TEST(SunriseSunsetAlgorithm_Reykjavik_June)
+{
+  // Reykjavik (utc 0). For date 2015/6/22:
+  // Sunrise utc time: 2015/6/22,2:56
+  // Sunset utc time: 2015/6/23,0:04
+  double const lat = 64.120467;
+  double const lon = -21.809448;
+
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 6, 22, 2, 45, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 6, 22, 3, 5, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 6, 23, 0, 0, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 6, 23, 0, 7, 0), lat, lon), ());
+}
+
+UNIT_TEST(SunriseSunsetAlgorithm_CapeTown_November)
+{
+  // Cape Town (utc +2). For date 2015/11/11:
+  // Sunrise utc time: 2015/11/11,3:38
+  // Sunset utc time: 2015/11/11,17:24
+  double const lat = -33.929573;
+  double const lon = 18.428439;
+
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 11, 11, 3, 30, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 11, 11, 3, 45, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 11, 11, 17, 20, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 11, 11, 17, 30, 0), lat, lon), ());
+}
+
+UNIT_TEST(SunriseSunsetAlgorithm_CapeTown_March)
+{
+  // Cape Town (utc +2). For date 2015/3/1:
+  // Sunrise utc time: 2015/3/1,4:34
+  // Sunset utc time: 2015/3/1,17:24
+  double const lat = -33.929573;
+  double const lon = 18.428439;
+
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 3, 1, 4, 30, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 3, 1, 4, 40, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 3, 1, 17, 20, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 3, 1, 17, 30, 0), lat, lon), ());
+}
+
+UNIT_TEST(SunriseSunsetAlgorithm_Tiksi_March)
+{
+  // Russia, Siberia, Tiksi. For date 2015/3/1:
+  // Sunrise utc time: 2015/2/28,23:04
+  // Sunset utc time: 2015/3/1,8:12
+  double const lat = 71.635604;
+  double const lon = 128.882922;
+
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 2, 28, 23, 0, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 2, 28, 23, 10, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 3, 1, 8, 10, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 3, 1, 8, 15, 0), lat, lon), ());
+}
+
+UNIT_TEST(SunriseSunsetAlgorithm_Tiksi_July)
+{
+  // Russia, Siberia, Tiksi. For date 2015/7/1:
+  // Polar day
+  double const lat = 71.635604;
+  double const lon = 128.882922;
+
+  TEST_EQUAL(DayTimeType::PolarDay, GetDayTime(base::TimeGM(2015, 7, 1, 0, 0, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::PolarDay, GetDayTime(base::TimeGM(2015, 7, 1, 12, 0, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::PolarDay, GetDayTime(base::TimeGM(2015, 7, 1, 23, 0, 0), lat, lon), ());
+}
+
+UNIT_TEST(SunriseSunsetAlgorithm_Tiksi_December)
+{
+  // Russia, Siberia, Tiksi. For date 2015/12/1:
+  // Polar night
+  double const lat = 71.635604;
+  double const lon = 128.882922;
+
+  TEST_EQUAL(DayTimeType::PolarNight, GetDayTime(base::TimeGM(2015, 12, 1, 0, 0, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::PolarNight, GetDayTime(base::TimeGM(2015, 12, 1, 12, 0, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::PolarNight, GetDayTime(base::TimeGM(2015, 12, 1, 23, 0, 0), lat, lon), ());
+}
+
+UNIT_TEST(SunriseSunsetAlgorithm_Norilsk_NewYear)
+{
+  // Norilsk. For date 2016/1/1:
+  // Polar night
+  double const lat = 69.350000;
+  double const lon = 88.180000;
+
+  TEST_EQUAL(DayTimeType::PolarNight, GetDayTime(base::TimeGM(2016, 1, 1, 0, 0, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::PolarNight, GetDayTime(base::TimeGM(2016, 1, 1, 12, 0, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::PolarNight, GetDayTime(base::TimeGM(2016, 1, 1, 23, 0, 0), lat, lon), ());
+}
+
+UNIT_TEST(SunriseSunsetAlgorithm_Norilsk_August)
+{
+  // Norilsk. For date 2015/6/22:
+  // Polar day
+  double const lat = 69.350000;
+  double const lon = 88.180000;
+
+  TEST_EQUAL(DayTimeType::PolarDay, GetDayTime(base::TimeGM(2015, 6, 22, 0, 0, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::PolarDay, GetDayTime(base::TimeGM(2015, 6, 22, 12, 0, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::PolarDay, GetDayTime(base::TimeGM(2015, 6, 22, 23, 0, 0), lat, lon), ());
+}
+
+UNIT_TEST(SunriseSunsetAlgorithm_Tokio_September)
+{
+  // Tokio. For date 2015/9/12:
+  // Sunrise utc time: 2015/9/11,20:22
+  // Sunset utc time: 2015/9/12,8:56
+  double const lat = 35.715791;
+  double const lon = 139.743945;
+
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 9, 12, 20, 20, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 9, 12, 20, 25, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 9, 12, 8, 50, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 9, 12, 9, 0, 0), lat, lon), ());
+}
+
+UNIT_TEST(SunriseSunsetAlgorithm_Kabul_March)
+{
+  // Kabul. For date 2015/3/20:
+  // Sunrise utc time: 2015/3/20,01:29
+  // Sunset utc time: 2015/3/20,13:35
+  double const lat = 34.552312;
+  double const lon = 69.170520;
+
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 3, 20, 1, 25, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 3, 20, 1, 35, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 3, 20, 13, 30, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 3, 20, 13, 40, 0), lat, lon), ());
+}
+
+UNIT_TEST(SunriseSunsetAlgorithm_Areora_January)
+{
+  // Areora. For date 2016/1/1:
+  // Sunrise utc time: 2016/1/1,15:57
+  // Sunset utc time: 2016/1/2,5:16
+  double const lat = -20.003751;
+  double const lon = -158.114640;
+
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2016, 1, 1, 15, 50, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2016, 1, 1, 16, 5, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2016, 1, 2, 5, 10, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2016, 1, 2, 5, 20, 0), lat, lon), ());
+}
+
+UNIT_TEST(SunriseSunsetAlgorithm_Lorino_February)
+{
+  // Lorino (utc +12). For date 2016/2/2:
+  // Sunrise utc time: 2016/2/2,20:17
+  // Sunset utc time: 2016/2/3,3:10
+  double const lat = 65.499550;
+  double const lon = -171.715726;
+
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2016, 2, 2, 20, 10, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2016, 2, 2, 20, 20, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2016, 2, 3, 3, 0, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2016, 2, 3, 3, 20, 0), lat, lon), ());
+}
+
+UNIT_TEST(SunriseSunsetAlgorithm_Anadyr_December)
+{
+  // Anadyr. For date 2015/12/25:
+  // Sunrise utc time: 2015/12/24,22:17
+  // Sunset utc time: 2015/12/25,02:03
+  double const lat = 64.722245;
+  double const lon = 177.499123;
+
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 12, 24, 22, 10, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 12, 24, 22, 20, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 12, 25, 2, 0, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 12, 25, 2, 5, 0), lat, lon), ());
+}
+
+UNIT_TEST(SunriseSunsetAlgorithm_Nikolski_December)
+{
+  // Nikolski. For date 2015/12/25:
+  // Sunrise utc time: 2015/12/25,19:29
+  // Sunset utc time: 2015/12/26,3:04
+  double const lat = 52.933280;
+  double const lon = -168.864102;
+
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 12, 25, 19, 0, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 12, 25, 19, 35, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 12, 26, 3, 0, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 12, 26, 3, 10, 0), lat, lon), ());
+}
+
+UNIT_TEST(SunriseSunsetAlgorithm_Kiribati_July)
+{
+  // Kiribati. For date 2015/7/1:
+  // Sunrise utc time: 2015/7/1,16:28
+  // Sunset utc time: 2015/7/2,4:41
+  double const lat = 1.928797;
+  double const lon = -157.494678;
+
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 7, 1, 16, 10, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 7, 1, 16, 35, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 7, 2, 4, 0, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 7, 2, 4, 50, 0), lat, lon), ());
+}
+
+UNIT_TEST(SunriseSunsetAlgorithm_Kiribati_July_2)
+{
+  // Kiribati. For date 2015/7/1:
+  // Sunrise utc time: 2015/7/1,16:28
+  // Sunset utc time: 2015/7/2,4:41
+  // Next sunrise utc time: 2015/7/2,16:28
+  // Next sunset utc time: 2015/7/3,4:42
+  double const lat = 1.928797;
+  double const lon = -157.494678;
+
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 7, 1, 16, 20, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 7, 1, 16, 35, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 7, 2, 4, 35, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 7, 2, 4, 50, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 7, 2, 16, 20, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 7, 2, 16, 35, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 7, 3, 4, 35, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 7, 3, 4, 50, 0), lat, lon), ());
+}
+
+UNIT_TEST(SunriseSunsetAlgorithm_London_July)
+{
+  // London. For date 2015/7/1:
+  // Sunrise utc time: 2015/7/1,3:47
+  // Sunset utc time: 2015/7/1,20:21
+  double const lat = 51.500000;
+  double const lon = 0.120000;
+
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 7, 1, 2, 50, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 7, 1, 16, 20, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Day, GetDayTime(base::TimeGM(2015, 7, 1, 20, 10, 0), lat, lon), ());
+  TEST_EQUAL(DayTimeType::Night, GetDayTime(base::TimeGM(2015, 7, 1, 21, 15, 0), lat, lon), ());
+}
diff --git a/base/base_tests/timegm_test.cpp b/base/base_tests/timegm_test.cpp
index 8e2aacb32d..e352ab7697 100644
--- a/base/base_tests/timegm_test.cpp
+++ b/base/base_tests/timegm_test.cpp
@@ -12,16 +12,20 @@ UNIT_TEST(TimegmTest)
   TEST(strptime("2016-05-17 07:10", "%Y-%m-%d %H:%M", &tm1), ());
   TEST(strptime("2016-05-17 07:10", "%Y-%m-%d %H:%M", &tm2), ());
   TEST_EQUAL(timegm(&tm1), base::TimeGM(tm2), ());
+  TEST_EQUAL(timegm(&tm1), base::TimeGM(2016, 5, 17, 7, 10, 0), ());
 
   TEST(strptime("2016-03-12 11:10", "%Y-%m-%d %H:%M", &tm1), ());
   TEST(strptime("2016-03-12 11:10", "%Y-%m-%d %H:%M", &tm2), ());
   TEST_EQUAL(timegm(&tm1), base::TimeGM(tm2), ());
+  TEST_EQUAL(timegm(&tm1), base::TimeGM(2016, 3, 12, 11, 10, 0), ());
 
   TEST(strptime("1970-01-01 00:00", "%Y-%m-%d %H:%M", &tm1), ());
   TEST(strptime("1970-01-01 00:00", "%Y-%m-%d %H:%M", &tm2), ());
   TEST_EQUAL(timegm(&tm1), base::TimeGM(tm2), ());
+  TEST_EQUAL(timegm(&tm1), base::TimeGM(1970, 1, 1, 0, 0, 0), ());
 
   TEST(strptime("2012-12-02 21:08:34", "%Y-%m-%d %H:%M:%S", &tm1), ());
   TEST(strptime("2012-12-02 21:08:34", "%Y-%m-%d %H:%M:%S", &tm2), ());
   TEST_EQUAL(timegm(&tm1), base::TimeGM(tm2), ());
+  TEST_EQUAL(timegm(&tm1), base::TimeGM(2012, 12, 2, 21, 8, 34), ());
 }
diff --git a/base/sunrise_sunset.cpp b/base/sunrise_sunset.cpp
new file mode 100644
index 0000000000..16e11dd03a
--- /dev/null
+++ b/base/sunrise_sunset.cpp
@@ -0,0 +1,255 @@
+#include "base/sunrise_sunset.hpp"
+
+#include "base/assert.hpp"
+#include "base/exception.hpp"
+#include "base/math.hpp"
+#include "base/timegm.hpp"
+
+namespace
+{
+
+// Sun's zenith for sunrise/sunset
+//   offical      = 90 degrees 50'
+//   civil        = 96 degrees
+//   nautical     = 102 degrees
+//   astronomical = 108 degrees
+double constexpr kZenith = 90 + 50. / 60.; // 90 degrees 50'
+
+time_t constexpr kOneDaySeconds = 24 * 60 * 60;
+
+inline double NormalizeAngle(double a)
+{
+  double res = fmod(a, 360.);
+  if (res < 0)
+    res += 360.;
+  return res;
+}
+
+void NextDay(int & year, int & month, int & day)
+{
+  ASSERT_GREATER_OR_EQUAL(month, 1, ());
+  ASSERT_LESS_OR_EQUAL(month, 12, ());
+  ASSERT_GREATER_OR_EQUAL(day, 1, ());
+  ASSERT_LESS_OR_EQUAL(day, base::DaysOfMonth(year, month), ());
+
+  if (day < base::DaysOfMonth(year, month))
+  {
+    ++day;
+    return;
+  }
+  if (month < 12)
+  {
+    day = 1;
+    ++month;
+    return;
+  }
+  day = 1;
+  month = 1;
+  ++year;
+}
+
+void PrevDay(int & year, int & month, int & day)
+{
+  ASSERT_GREATER_OR_EQUAL(month, 1, ());
+  ASSERT_LESS_OR_EQUAL(month, 12, ());
+  ASSERT_GREATER_OR_EQUAL(day, 1, ());
+  ASSERT_LESS_OR_EQUAL(day, base::DaysOfMonth(year, month), ());
+
+  if (day > 1)
+  {
+    --day;
+    return;
+  }
+  if (month > 1)
+  {
+    --month;
+    day = base::DaysOfMonth(year, month);
+    return;
+  }
+  --year;
+  month = 12;
+  day = 31;
+}
+
+enum class DayEventType
+{
+  Sunrise,
+  Sunset,
+  PolarDay,
+  PolarNight
+};
+
+// Main work-horse function which calculates sunrise/sunset in a specified date in a specified location.
+// This function was taken from source http://williams.best.vwh.net/sunrise_sunset_algorithm.htm.
+// Notation is kept to have source close to source.
+// Original article is // http://babel.hathitrust.org/cgi/pt?id=uiug.30112059294311;view=1up;seq=25
+pair<DayEventType, time_t> CalculateDayEventTime(time_t timeUtc,
+                                                 double latitude, double longitude,
+                                                 bool sunrise)
+{
+  tm const * const gmt = gmtime(&timeUtc);
+  if (nullptr == gmt)
+    MYTHROW(RootException, ("gmtime failed, time =", timeUtc));
+
+  int year = gmt->tm_year + 1900;
+  int month = gmt->tm_mon + 1;
+  int day = gmt->tm_mday;
+
+  // 1. first calculate the day of the year
+
+  double const N1 = floor(275. * month / 9.);
+  double const N2 = floor((month + 9.) / 12.);
+  double const N3 = (1. + floor((year - 4. * floor(year / 4.) + 2.) / 3.));
+  double const N = N1 - (N2 * N3) + day - 30.;
+
+  // 2. convert the longitude to hour value and calculate an approximate time
+
+  double const lngHour = longitude / 15;
+
+  double t = 0;
+  if (sunrise)
+    t = N + ((6 - lngHour) / 24);
+  else
+    t = N + ((18 - lngHour) / 24);
+
+  // 3. calculate the Sun's mean anomaly
+
+  double const M = (0.9856 * t) - 3.289;
+
+  // 4. calculate the Sun's true longitude
+
+  double L = M + (1.916 * sin(my::DegToRad(M))) + (0.020 * sin(2 * my::DegToRad(M))) + 282.634;
+  // NOTE: L potentially needs to be adjusted into the range [0,360) by adding/subtracting 360
+  L = NormalizeAngle(L);
+
+  // 5a. calculate the Sun's right ascension
+
+  double RA = my::RadToDeg( atan(0.91764 * tan(my::DegToRad(L))) );
+  // NOTE: RA potentially needs to be adjusted into the range [0,360) by adding/subtracting 360
+  RA = NormalizeAngle(RA);
+
+  // 5b. right ascension value needs to be in the same quadrant as L
+
+  double const Lquadrant = (floor( L / 90)) * 90;
+  double const RAquadrant = (floor(RA / 90)) * 90;
+  RA = RA + (Lquadrant - RAquadrant);
+
+  // 5c. right ascension value needs to be converted into hours
+
+  RA = RA / 15;
+
+  // 6. calculate the Sun's declination
+
+  double sinDec = 0.39782 * sin(my::DegToRad(L));
+  double cosDec = cos(asin(sinDec));
+
+  // 7a. calculate the Sun's local hour angle
+
+  double cosH = (cos(my::DegToRad(kZenith)) - (sinDec * sin(my::DegToRad(latitude)))) / (cosDec * cos(my::DegToRad(latitude)));
+
+  // if cosH > 1 then sun is never rises on this location on specified date (polar night)
+  // if cosH < -1 then sun is never sets on this location on specified date (polar day)
+  if (cosH < -1 || cosH > 1)
+  {
+    int const h = sunrise ? 0 : 23;
+    int const m = sunrise ? 0 : 59;
+    int const s = sunrise ? 0 : 59;
+
+    return make_pair((cosH < -1) ? DayEventType::PolarDay : DayEventType::PolarNight,
+                     base::TimeGM(year, month, day, h, m, s));
+  }
+
+  // 7b. finish calculating H and convert into hours
+
+  double H = 0;
+  if (sunrise)
+    H = 360 - my::RadToDeg(acos(cosH));
+  else
+    H = my::RadToDeg(acos(cosH));
+
+  H = H / 15;
+
+  // 8. calculate local mean time of rising/setting
+
+  double T = H + RA - (0.06571 * t) - 6.622;
+
+  if (T > 24.)
+    T = fmod(T, 24.);
+  else if (T < 0)
+    T += 24.;
+
+  // 9. adjust back to UTC
+
+  double UT = T - lngHour;
+
+  if (UT > 24.)
+  {
+    NextDay(year, month, day);
+    UT = fmod(UT, 24.0);
+  }
+  else if (UT < 0)
+  {
+    PrevDay(year, month, day);
+    UT += 24.;
+  }
+
+  // UT - is a hour with fractional part of date year/month/day, in range of [0;24)
+
+  int const h = floor(UT); // [0;24)
+  int const m = floor((UT - h) * 60); // [0;60)
+  int const s = fmod(floor(UT * 60 * 60) /* number of seconds from 0:0 to UT */, 60); // [0;60)
+
+  return make_pair(sunrise ? DayEventType::Sunrise : DayEventType::Sunset,
+                   base::TimeGM(year, month, day, h, m, s));
+}
+
+} // namespace
+
+DayTimeType GetDayTime(time_t timeUtc, double latitude, double longitude)
+{
+  auto const sunrise = CalculateDayEventTime(timeUtc, latitude, longitude, true /* sunrise */);
+  auto const sunset = CalculateDayEventTime(timeUtc, latitude, longitude, false /* sunrise */);
+
+  // Edge cases: polar day and polar night
+  if (sunrise.first == DayEventType::PolarDay || sunset.first == DayEventType::PolarDay)
+    return DayTimeType::PolarDay;
+  else if (sunrise.first == DayEventType::PolarNight || sunset.first == DayEventType::PolarNight)
+    return DayTimeType::PolarNight;
+
+  if (timeUtc < sunrise.second)
+  {
+    auto const prevSunrise = CalculateDayEventTime(timeUtc - kOneDaySeconds, latitude, longitude, true /* sunrise */);
+    auto const prevSunset = CalculateDayEventTime(timeUtc - kOneDaySeconds, latitude, longitude, false /* sunrise */);
+
+    if (timeUtc >= prevSunset.second)
+      return DayTimeType::Night;
+    if (timeUtc < prevSunrise.second)
+      return DayTimeType::Night;
+    return DayTimeType::Day;
+  }
+  else if (timeUtc > sunset.second)
+  {
+    auto const nextSunrise = CalculateDayEventTime(timeUtc + kOneDaySeconds, latitude, longitude, true /* sunrise */);
+    auto const nextSunset = CalculateDayEventTime(timeUtc + kOneDaySeconds, latitude, longitude, false /* sunrise */);
+
+    if (timeUtc < nextSunrise.second)
+      return DayTimeType::Night;
+    if (timeUtc > nextSunset.second)
+      return DayTimeType::Night;
+    return DayTimeType::Day;
+  }
+
+  return DayTimeType::Day;
+}
+
+string DebugPrint(DayTimeType type)
+{
+  switch (type)
+  {
+  case DayTimeType::Day: return "Day";
+  case DayTimeType::Night: return "Night";
+  case DayTimeType::PolarDay: return "PolarDay";
+  case DayTimeType::PolarNight: return "PolarNight";
+  }
+  return string();
+}
diff --git a/base/sunrise_sunset.hpp b/base/sunrise_sunset.hpp
new file mode 100644
index 0000000000..110c9c4151
--- /dev/null
+++ b/base/sunrise_sunset.hpp
@@ -0,0 +1,22 @@
+#pragma once
+
+#include "std/ctime.hpp"
+#include "std/string.hpp"
+
+enum class DayTimeType
+{
+  Day,
+  Night,
+  PolarDay,
+  PolarNight
+};
+
+string DebugPrint(DayTimeType type);
+
+/// Helpers which calculates 'is day time' without a time calculation error.
+/// @param timeUtc - utc time
+/// @param latitude - latutude, -90...+90 degrees
+/// @param longitude - longitude, -180...+180 degrees
+/// @returns day time type for a specified date for a specified location
+/// @note throws RootException if gmtime returns nullptr
+DayTimeType GetDayTime(time_t timeUtc, double latitude, double longitude);
diff --git a/base/timegm.cpp b/base/timegm.cpp
index 8aff002f18..6b324f4e20 100644
--- a/base/timegm.cpp
+++ b/base/timegm.cpp
@@ -1,5 +1,7 @@
 #include "timegm.hpp"
 
+#include "base/assert.hpp"
+
 // There are issues with this implementation due to absence
 // of time_t fromat specification. There are no guarantees
 // of its internal structure so we cannot rely on + or -.
@@ -10,17 +12,13 @@
 
 namespace
 {
+
 // Number of days elapsed since Jan 01 up to each month
 // (except for February in leap years).
 int const g_monoff[] = {
   0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334
 };
 
-bool IsLeapYear(int year)
-{
-  return year % 4 == 0 && (year % 100 != 0 || year % 400 == 0);
-}
-
 int LeapDaysCount(int y1, int y2)
 {
   --y1;
@@ -31,6 +29,22 @@ int LeapDaysCount(int y1, int y2)
 
 namespace base
 {
+
+int DaysOfMonth(int year, int month)
+{
+  ASSERT_GREATER_OR_EQUAL(month, 1, ());
+  ASSERT_LESS_OR_EQUAL(month, 12, ());
+
+  int const february = base::IsLeapYear(year) ? 29 : 28;
+  int const daysPerMonth[12] = { 31, february, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
+  return daysPerMonth[month - 1];
+}
+
+bool IsLeapYear(int year)
+{
+  return year % 4 == 0 && (year % 100 != 0 || year % 400 == 0);
+}
+
 // Inspired by python's calendar.py
 time_t TimeGM(std::tm const & tm)
 {
@@ -54,4 +68,22 @@ time_t TimeGM(std::tm const & tm)
 
   return seconds;
 }
+
+time_t TimeGM(int year, int month, int day, int hour, int min, int sec)
+{
+  ASSERT_GREATER_OR_EQUAL(month, 1, ());
+  ASSERT_LESS_OR_EQUAL(month, 12, ());
+  ASSERT_GREATER_OR_EQUAL(day, 1, ());
+  ASSERT_LESS_OR_EQUAL(day, DaysOfMonth(year, month), ());
+
+  tm t = {};
+  t.tm_year = year - 1900;
+  t.tm_mon = month - 1;
+  t.tm_mday = day;
+  t.tm_hour = hour;
+  t.tm_min = min;
+  t.tm_sec = sec;
+  return TimeGM(t);
+}
+
 } // namespace base
diff --git a/base/timegm.hpp b/base/timegm.hpp
index fbc5194aa6..74dfbc5d8d 100644
--- a/base/timegm.hpp
+++ b/base/timegm.hpp
@@ -2,9 +2,26 @@
 
 #include "std/ctime.hpp"
 
-// For some reasons android doesn't have timegm function. The following
-// work around is provided.
 namespace base
 {
+
+// Returns true if year is leap (has 29 days in Feb).
+bool IsLeapYear(int year);
+
+// Returns number of days for specified month and year.
+int DaysOfMonth(int year, int month);
+
+// For some reasons android doesn't have timegm function. The following
+// work around is provided.
 time_t TimeGM(std::tm const & tm);
-}
+
+// Forms timestamp (number of seconds since 1.1.1970) from year/day/month, hour:min:sec
+// year - since 0, for example 2015
+// month - 1-jan...12-dec
+// day - 1...31
+// hour - 0...23
+// min - 0...59
+// sec - 0...59
+time_t TimeGM(int year, int month, int day, int hour, int min, int sec);
+
+} // base