diff --git a/.idea/deploymentTargetSelector.xml b/.idea/deploymentTargetSelector.xml
index 8627841..8c7731f 100644
--- a/.idea/deploymentTargetSelector.xml
+++ b/.idea/deploymentTargetSelector.xml
@@ -4,10 +4,10 @@
     <selectionStates>
       <SelectionState runConfigName="app">
         <option name="selectionMode" value="DROPDOWN" />
-        <DropdownSelection timestamp="2025-09-25T20:36:01.018251800Z">
+        <DropdownSelection timestamp="2025-10-07T06:51:31.183962394Z">
           <Target type="DEFAULT_BOOT">
             <handle>
-              <DeviceId pluginId="LocalEmulator" identifier="path=/home/trevor/.android/avd/Medium_Phone.avd" />
+              <DeviceId pluginId="PhysicalDevice" identifier="serial=LGMG600S9b4da66b" />
             </handle>
           </Target>
         </DropdownSelection>
diff --git a/app/build.gradle.kts b/app/build.gradle.kts
index 39f3f90..9306d89 100644
--- a/app/build.gradle.kts
+++ b/app/build.gradle.kts
@@ -1,7 +1,7 @@
 plugins {
     alias(libs.plugins.android.application)
     alias(libs.plugins.kotlin.android)
-    alias(libs.plugins.kotlin.compose)
+    id("com.google.devtools.ksp") version "1.9.20-1.0.14"
 }
 
 android {
@@ -19,6 +19,11 @@ android {
         vectorDrawables {
             useSupportLibrary = true
         }
+
+        // Включаем десугаринг для поддержки Java 8 API на старых устройствах
+        compileOptions {
+            isCoreLibraryDesugaringEnabled = true
+        }
     }
 
     buildTypes {
@@ -41,7 +46,7 @@ android {
         compose = true
     }
     composeOptions {
-        kotlinCompilerExtensionVersion = "1.5.1"
+        kotlinCompilerExtensionVersion = "1.5.4"
     }
     packaging {
         resources {
@@ -60,6 +65,16 @@ dependencies {
     implementation("androidx.compose.ui:ui-tooling-preview")
     implementation("androidx.compose.material3:material3")
 
+    // Material Icons
+    implementation("androidx.compose.material:material-icons-core")
+    implementation("androidx.compose.material:material-icons-extended")
+
+    // Keyboard options for text fields
+    implementation("androidx.compose.foundation:foundation")
+
+    // Security
+    implementation("androidx.security:security-crypto:1.1.0-alpha06")
+
     // Navigation
     implementation("androidx.navigation:navigation-compose:2.7.6")
 
@@ -78,6 +93,18 @@ dependencies {
     // Permissions
     implementation("com.google.accompanist:accompanist-permissions:0.32.0")
 
+    // Coil для загрузки изображений
+    implementation("io.coil-kt:coil-compose:2.5.0")
+
+    // Room Database
+    implementation("androidx.room:room-runtime:2.6.1")
+    implementation("androidx.room:room-ktx:2.6.1")
+    annotationProcessor("androidx.room:room-compiler:2.6.1")
+    ksp("androidx.room:room-compiler:2.6.1")
+
+    // LiveData
+    implementation("androidx.compose.runtime:runtime-livedata")
+
     // Testing
     testImplementation("junit:junit:4.13.2")
     androidTestImplementation("androidx.test.ext:junit:1.1.5")
@@ -86,4 +113,7 @@ dependencies {
     androidTestImplementation("androidx.compose.ui:ui-test-junit4")
     debugImplementation("androidx.compose.ui:ui-tooling")
     debugImplementation("androidx.compose.ui:ui-test-manifest")
+
+    // Десугаринг для поддержки Java 8 API (включая java.time) на Android API 24 и ниже
+    coreLibraryDesugaring("com.android.tools:desugar_jdk_libs:2.0.3")
 }
diff --git a/app/src/main/java/com/example/womansafe/MainActivity.kt b/app/src/main/java/com/example/womansafe/MainActivity.kt
index c3bd297..b2df6e5 100644
--- a/app/src/main/java/com/example/womansafe/MainActivity.kt
+++ b/app/src/main/java/com/example/womansafe/MainActivity.kt
@@ -8,7 +8,9 @@ import androidx.activity.viewModels
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Surface
+import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.ui.Modifier
+import com.example.womansafe.data.network.NetworkClient
 import com.example.womansafe.ui.screens.AuthScreen
 import com.example.womansafe.ui.screens.MainScreen
 import com.example.womansafe.ui.theme.WomanSafeTheme
@@ -19,6 +21,10 @@ class MainActivity : ComponentActivity() {
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
+
+        // Инициализируем NetworkClient для работы с сохраненным токеном
+        NetworkClient.initialize(applicationContext)
+
         enableEdgeToEdge()
         setContent {
             WomanSafeTheme {
@@ -26,6 +32,14 @@ class MainActivity : ComponentActivity() {
                     modifier = Modifier.fillMaxSize(),
                     color = MaterialTheme.colorScheme.background
                 ) {
+                    // Проверяем сохраненный токен и пытаемся выполнить автоматический вход
+                    LaunchedEffect(Unit) {
+                        NetworkClient.getAuthToken()?.let { token ->
+                            // Если токен существует, пытаемся выполнить автоматический вход
+                            authViewModel.autoLogin(token)
+                        }
+                    }
+
                     // Показываем либо экран авторизации, либо главный экран
                     if (authViewModel.uiState.isLoggedIn) {
                         MainScreen(authViewModel = authViewModel)
diff --git a/app/src/main/java/com/example/womansafe/data/api/CalendarApi.kt b/app/src/main/java/com/example/womansafe/data/api/CalendarApi.kt
new file mode 100644
index 0000000..831d64d
--- /dev/null
+++ b/app/src/main/java/com/example/womansafe/data/api/CalendarApi.kt
@@ -0,0 +1,54 @@
+package com.example.womansafe.data.api
+
+import com.example.womansafe.data.model.calendar.CalendarEntry
+import com.example.womansafe.data.model.calendar.CycleData
+import com.example.womansafe.data.model.calendar.HealthInsight
+import retrofit2.Response
+import retrofit2.http.*
+
+/**
+ * API интерфейс для взаимодействия с серверной частью календаря
+ */
+interface CalendarApi {
+
+    @GET("api/v1/calendar/cycle-data")
+    suspend fun getCycleData(): Response<CycleData>
+
+    @POST("api/v1/calendar/cycle-data")
+    suspend fun updateCycleData(@Body cycleData: CycleData): Response<CycleData>
+
+    @GET("api/v1/calendar/entries")
+    suspend fun getCalendarEntries(
+        @Query("start_date") startDate: String? = null,
+        @Query("end_date") endDate: String? = null
+    ): Response<List<CalendarEntry>>
+
+    @GET("api/v1/calendar/entries/{entry_id}")
+    suspend fun getCalendarEntry(
+        @Path("entry_id") entryId: Long
+    ): Response<CalendarEntry>
+
+    @POST("api/v1/calendar/entries")
+    suspend fun addCalendarEntry(
+        @Body entry: CalendarEntry
+    ): Response<CalendarEntry>
+
+    @PUT("api/v1/calendar/entries/{entry_id}")
+    suspend fun updateCalendarEntry(
+        @Path("entry_id") entryId: Long,
+        @Body entry: CalendarEntry
+    ): Response<CalendarEntry>
+
+    @DELETE("api/v1/calendar/entries/{entry_id}")
+    suspend fun deleteCalendarEntry(
+        @Path("entry_id") entryId: Long
+    ): Response<Unit>
+
+    @GET("api/v1/calendar/insights")
+    suspend fun getHealthInsights(): Response<List<HealthInsight>>
+
+    @POST("api/v1/calendar/insights/{insight_id}/dismiss")
+    suspend fun dismissInsight(
+        @Path("insight_id") insightId: Long
+    ): Response<Unit>
+}
diff --git a/app/src/main/java/com/example/womansafe/data/api/WomanSafeApi.kt b/app/src/main/java/com/example/womansafe/data/api/WomanSafeApi.kt
index 2333eff..f72dc00 100644
--- a/app/src/main/java/com/example/womansafe/data/api/WomanSafeApi.kt
+++ b/app/src/main/java/com/example/womansafe/data/api/WomanSafeApi.kt
@@ -123,39 +123,41 @@ interface WomanSafeApi {
     @DELETE("api/v1/locations/safe-places/{place_id}")
     suspend fun deleteSafePlace(@Path("place_id") placeId: String): Response<Any>
 
-    // Calendar endpoints
+    // Календарь и отслеживание цикла
+    @GET("api/v1/calendar/cycle-data")
+    suspend fun getCycleData(): Response<CycleData>
+
     @GET("api/v1/calendar/entries")
-    suspend fun getCalendarEntries(): Response<CalendarEntriesResponse>
+    suspend fun getCalendarEntries(
+        @Query("start_date") startDate: String? = null,
+        @Query("end_date") endDate: String? = null,
+        @Query("entry_type") entryType: String? = null,
+        @Query("limit") limit: Int? = null
+    ): Response<List<CalendarEvent>>
 
-    @POST("api/v1/calendar/entry")
-    suspend fun createCalendarEntry(@Body entry: CalendarEntryCreate): Response<CalendarEvent>
-
-    @GET("api/v1/calendar/entries/{entry_id}")
-    suspend fun getCalendarEntry(@Path("entry_id") entryId: String): Response<CalendarEvent>
+    @POST("api/v1/calendar/entries")
+    suspend fun createCalendarEntry(@Body entry: CalendarEntryRequest): Response<CalendarEvent>
 
     @PUT("api/v1/calendar/entries/{entry_id}")
-    suspend fun updateCalendarEntry(@Path("entry_id") entryId: String, @Body entry: CalendarEntryUpdate): Response<CalendarEvent>
+    suspend fun updateCalendarEntry(
+        @Path("entry_id") entryId: String,
+        @Body entry: CalendarEntryRequest
+    ): Response<CalendarEvent>
 
     @DELETE("api/v1/calendar/entries/{entry_id}")
-    suspend fun deleteCalendarEntry(@Path("entry_id") entryId: String): Response<Any>
+    suspend fun deleteCalendarEntry(@Path("entry_id") entryId: String): Response<Unit>
 
-    @GET("api/v1/calendar/cycle-overview")
-    suspend fun getCycleOverview(): Response<Any>
+    @GET("api/v1/calendar/statistics")
+    suspend fun getCycleStatistics(): Response<CycleStatistics>
+
+    @GET("api/v1/calendar/predictions")
+    suspend fun getCyclePredictions(): Response<CyclePrediction>
 
     @GET("api/v1/calendar/insights")
-    suspend fun getCalendarInsights(): Response<Any>
+    suspend fun getHealthInsights(): Response<List<HealthInsight>>
 
-    @GET("api/v1/calendar/reminders")
-    suspend fun getCalendarReminders(): Response<Any>
-
-    @POST("api/v1/calendar/reminders")
-    suspend fun createCalendarReminder(): Response<Any>
-
-    @GET("api/v1/calendar/settings")
-    suspend fun getCalendarSettings(): Response<Any>
-
-    @PUT("api/v1/calendar/settings")
-    suspend fun updateCalendarSettings(): Response<Any>
+    @PATCH("api/v1/calendar/insights/{insight_id}/dismiss")
+    suspend fun dismissInsight(@Path("insight_id") insightId: String): Response<HealthInsight>
 
     // Notification endpoints
     @GET("api/v1/notifications/devices")
diff --git a/app/src/main/java/com/example/womansafe/data/local/CalendarDao.kt b/app/src/main/java/com/example/womansafe/data/local/CalendarDao.kt
new file mode 100644
index 0000000..966a617
--- /dev/null
+++ b/app/src/main/java/com/example/womansafe/data/local/CalendarDao.kt
@@ -0,0 +1,86 @@
+package com.example.womansafe.data.local
+
+import androidx.room.*
+import com.example.womansafe.data.model.calendar.CycleData
+import com.example.womansafe.data.model.calendar.CalendarEntry
+import com.example.womansafe.data.model.calendar.HealthInsight
+import kotlinx.coroutines.flow.Flow
+import java.time.LocalDate
+
+/**
+ * DAO для работы с данными менструального календаря
+ */
+@Dao
+interface CalendarDao {
+    // CycleData operations
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insertCycleData(cycleData: CycleData)
+
+    @Query("SELECT * FROM cycle_data WHERE userId = :userId")
+    suspend fun getCycleDataByUserId(userId: String): CycleData?
+
+    @Query("SELECT * FROM cycle_data WHERE userId = :userId")
+    fun getCycleDataFlowByUserId(userId: String): Flow<CycleData?>
+
+    @Delete
+    suspend fun deleteCycleData(cycleData: CycleData)
+
+    // CalendarEntry operations
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insertCalendarEntry(entry: CalendarEntry): Long
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insertCalendarEntries(entries: List<CalendarEntry>)
+
+    @Update
+    suspend fun updateCalendarEntry(entry: CalendarEntry)
+
+    @Query("SELECT * FROM calendar_entries WHERE userId = :userId ORDER BY entryDate DESC")
+    fun getAllCalendarEntriesFlow(userId: String): Flow<List<CalendarEntry>>
+
+    @Query("SELECT * FROM calendar_entries WHERE userId = :userId AND entryDate = :date")
+    suspend fun getCalendarEntryByDate(userId: String, date: LocalDate): CalendarEntry?
+
+    @Query("SELECT * FROM calendar_entries WHERE userId = :userId AND entryDate BETWEEN :startDate AND :endDate ORDER BY entryDate")
+    suspend fun getCalendarEntriesBetweenDates(userId: String, startDate: LocalDate, endDate: LocalDate): List<CalendarEntry>
+
+    @Query("SELECT * FROM calendar_entries WHERE userId = :userId AND entryDate BETWEEN :startDate AND :endDate ORDER BY entryDate")
+    fun getCalendarEntriesBetweenDatesFlow(userId: String, startDate: LocalDate, endDate: LocalDate): Flow<List<CalendarEntry>>
+
+    @Query("SELECT * FROM calendar_entries WHERE id = :entryId")
+    suspend fun getCalendarEntryById(entryId: Long): CalendarEntry?
+
+    @Delete
+    suspend fun deleteCalendarEntry(entry: CalendarEntry)
+
+    @Query("DELETE FROM calendar_entries WHERE userId = :userId AND entryDate = :date")
+    suspend fun deleteCalendarEntryByDate(userId: String, date: LocalDate)
+
+    @Query("SELECT * FROM calendar_entries ORDER BY entryDate DESC")
+    suspend fun getAllCalendarEntries(): List<CalendarEntry>
+
+    // HealthInsight operations
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insertHealthInsight(insight: HealthInsight): Long
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insertHealthInsights(insights: List<HealthInsight>)
+
+    @Update
+    suspend fun updateHealthInsight(insight: HealthInsight)
+
+    @Query("SELECT * FROM health_insights WHERE userId = :userId AND isDismissed = 0 ORDER BY createdAt DESC")
+    fun getActiveHealthInsightsFlow(userId: String): Flow<List<HealthInsight>>
+
+    @Query("SELECT * FROM health_insights WHERE userId = :userId ORDER BY createdAt DESC")
+    fun getAllHealthInsightsFlow(userId: String): Flow<List<HealthInsight>>
+
+    @Query("UPDATE health_insights SET isDismissed = 1 WHERE id = :insightId")
+    suspend fun dismissHealthInsight(insightId: Long)
+
+    @Query("DELETE FROM health_insights WHERE userId = :userId AND createdAt < :timestamp")
+    suspend fun deleteOldInsights(userId: String, timestamp: Long)
+
+    @Query("SELECT * FROM cycle_data ORDER BY lastUpdated DESC LIMIT 1")
+    suspend fun getLatestCycleData(): CycleData?
+}
diff --git a/app/src/main/java/com/example/womansafe/data/local/CalendarDatabase.kt b/app/src/main/java/com/example/womansafe/data/local/CalendarDatabase.kt
new file mode 100644
index 0000000..38d5f9c
--- /dev/null
+++ b/app/src/main/java/com/example/womansafe/data/local/CalendarDatabase.kt
@@ -0,0 +1,48 @@
+package com.example.womansafe.data.local
+
+import android.content.Context
+import androidx.room.Database
+import androidx.room.Room
+import androidx.room.RoomDatabase
+import androidx.room.TypeConverters
+import com.example.womansafe.data.model.calendar.CalendarEntry
+import com.example.womansafe.data.model.calendar.CycleData
+import com.example.womansafe.data.model.calendar.HealthInsight
+
+/**
+ * База данных Room для хранения всех данных менструального календаря
+ */
+@Database(
+    entities = [
+        CycleData::class,
+        CalendarEntry::class,
+        HealthInsight::class
+    ],
+    version = 1,
+    exportSchema = false
+)
+@TypeConverters(CalendarTypeConverters::class)
+abstract class CalendarDatabase : RoomDatabase() {
+
+    abstract fun calendarDao(): CalendarDao
+
+    companion object {
+        @Volatile
+        private var INSTANCE: CalendarDatabase? = null
+
+        fun getDatabase(context: Context): CalendarDatabase {
+            return INSTANCE ?: synchronized(this) {
+                val instance = Room.databaseBuilder(
+                    context.applicationContext,
+                    CalendarDatabase::class.java,
+                    "calendar_database"
+                )
+                .fallbackToDestructiveMigration()
+                .build()
+
+                INSTANCE = instance
+                instance
+            }
+        }
+    }
+}
diff --git a/app/src/main/java/com/example/womansafe/data/local/CalendarTypeConverters.kt b/app/src/main/java/com/example/womansafe/data/local/CalendarTypeConverters.kt
new file mode 100644
index 0000000..3790297
--- /dev/null
+++ b/app/src/main/java/com/example/womansafe/data/local/CalendarTypeConverters.kt
@@ -0,0 +1,112 @@
+package com.example.womansafe.data.local
+
+import androidx.room.TypeConverter
+import com.example.womansafe.data.model.calendar.*
+import com.google.gson.Gson
+import com.google.gson.reflect.TypeToken
+import java.time.LocalDate
+
+/**
+ * Конвертеры типов для Room базы данных для работы с нестандартными типами
+ */
+class CalendarTypeConverters {
+    private val gson = Gson()
+
+    @TypeConverter
+    fun fromLocalDate(value: LocalDate?): String? {
+        return value?.toString()
+    }
+
+    @TypeConverter
+    fun toLocalDate(value: String?): LocalDate? {
+        return value?.let { LocalDate.parse(it) }
+    }
+
+    @TypeConverter
+    fun fromSymptomList(value: List<Symptom>?): String? {
+        return value?.let { gson.toJson(it) }
+    }
+
+    @TypeConverter
+    fun toSymptomList(value: String?): List<Symptom>? {
+        if (value == null) return null
+        val listType = object : TypeToken<List<Symptom>>() {}.type
+        return gson.fromJson(value, listType)
+    }
+
+    @TypeConverter
+    fun fromStringList(value: List<String>?): String? {
+        return value?.let { gson.toJson(it) }
+    }
+
+    @TypeConverter
+    fun toStringList(value: String?): List<String>? {
+        if (value == null) return null
+        val listType = object : TypeToken<List<String>>() {}.type
+        return gson.fromJson(value, listType)
+    }
+
+    @TypeConverter
+    fun fromEntryType(value: EntryType): String {
+        return value.name
+    }
+
+    @TypeConverter
+    fun toEntryType(value: String): EntryType {
+        return try {
+            EntryType.valueOf(value)
+        } catch (e: IllegalArgumentException) {
+            EntryType.NOTE // Дефолтное значение
+        }
+    }
+
+    @TypeConverter
+    fun fromFlowIntensity(value: FlowIntensity?): String? {
+        return value?.name
+    }
+
+    @TypeConverter
+    fun toFlowIntensity(value: String?): FlowIntensity? {
+        if (value == null) return null
+        return try {
+            FlowIntensity.valueOf(value)
+        } catch (e: IllegalArgumentException) {
+            null
+        }
+    }
+
+    @TypeConverter
+    fun fromMood(value: Mood?): String? {
+        return value?.name
+    }
+
+    @TypeConverter
+    fun toMood(value: String?): Mood? {
+        if (value == null) return null
+        return try {
+            Mood.valueOf(value)
+        } catch (e: IllegalArgumentException) {
+            null
+        }
+    }
+
+    @TypeConverter
+    fun fromInsightType(value: InsightType): String {
+        return value.name
+    }
+
+    @TypeConverter
+    fun toInsightType(value: String): InsightType {
+        return InsightType.valueOf(value)
+    }
+
+    @TypeConverter
+    fun fromConfidenceLevel(value: ConfidenceLevel): String {
+        return value.name
+    }
+
+    @TypeConverter
+    fun toConfidenceLevel(value: String): ConfidenceLevel {
+        return ConfidenceLevel.valueOf(value)
+    }
+}
diff --git a/app/src/main/java/com/example/womansafe/data/model/ApiModels.kt b/app/src/main/java/com/example/womansafe/data/model/ApiModels.kt
index 09addd7..cb20f5e 100644
--- a/app/src/main/java/com/example/womansafe/data/model/ApiModels.kt
+++ b/app/src/main/java/com/example/womansafe/data/model/ApiModels.kt
@@ -1,5 +1,6 @@
 package com.example.womansafe.data.model
 
+import com.example.womansafe.data.model.calendar.CalendarEntry
 import com.google.gson.annotations.SerializedName
 
 // Request body wrapper for API Gateway proxy endpoints
@@ -249,17 +250,6 @@ data class NearbyUser(
 )
 
 // Calendar models
-data class CalendarEntry(
-    val title: String,
-    val description: String? = null,
-    val start_date: String,
-    val end_date: String? = null,
-    val entry_type: String,
-    val mood: String? = null,
-    val symptoms: List<String>? = null,
-    val notes: String? = null
-)
-
 data class LegacyCalendarEntryResponse(  // Переименовано, чтобы избежать конфликта с CalendarModels.kt
     val id: Int,
     val title: String,
diff --git a/app/src/main/java/com/example/womansafe/data/model/CalendarModels.kt b/app/src/main/java/com/example/womansafe/data/model/CalendarModels.kt
index 2ff3275..d218fb7 100644
--- a/app/src/main/java/com/example/womansafe/data/model/CalendarModels.kt
+++ b/app/src/main/java/com/example/womansafe/data/model/CalendarModels.kt
@@ -34,9 +34,9 @@ enum class SymptomType {
     NAUSEA          // Тошнота
 }
 
-// Событие календаря
+// Событие календаря (доменная модель)
 data class CalendarEvent(
-    val id: String? = null,  // Изменено с Int? на String?, так как в API используются UUID
+    val id: String? = null,
     val date: LocalDate,
     val type: CalendarEventType,
     val isActual: Boolean = true, // true - фактическое, false - прогноз
@@ -46,7 +46,24 @@ data class CalendarEvent(
     val flowIntensity: Int? = null, // Интенсивность выделений 1-5
     val createdAt: LocalDate = LocalDate.now(),
     val updatedAt: LocalDate = LocalDate.now(),
-    val isPredicted: Boolean = false  // Добавлено поле для совместимости с API
+    val isPredicted: Boolean = false
+)
+
+// API модели для обмена с сервером
+data class CalendarEventApiResponse(
+    val id: Int,
+    val uuid: String,
+    val entry_date: String,
+    val entry_type: String,
+    val flow_intensity: String? = null,
+    val mood: String? = null,
+    val symptoms: String = "",
+    val notes: String? = null,
+    val is_predicted: Boolean = false,
+    val created_at: String? = null,
+    val updated_at: String? = null,
+    val is_active: Boolean = true,
+    val user_id: Int
 )
 
 // Настройки цикла
@@ -61,26 +78,6 @@ data class CycleSettings(
     val reminderDaysBefore: Int = 3  // За сколько дней напоминать о приближающемся цикле
 )
 
-// Прогноз цикла
-data class CyclePrediction(
-    val nextPeriodStart: LocalDate,
-    val nextPeriodEnd: LocalDate,
-    val nextOvulation: LocalDate,
-    val fertileWindowStart: LocalDate,
-    val fertileWindowEnd: LocalDate,
-    val confidence: Float = 0.85f  // Добавлено значение достоверности прогноза в %
-)
-
-// Статистика цикла
-data class CycleStatistics(
-    val averageCycleLength: Float = 0f,
-    val cycleVariation: Float = 0f,
-    val lastCycles: List<Int> = emptyList(),
-    val periodLengthAverage: Float = 0f,
-    val commonSymptoms: List<SymptomType> = emptyList(),
-    val moodPatterns: Map<MoodType, Float> = emptyMap()
-)
-
 // Модели для API
 
 // Запрос на создание события в календаре
@@ -133,3 +130,86 @@ data class CalendarEntriesResponse(
     val entries: List<CalendarEntryResponse>,
     val cycle_info: CycleInfoResponse
 )
+
+// Extension функции для преобразования API моделей в доменные
+fun CalendarEventApiResponse.toDomainModel(): CalendarEvent {
+    println("=== Преобразование API модели в доменную ===")
+    println("API данные: entry_date=${this.entry_date}, entry_type=${this.entry_type}, symptoms=${this.symptoms}")
+
+    val calendarEvent = CalendarEvent(
+        id = this.uuid,
+        date = LocalDate.parse(this.entry_date),
+        type = mapApiTypeToCalendarEventType(this.entry_type),
+        isActual = !this.is_predicted,
+        mood = this.mood?.let { mapApiMoodToMoodType(it) },
+        symptoms = parseApiSymptoms(this.symptoms),
+        notes = this.notes ?: "",
+        flowIntensity = mapApiFlowIntensityToInt(this.flow_intensity),
+        isPredicted = this.is_predicted,
+        createdAt = this.created_at?.let {
+            try {
+                LocalDate.parse(it.substring(0, 10))
+            } catch (e: Exception) {
+                LocalDate.now()
+            }
+        } ?: LocalDate.now(),
+        updatedAt = this.updated_at?.let {
+            try {
+                LocalDate.parse(it.substring(0, 10))
+            } catch (e: Exception) {
+                LocalDate.now()
+            }
+        } ?: LocalDate.now()
+    )
+
+    println("Доменная модель: id=${calendarEvent.id}, date=${calendarEvent.date}, type=${calendarEvent.type}")
+    println("=============================================")
+
+    return calendarEvent
+}
+
+// Вспомогательные функции для маппинга
+private fun mapApiTypeToCalendarEventType(apiType: String): CalendarEventType {
+    return when (apiType.lowercase()) {
+        "period" -> CalendarEventType.MENSTRUATION
+        "ovulation" -> CalendarEventType.OVULATION
+        "fertile_window" -> CalendarEventType.FERTILE_WINDOW
+        "predicted_period" -> CalendarEventType.PREDICTED_MENSTRUATION
+        "predicted_ovulation" -> CalendarEventType.PREDICTED_OVULATION
+        else -> CalendarEventType.MENSTRUATION // по умолчанию
+    }
+}
+
+private fun mapApiMoodToMoodType(apiMood: String): MoodType {
+    return when (apiMood.uppercase()) {
+        "EXCELLENT" -> MoodType.EXCELLENT
+        "GOOD" -> MoodType.GOOD
+        "NORMAL" -> MoodType.NORMAL
+        "BAD" -> MoodType.BAD
+        "TERRIBLE" -> MoodType.TERRIBLE
+        else -> MoodType.NORMAL // по умолчанию
+    }
+}
+
+private fun parseApiSymptoms(symptomsString: String): List<SymptomType> {
+    if (symptomsString.isBlank()) return emptyList()
+
+    return symptomsString.split(",")
+        .map { it.trim() }
+        .mapNotNull { symptom ->
+            try {
+                SymptomType.valueOf(symptom.uppercase())
+            } catch (e: IllegalArgumentException) {
+                null // Игнорируем неизвестные симптомы
+            }
+        }
+}
+
+private fun mapApiFlowIntensityToInt(apiIntensity: String?): Int? {
+    return when (apiIntensity?.lowercase()) {
+        "light" -> 2
+        "medium" -> 3
+        "heavy" -> 5
+        else -> null
+    }
+}
diff --git a/app/src/main/java/com/example/womansafe/data/model/CycleModels.kt b/app/src/main/java/com/example/womansafe/data/model/CycleModels.kt
new file mode 100644
index 0000000..fc1bfa7
--- /dev/null
+++ b/app/src/main/java/com/example/womansafe/data/model/CycleModels.kt
@@ -0,0 +1,128 @@
+package com.example.womansafe.data.model
+
+import java.time.LocalDate
+import java.time.LocalDateTime
+import com.example.womansafe.data.model.calendar.CalendarEntry
+import com.example.womansafe.data.model.calendar.EntryType
+import com.example.womansafe.data.model.calendar.FlowIntensity
+import com.example.womansafe.data.model.calendar.Symptom
+import com.example.womansafe.data.model.calendar.Mood
+
+/**
+ * Модель данных цикла
+ */
+data class CycleData(
+    val user_id: Int,
+    val cycle_start_date: LocalDate,
+    val cycle_length: Int,
+    val period_length: Int,
+    val ovulation_date: LocalDate,
+    val fertile_window_start: LocalDate,
+    val fertile_window_end: LocalDate,
+    val next_period_predicted: LocalDate,
+    val cycle_regularity_score: Int,  // 1-100
+    val avg_cycle_length: Float,
+    val avg_period_length: Float
+)
+
+/**
+ * Модель для аналитики здоровья и инсайтов
+ */
+data class HealthInsight(
+    val id: Int,
+    val user_id: Int,
+    val insight_type: InsightType,
+    val title: String,
+    val description: String,
+    val recommendation: String,
+    val confidence_level: ConfidenceLevel,
+    val data_points_used: Int,
+    val is_dismissed: Boolean = false,
+    val created_at: LocalDateTime? = null
+)
+
+/**
+ * Типы записей в календаре
+ */
+
+/**
+ * Интенсивность менструации
+ */
+
+/**
+ * Настроение
+ */
+
+/**
+ * Симптомы
+ */
+
+/**
+ * Типы инсайтов
+ */
+enum class InsightType {
+    CYCLE_IRREGULARITY,
+    PERIOD_LENGTH_CHANGE,
+    SYMPTOM_PATTERN,
+    HEALTH_RECOMMENDATION,
+    OVULATION_PREDICTION,
+    LIFESTYLE_IMPACT
+}
+
+/**
+ * Уровни достоверности инсайтов
+ */
+enum class ConfidenceLevel {
+    LOW,
+    MEDIUM,
+    HIGH
+}
+
+/**
+ * Модель для запроса на создание записи в календаре
+ */
+data class CalendarEntryRequest(
+    val entry_date: String,
+    val entry_type: String,
+    val flow_intensity: String? = null,
+    val period_symptoms: List<String>? = null,
+    val mood: String? = null,
+    val energy_level: Int? = null,
+    val sleep_hours: Float? = null,
+    val symptoms: List<String>? = null,
+    val medications: List<String>? = null,
+    val notes: String? = null
+)
+
+/**
+ * Модель для статистики цикла
+ */
+data class CycleStatistics(
+    val average_cycle_length: Float,
+    val cycle_length_variation: Float,
+    val average_period_length: Float,
+    val cycle_regularity: Int,
+    val cycle_history: List<CycleHistoryItem>
+)
+
+/**
+ * Элемент истории циклов для отображения графика
+ */
+data class CycleHistoryItem(
+    val start_date: LocalDate,
+    val end_date: LocalDate,
+    val cycle_length: Int,
+    val period_length: Int
+)
+
+/**
+ * Модель для прогноза цикла
+ */
+data class CyclePrediction(
+    val next_period_start: LocalDate,
+    val next_period_end: LocalDate,
+    val next_ovulation: LocalDate,
+    val fertile_window_start: LocalDate,
+    val fertile_window_end: LocalDate,
+    val confidence: Float = 0.85f
+)
diff --git a/app/src/main/java/com/example/womansafe/data/model/calendar/CalendarEntry.kt b/app/src/main/java/com/example/womansafe/data/model/calendar/CalendarEntry.kt
new file mode 100644
index 0000000..e7207d4
--- /dev/null
+++ b/app/src/main/java/com/example/womansafe/data/model/calendar/CalendarEntry.kt
@@ -0,0 +1,26 @@
+package com.example.womansafe.data.model.calendar
+
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import java.time.LocalDate
+
+@Entity(tableName = "calendar_entries")
+data class CalendarEntry(
+    @PrimaryKey(autoGenerate = true)
+    val id: Long = 0,
+    val userId: String,
+    val entryDate: LocalDate,
+    val entryType: EntryType,
+    val flowIntensity: FlowIntensity? = null,
+    val periodSymptoms: List<Symptom>? = null,
+    val mood: Mood? = null,
+    val energyLevel: Int? = null, // 1-5
+    val sleepHours: Float? = null,
+    val symptoms: List<Symptom>? = null,
+    val medications: List<String>? = null,
+    val notes: String? = null,
+    val isPredicted: Boolean = false,
+    val confidenceScore: Int? = null, // 1-100
+    val syncTimestamp: Long = System.currentTimeMillis(),
+    val entryId: Long
+)
diff --git a/app/src/main/java/com/example/womansafe/data/model/calendar/CalendarEntryRequest.kt b/app/src/main/java/com/example/womansafe/data/model/calendar/CalendarEntryRequest.kt
new file mode 100644
index 0000000..137338f
--- /dev/null
+++ b/app/src/main/java/com/example/womansafe/data/model/calendar/CalendarEntryRequest.kt
@@ -0,0 +1,17 @@
+package com.example.womansafe.data.model.calendar
+
+/**
+ * Запрос на создание/обновление записи календаря
+ */
+data class CalendarEntryRequest(
+    val entry_date: String,
+    val entry_type: String,
+    val flow_intensity: String? = null,
+    val mood: String? = null,
+    val symptoms: List<String>? = null,
+    val period_symptoms: List<String>? = null,
+    val medications: List<String>? = null,
+    val notes: String? = null,
+    val energy_level: Int? = null,
+    val sleep_hours: Float? = null
+)
diff --git a/app/src/main/java/com/example/womansafe/data/model/calendar/CalendarEvent.kt b/app/src/main/java/com/example/womansafe/data/model/calendar/CalendarEvent.kt
new file mode 100644
index 0000000..f2f25b6
--- /dev/null
+++ b/app/src/main/java/com/example/womansafe/data/model/calendar/CalendarEvent.kt
@@ -0,0 +1,26 @@
+package com.example.womansafe.data.model.calendar
+
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import java.time.LocalDate
+
+/**
+ * Модель события календаря, используемая в улучшенном календарном интерфейсе
+ */
+@Entity(tableName = "calendar_events")
+data class CalendarEvent(
+    @PrimaryKey
+    val id: String,
+    val userId: String,
+    val date: LocalDate,
+    val type: String, // period, ovulation, symptoms, medication, note, appointment
+    val flowIntensity: String? = null,
+    val mood: String? = null,
+    val energyLevel: Int? = null,
+    val sleepHours: Float? = null,
+    val symptoms: List<String>? = null,
+    val medications: List<String>? = null,
+    val notes: String? = null,
+    val isDismissed: Boolean = false,
+    val syncTimestamp: Long = System.currentTimeMillis()
+)
diff --git a/app/src/main/java/com/example/womansafe/data/model/calendar/ConfidenceLevel.kt b/app/src/main/java/com/example/womansafe/data/model/calendar/ConfidenceLevel.kt
new file mode 100644
index 0000000..952ae62
--- /dev/null
+++ b/app/src/main/java/com/example/womansafe/data/model/calendar/ConfidenceLevel.kt
@@ -0,0 +1,10 @@
+package com.example.womansafe.data.model.calendar
+
+/**
+ * Уровень уверенности в прогнозе или инсайте
+ */
+enum class ConfidenceLevel {
+    LOW,       // Низкая уверенность
+    MEDIUM,    // Средняя уверенность
+    HIGH       // Высокая уверенность
+}
diff --git a/app/src/main/java/com/example/womansafe/data/model/calendar/CycleData.kt b/app/src/main/java/com/example/womansafe/data/model/calendar/CycleData.kt
new file mode 100644
index 0000000..3ef9c53
--- /dev/null
+++ b/app/src/main/java/com/example/womansafe/data/model/calendar/CycleData.kt
@@ -0,0 +1,29 @@
+package com.example.womansafe.data.model.calendar
+
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import java.time.LocalDate
+
+/**
+ * Данные о текущем менструальном цикле
+ */
+@Entity(tableName = "cycle_data")
+data class CycleData(
+    @PrimaryKey
+    val userId: String,
+    val periodStart: LocalDate?,
+    val periodEnd: LocalDate?,
+    val ovulationDate: LocalDate?,
+    val fertileWindowStart: LocalDate?,
+    val fertileWindowEnd: LocalDate?,
+    val cycleLength: Int = 28,
+    val periodLength: Int = 5,
+    val nextPeriodPredicted: LocalDate? = null,
+    val lastUpdated: Long = System.currentTimeMillis(),
+    // Добавленные поля для совместимости с кодом
+    val lastPeriodStartDate: LocalDate? = periodStart,
+    val averageCycleLength: Int = cycleLength,
+    val averagePeriodLength: Int = periodLength,
+    val regularityScore: Int = 0, // 0-100
+    val cycleStartDate: LocalDate? = null
+)
diff --git a/app/src/main/java/com/example/womansafe/data/model/calendar/CyclePrediction.kt b/app/src/main/java/com/example/womansafe/data/model/calendar/CyclePrediction.kt
new file mode 100644
index 0000000..151129c
--- /dev/null
+++ b/app/src/main/java/com/example/womansafe/data/model/calendar/CyclePrediction.kt
@@ -0,0 +1,17 @@
+package com.example.womansafe.data.model.calendar
+
+import java.time.LocalDate
+
+/**
+ * Модель прогноза менструального цикла
+ */
+data class CyclePrediction(
+    val userId: String,
+    val nextPeriodStart: LocalDate,
+    val nextPeriodEnd: LocalDate,
+    val nextOvulation: LocalDate,
+    val fertileWindowStart: LocalDate,
+    val fertileWindowEnd: LocalDate,
+    val confidenceScore: Int, // 1-100
+    val createdAt: Long = System.currentTimeMillis()
+)
diff --git a/app/src/main/java/com/example/womansafe/data/model/calendar/CycleStatistics.kt b/app/src/main/java/com/example/womansafe/data/model/calendar/CycleStatistics.kt
new file mode 100644
index 0000000..f42485b
--- /dev/null
+++ b/app/src/main/java/com/example/womansafe/data/model/calendar/CycleStatistics.kt
@@ -0,0 +1,16 @@
+package com.example.womansafe.data.model.calendar
+
+/**
+ * Модель статистики менструального цикла
+ */
+data class CycleStatistics(
+    val userId: String,
+    val averageCycleLength: Int,
+    val averagePeriodLength: Int,
+    val shortestCycle: Int,
+    val longestCycle: Int,
+    val cycleLengthVariation: Int,
+    val regularityScore: Int, // 1-100
+    val dataPointsCount: Int,
+    val lastUpdated: Long = System.currentTimeMillis()
+)
diff --git a/app/src/main/java/com/example/womansafe/data/model/calendar/EntryType.kt b/app/src/main/java/com/example/womansafe/data/model/calendar/EntryType.kt
new file mode 100644
index 0000000..2b38823
--- /dev/null
+++ b/app/src/main/java/com/example/womansafe/data/model/calendar/EntryType.kt
@@ -0,0 +1,13 @@
+package com.example.womansafe.data.model.calendar
+
+/**
+ * Типы записей в календаре женского здоровья
+ */
+enum class EntryType {
+    PERIOD,        // Менструация
+    OVULATION,     // Овуляция
+    SYMPTOMS,      // Симптомы
+    MEDICATION,    // Лекарства
+    NOTE,          // Заметка
+    APPOINTMENT    // Приём у врача
+}
diff --git a/app/src/main/java/com/example/womansafe/data/model/calendar/FlowIntensity.kt b/app/src/main/java/com/example/womansafe/data/model/calendar/FlowIntensity.kt
new file mode 100644
index 0000000..b9a69f4
--- /dev/null
+++ b/app/src/main/java/com/example/womansafe/data/model/calendar/FlowIntensity.kt
@@ -0,0 +1,12 @@
+package com.example.womansafe.data.model.calendar
+
+/**
+ * Интенсивность менструального кровотечения
+ */
+enum class FlowIntensity {
+    SPOTTING,       // Мажущие выделения
+    LIGHT,          // Легкие
+    MEDIUM,         // Средние
+    HEAVY,          // Сильные
+    VERY_HEAVY      // Очень сильные
+}
diff --git a/app/src/main/java/com/example/womansafe/data/model/calendar/HealthInsight.kt b/app/src/main/java/com/example/womansafe/data/model/calendar/HealthInsight.kt
new file mode 100644
index 0000000..9610237
--- /dev/null
+++ b/app/src/main/java/com/example/womansafe/data/model/calendar/HealthInsight.kt
@@ -0,0 +1,22 @@
+package com.example.womansafe.data.model.calendar
+
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+
+/**
+ * Модель медицинских инсайтов на основе данных календаря
+ */
+@Entity(tableName = "health_insights")
+data class HealthInsight(
+    @PrimaryKey
+    val id: Long,
+    val userId: String,
+    val insightType: InsightType,
+    val title: String,
+    val description: String,
+    val confidenceLevel: ConfidenceLevel,
+    val recommendation: String,
+    val dataPointsUsed: Int,
+    val isDismissed: Boolean = false,
+    val createdAt: Long = System.currentTimeMillis()
+)
diff --git a/app/src/main/java/com/example/womansafe/data/model/calendar/InsightType.kt b/app/src/main/java/com/example/womansafe/data/model/calendar/InsightType.kt
new file mode 100644
index 0000000..ffbd4b8
--- /dev/null
+++ b/app/src/main/java/com/example/womansafe/data/model/calendar/InsightType.kt
@@ -0,0 +1,17 @@
+package com.example.womansafe.data.model.calendar
+
+/**
+ * Типы инсайтов о женском здоровье
+ */
+enum class InsightType {
+    CYCLE_REGULARITY,      // Регулярность цикла
+    PERIOD_LENGTH,         // Продолжительность менструации
+    SYMPTOM_PATTERN,       // Закономерности в симптомах
+    LIFESTYLE_IMPACT,      // Влияние образа жизни
+    MEDICATION_EFFECTIVENESS, // Эффективность лекарств
+    MOOD_CORRELATION,      // Корреляции настроения
+    PERIOD_PREDICTION,     // Прогноз менструации
+    HEALTH_TIP,            // Совет по здоровью
+    MEDICATION_REMINDER,   // Напоминание о приеме лекарств
+    EXERCISE_SUGGESTION    // Рекомендации по физическим упражнениям
+}
diff --git a/app/src/main/java/com/example/womansafe/data/model/calendar/Mood.kt b/app/src/main/java/com/example/womansafe/data/model/calendar/Mood.kt
new file mode 100644
index 0000000..7ba4ff0
--- /dev/null
+++ b/app/src/main/java/com/example/womansafe/data/model/calendar/Mood.kt
@@ -0,0 +1,20 @@
+package com.example.womansafe.data.model.calendar
+
+/**
+ * Расширенный набор настроений для дополненного календаря
+ */
+enum class Mood {
+    VERY_HAPPY,    // Очень счастливое
+    HAPPY,         // Счастливое
+    NEUTRAL,       // Нейтральное
+    NORMAL,        // Обычное (для совместимости)
+    SAD,           // Грустное
+    VERY_SAD,      // Очень грустное
+    ANXIOUS,       // Тревожное
+    IRRITATED,     // Раздраженное (для совместимости)
+    IRRITABLE,     // Раздражительное
+    SENSITIVE,     // Чувствительное
+    CALM,          // Спокойное
+    ENERGETIC,     // Энергичное
+    TIRED          // Усталое
+}
diff --git a/app/src/main/java/com/example/womansafe/data/model/calendar/SkinCondition.kt b/app/src/main/java/com/example/womansafe/data/model/calendar/SkinCondition.kt
new file mode 100644
index 0000000..28568e3
--- /dev/null
+++ b/app/src/main/java/com/example/womansafe/data/model/calendar/SkinCondition.kt
@@ -0,0 +1,14 @@
+package com.example.womansafe.data.model.calendar
+
+/**
+ * Состояние кожи в менструальном календаре
+ */
+enum class SkinCondition {
+    NORMAL,      // Нормальное состояние кожи
+    IRRITATED,   // Раздраженная кожа
+    SENSITIVE,   // Чувствительная кожа
+    DRY,         // Сухая кожа
+    OILY,        // Жирная кожа
+    ACNE,        // Высыпания/акне
+    REDNESS      // Покраснения
+}
diff --git a/app/src/main/java/com/example/womansafe/data/model/calendar/Symptom.kt b/app/src/main/java/com/example/womansafe/data/model/calendar/Symptom.kt
new file mode 100644
index 0000000..972d9f3
--- /dev/null
+++ b/app/src/main/java/com/example/womansafe/data/model/calendar/Symptom.kt
@@ -0,0 +1,23 @@
+package com.example.womansafe.data.model.calendar
+
+/**
+ * Расширенный набор симптомов для женского здоровья
+ */
+enum class Symptom {
+    CRAMPS,             // Спазмы/боли
+    HEADACHE,           // Головная боль
+    BACKACHE,           // Боли в спине
+    NAUSEA,             // Тошнота
+    FATIGUE,            // Усталость
+    BLOATING,           // Вздутие
+    BREAST_TENDERNESS,  // Чувствительность груди
+    ACNE,               // Высыпания
+    MOOD_SWINGS,        // Перепады настроения
+    CRAVINGS,           // Тяга к еде
+    INSOMNIA,           // Бессонница
+    DIZZINESS,          // Головокружение
+    CONSTIPATION,       // Запоры
+    DIARRHEA,           // Диарея
+    HOT_FLASHES,        // Приливы
+    SPOTTING            // Мажущие выделения
+}
diff --git a/app/src/main/java/com/example/womansafe/data/network/NetworkClient.kt b/app/src/main/java/com/example/womansafe/data/network/NetworkClient.kt
index 6247777..af7805c 100644
--- a/app/src/main/java/com/example/womansafe/data/network/NetworkClient.kt
+++ b/app/src/main/java/com/example/womansafe/data/network/NetworkClient.kt
@@ -1,6 +1,8 @@
 package com.example.womansafe.data.network
 
+import android.content.Context
 import com.example.womansafe.data.api.WomanSafeApi
+import com.example.womansafe.util.PreferenceManager
 import okhttp3.Interceptor
 import okhttp3.OkHttpClient
 import okhttp3.logging.HttpLoggingInterceptor
@@ -11,6 +13,30 @@ import java.util.concurrent.TimeUnit
 object NetworkClient {
     private var BASE_URL = "http://192.168.0.112:8000/"
     private var authToken: String? = null
+    private lateinit var preferenceManager: PreferenceManager
+
+    // Метод для получения экземпляра клиента Retrofit
+    fun getClient(): Retrofit {
+        return Retrofit.Builder()
+            .baseUrl(BASE_URL)
+            .client(okHttpClient)
+            .addConverterFactory(GsonConverterFactory.create())
+            .build()
+    }
+
+    // Метод для получения ID пользователя из токена
+    fun getUserId(): String? {
+        // Заглушка для метода - в реальном приложении здесь должна быть логика получения ID из токена
+        return "user123"
+    }
+
+    // Инициализация клиента с контекстом приложения
+    fun initialize(context: Context) {
+        preferenceManager = PreferenceManager.getInstance(context)
+        // Загружаем сохраненный токен при инициализации
+        authToken = preferenceManager.getAuthToken()
+        println("NetworkClient initialized with token: ${authToken?.take(10)}...")
+    }
 
     private val authInterceptor = Interceptor { chain ->
         val requestBuilder = chain.request().newBuilder()
@@ -23,7 +49,14 @@ object NetworkClient {
         println("=== API Request Debug ===")
         println("URL: ${request.url}")
         println("Method: ${request.method}")
-        println("Headers: ${request.headers}")
+        print("Headers: ")
+        request.headers.forEach { (name, value) ->
+            if (name.equals("Authorization", ignoreCase = true)) {
+                println("$name: ██")
+            } else {
+                println("$name: $value")
+            }
+        }
 
         val response = chain.proceed(request)
         println("Response Code: ${response.code}")
@@ -56,9 +89,32 @@ object NetworkClient {
 
     fun setAuthToken(token: String?) {
         authToken = token
+        if (::preferenceManager.isInitialized) {
+            preferenceManager.saveAuthToken(token)
+            println("Token saved to preferences: ${token?.take(10)}...")
+        }
     }
 
+    fun clearAuthToken() {
+        authToken = null
+        if (::preferenceManager.isInitialized) {
+            preferenceManager.clearAuthData()
+            println("Token cleared from preferences")
+        }
+    }
+
+    fun getAuthToken(): String? = authToken
+
     fun updateBaseUrl(newUrl: String) {
         BASE_URL = if (!newUrl.endsWith("/")) "$newUrl/" else newUrl
     }
+
+    private val retrofit: Retrofit = Retrofit.Builder()
+        .baseUrl("https://api.example.com/") // Замените на актуальный URL
+        .addConverterFactory(GsonConverterFactory.create())
+        .build()
+
+    fun <T> createService(serviceClass: Class<T>): T {
+        return retrofit.create(serviceClass)
+    }
 }
diff --git a/app/src/main/java/com/example/womansafe/data/repository/ApiRepository.kt b/app/src/main/java/com/example/womansafe/data/repository/ApiRepository.kt
index 5425b0a..a20df5e 100644
--- a/app/src/main/java/com/example/womansafe/data/repository/ApiRepository.kt
+++ b/app/src/main/java/com/example/womansafe/data/repository/ApiRepository.kt
@@ -1,6 +1,7 @@
 package com.example.womansafe.data.repository
 
 import com.example.womansafe.data.model.*
+import com.example.womansafe.data.model.calendar.CalendarEntry
 import com.example.womansafe.data.network.NetworkClient
 import retrofit2.Response
 
@@ -191,44 +192,57 @@ class ApiRepository {
     }
 
     // Calendar methods
-    suspend fun getCalendarEntries(): Response<CalendarEntriesResponse> {
-        return apiService.getCalendarEntries()
+    suspend fun getCalendarEntries(
+        startDate: String? = null,
+        endDate: String? = null,
+        entryType: String? = null,
+        limit: Int? = null
+    ): Response<List<CalendarEntry>> {
+        // В WomanSafeApi нет метода getCalendarEntries, нужно использовать другой API
+        // Здесь должна быть интеграция с CalendarApi
+        throw NotImplementedError("Method getCalendarEntries not implemented in WomanSafeApi")
     }
 
-    suspend fun createCalendarEntry(entry: CalendarEntryCreate): Response<CalendarEvent> {
-        return apiService.createCalendarEntry(entry)
+    suspend fun createCalendarEntry(entry: CalendarEntry): Response<CalendarEntry> {
+        // В WomanSafeApi нет метода createCalendarEntry, нужно использовать другой API
+        // Здесь должна быть интеграция с CalendarApi
+        throw NotImplementedError("Method createCalendarEntry not implemented in WomanSafeApi")
     }
 
-    suspend fun updateCalendarEntry(id: String, entry: CalendarEntryUpdate): Response<CalendarEvent> {
-        return apiService.updateCalendarEntry(id, entry)
+    suspend fun updateCalendarEntry(id: String, entry: CalendarEntry): Response<CalendarEntry> {
+        // В WomanSafeApi нет метода updateCalendarEntry, нужно использовать другой API
+        // Здесь должна быть интеграция с CalendarApi
+        throw NotImplementedError("Method updateCalendarEntry not implemented in WomanSafeApi")
     }
 
-    suspend fun deleteCalendarEntry(id: String): Response<Any> {
-        return apiService.deleteCalendarEntry(id)
+    suspend fun deleteCalendarEntry(id: String): Response<Unit> {
+        // В WomanSafeApi нет метода deleteCalendarEntry, нужно использовать другой API
+        // Здесь должна быть интеграция с CalendarApi
+        throw NotImplementedError("Method deleteCalendarEntry not implemented in WomanSafeApi")
     }
 
     suspend fun getCycleOverview(): Response<Any> {
-        return apiService.getCycleOverview()
+        return apiService.getHealth() // Временная заглушка
     }
 
     suspend fun getCalendarInsights(): Response<Any> {
-        return apiService.getCalendarInsights()
+        return apiService.getHealth() // Временная заглушка
     }
 
     suspend fun getCalendarReminders(): Response<Any> {
-        return apiService.getCalendarReminders()
+        return apiService.getHealth() // Временная заглушка
     }
 
     suspend fun createCalendarReminder(): Response<Any> {
-        return apiService.createCalendarReminder()
+        return apiService.getHealth() // Временная заглушка
     }
 
     suspend fun getCalendarSettings(): Response<Any> {
-        return apiService.getCalendarSettings()
+        return apiService.getHealth() // Временная заглушка
     }
 
     suspend fun updateCalendarSettings(): Response<Any> {
-        return apiService.updateCalendarSettings()
+        return apiService.getHealth() // Временная заглушка
     }
 
     // Notification methods
diff --git a/app/src/main/java/com/example/womansafe/data/repository/CalendarRepository.kt b/app/src/main/java/com/example/womansafe/data/repository/CalendarRepository.kt
new file mode 100644
index 0000000..07dd15a
--- /dev/null
+++ b/app/src/main/java/com/example/womansafe/data/repository/CalendarRepository.kt
@@ -0,0 +1,298 @@
+package com.example.womansafe.data.repository
+
+import android.util.Log
+import com.example.womansafe.data.api.CalendarApi
+import com.example.womansafe.data.local.CalendarDao
+import com.example.womansafe.data.model.calendar.CalendarEntry
+import com.example.womansafe.data.model.calendar.CycleData
+import com.example.womansafe.data.model.calendar.HealthInsight
+import retrofit2.Response
+import com.example.womansafe.data.model.calendar.CycleStatistics
+import com.example.womansafe.data.model.calendar.CyclePrediction
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.withContext
+import java.time.LocalDate
+import java.time.format.DateTimeFormatter
+
+/**
+ * Репозиторий для работы с данными менструального календаря
+ */
+class CalendarRepository(
+    private val calendarDao: CalendarDao,
+    private val calendarApi: CalendarApi
+) {
+    private val TAG = "CalendarRepository"
+    private val dateFormatter = DateTimeFormatter.ISO_LOCAL_DATE
+
+    // CycleData operations
+    fun getCycleDataFlow(userId: String): Flow<CycleData?> {
+        return calendarDao.getCycleDataFlowByUserId(userId)
+    }
+
+    suspend fun refreshCycleData(userId: String) {
+        withContext(Dispatchers.IO) {
+            try {
+                val response = calendarApi.getCycleData()
+                if (response.isSuccessful) {
+                    response.body()?.let { cycleData ->
+                        calendarDao.insertCycleData(cycleData)
+                        Log.d(TAG, "Cycle data refreshed from server")
+                    }
+                } else {
+                    Log.e(TAG, "Failed to refresh cycle data: ${response.code()}")
+                }
+            } catch (e: Exception) {
+                Log.e(TAG, "Error refreshing cycle data", e)
+            }
+        }
+    }
+
+    suspend fun updateCycleData(cycleData: CycleData): Result<CycleData> {
+        return withContext(Dispatchers.IO) {
+            try {
+                val response = calendarApi.updateCycleData(cycleData)
+                if (response.isSuccessful) {
+                    response.body()?.let { updatedData ->
+                        calendarDao.insertCycleData(updatedData)
+                        Result.success(updatedData)
+                    } ?: Result.failure(Exception("Empty response body"))
+                } else {
+                    // Сохраняем данные локально даже при ошибке сети
+                    calendarDao.insertCycleData(cycleData)
+                    Result.failure(Exception("API error: ${response.code()}"))
+                }
+            } catch (e: Exception) {
+                // При ошибке сети сохраняем данные локально
+                calendarDao.insertCycleData(cycleData)
+                Log.e(TAG, "Error updating cycle data", e)
+                Result.failure(e)
+            }
+        }
+    }
+
+    // CalendarEntry operations
+    fun getCalendarEntriesFlow(userId: String): Flow<List<CalendarEntry>> {
+        return calendarDao.getAllCalendarEntriesFlow(userId)
+    }
+
+    fun getCalendarEntriesBetweenDatesFlow(
+        userId: String,
+        startDate: LocalDate,
+        endDate: LocalDate
+    ): Flow<List<CalendarEntry>> {
+        return calendarDao.getCalendarEntriesBetweenDatesFlow(userId, startDate, endDate)
+    }
+
+    suspend fun refreshCalendarEntries(
+        userId: String,
+        startDate: LocalDate? = null,
+        endDate: LocalDate? = null
+    ) {
+        withContext(Dispatchers.IO) {
+            try {
+                val response = calendarApi.getCalendarEntries(
+                    startDate?.format(dateFormatter),
+                    endDate?.format(dateFormatter)
+                )
+                if (response.isSuccessful) {
+                    response.body()?.let { entries ->
+                        calendarDao.insertCalendarEntries(entries)
+                        Log.d(TAG, "Calendar entries refreshed from server: ${entries.size}")
+                    }
+                } else {
+                    Log.e(TAG, "Failed to refresh calendar entries: ${response.code()}")
+                }
+            } catch (e: Exception) {
+                Log.e(TAG, "Error refreshing calendar entries", e)
+            }
+        }
+    }
+
+    suspend fun getCalendarEntryByDate(userId: String, date: LocalDate): CalendarEntry? {
+        return calendarDao.getCalendarEntryByDate(userId, date)
+    }
+
+    suspend fun addCalendarEntry(entry: CalendarEntry): Result<CalendarEntry> {
+        return withContext(Dispatchers.IO) {
+            try {
+                val response = calendarApi.addCalendarEntry(entry)
+                if (response.isSuccessful) {
+                    response.body()?.let { serverEntry ->
+                        calendarDao.insertCalendarEntry(serverEntry)
+                        Result.success(serverEntry)
+                    } ?: Result.failure(Exception("Empty response body"))
+                } else {
+                    // Сохраняем данные локально даже при ошибке сети
+                    val localId = calendarDao.insertCalendarEntry(entry)
+                    Result.failure(Exception("API error: ${response.code()}"))
+                }
+            } catch (e: Exception) {
+                // При ошибке сети сохраняем данные локально
+                val localId = calendarDao.insertCalendarEntry(entry)
+                Log.e(TAG, "Error adding calendar entry", e)
+                Result.failure(e)
+            }
+        }
+    }
+
+    suspend fun updateCalendarEntry(entry: CalendarEntry): Result<CalendarEntry> {
+        return withContext(Dispatchers.IO) {
+            try {
+                val response = calendarApi.updateCalendarEntry(entry.id, entry)
+                if (response.isSuccessful) {
+                    response.body()?.let { updatedEntry ->
+                        calendarDao.updateCalendarEntry(updatedEntry)
+                        Result.success(updatedEntry)
+                    } ?: Result.failure(Exception("Empty response body"))
+                } else {
+                    // Обновляем данные локально даже при ошибке сети
+                    calendarDao.updateCalendarEntry(entry)
+                    Result.failure(Exception("API error: ${response.code()}"))
+                }
+            } catch (e: Exception) {
+                // При ошибке сети обновляем данные локально
+                calendarDao.updateCalendarEntry(entry)
+                Log.e(TAG, "Error updating calendar entry", e)
+                Result.failure(e)
+            }
+        }
+    }
+
+    suspend fun deleteCalendarEntry(entryId: Long): Result<Unit> {
+        return withContext(Dispatchers.IO) {
+            try {
+                val entry = calendarDao.getCalendarEntryById(entryId)
+                if (entry == null) {
+                    return@withContext Result.failure(Exception("Entry not found"))
+                }
+
+                val response = calendarApi.deleteCalendarEntry(entryId)
+                if (response.isSuccessful) {
+                    calendarDao.deleteCalendarEntry(entry)
+                    Result.success(Unit)
+                } else {
+                    Result.failure(Exception("API error: ${response.code()}"))
+                }
+            } catch (e: Exception) {
+                Log.e(TAG, "Error deleting calendar entry", e)
+                Result.failure(e)
+            }
+        }
+    }
+
+    // HealthInsight operations
+    fun getActiveHealthInsightsFlow(userId: String): Flow<List<HealthInsight>> {
+        return calendarDao.getActiveHealthInsightsFlow(userId)
+    }
+
+    fun getAllHealthInsightsFlow(userId: String): Flow<List<HealthInsight>> {
+        return calendarDao.getAllHealthInsightsFlow(userId)
+    }
+
+    suspend fun refreshHealthInsights(userId: String) {
+        withContext(Dispatchers.IO) {
+            try {
+                val response = calendarApi.getHealthInsights()
+                if (response.isSuccessful) {
+                    response.body()?.let { insights ->
+                        calendarDao.insertHealthInsights(insights)
+                        Log.d(TAG, "Health insights refreshed from server: ${insights.size}")
+                    }
+                } else {
+                    Log.e(TAG, "Failed to refresh health insights: ${response.code()}")
+                }
+            } catch (e: Exception) {
+                Log.e(TAG, "Error refreshing health insights", e)
+            }
+        }
+    }
+
+    suspend fun dismissInsight(insightId: Long): Result<Unit> {
+        return withContext(Dispatchers.IO) {
+            try {
+                val response = calendarApi.dismissInsight(insightId)
+                if (response.isSuccessful) {
+                    calendarDao.dismissHealthInsight(insightId)
+                    Result.success(Unit)
+                } else {
+                    Result.failure(Exception("API error: ${response.code()}"))
+                }
+            } catch (e: Exception) {
+                Log.e(TAG, "Error dismissing insight", e)
+                Result.failure(e)
+            }
+        }
+    }
+
+    // Заглушка: Получение статистики цикла
+    suspend fun getCycleStatistics(userId: String): Response<CycleStatistics> {
+        val now = System.currentTimeMillis()
+        return Response.success(
+            CycleStatistics(
+                userId = userId,
+                averageCycleLength = 28,
+                averagePeriodLength = 5,
+                shortestCycle = 27,
+                longestCycle = 30,
+                cycleLengthVariation = 3,
+                regularityScore = 90,
+                dataPointsCount = 12,
+                lastUpdated = now
+            )
+        )
+    }
+
+    // Заглушка: Получение прогнозов цикла
+    suspend fun getCyclePredictions(userId: String): Response<CyclePrediction> {
+        val today = java.time.LocalDate.now()
+        return Response.success(
+            CyclePrediction(
+                userId = userId,
+                nextPeriodStart = today.plusDays(10),
+                nextPeriodEnd = today.plusDays(15),
+                nextOvulation = today.plusDays(20),
+                fertileWindowStart = today.plusDays(18),
+                fertileWindowEnd = today.plusDays(22),
+                confidenceScore = 85,
+                createdAt = System.currentTimeMillis()
+            )
+        )
+    }
+
+    // Заглушка: Получение кэшированных прогнозов
+    fun getCachedPredictions(userId: String): CyclePrediction {
+        val today = java.time.LocalDate.now()
+        return CyclePrediction(
+            userId = userId,
+            nextPeriodStart = today.plusDays(10),
+            nextPeriodEnd = today.plusDays(15),
+            nextOvulation = today.plusDays(20),
+            fertileWindowStart = today.plusDays(18),
+            fertileWindowEnd = today.plusDays(22),
+            confidenceScore = 80,
+            createdAt = System.currentTimeMillis()
+        )
+    }
+
+    // Заглушка: Получение инсайтов о здоровье
+    suspend fun getHealthInsights(): Response<List<HealthInsight>> {
+        // TODO: Реализовать реальный запрос
+        return Response.success(emptyList())
+    }
+
+    // Clean up operations
+    suspend fun cleanupOldInsights(userId: String, olderThan: Long) {
+        calendarDao.deleteOldInsights(userId, olderThan)
+    }
+
+    suspend fun getCalendarEntries(): List<CalendarEntry> {
+        // Пример: получение из DAO или API
+        return calendarDao.getAllCalendarEntries()
+    }
+
+    suspend fun getCycleData(): CycleData? {
+        // Пример: получение из DAO или API
+        return calendarDao.getLatestCycleData()
+    }
+}
diff --git a/app/src/main/java/com/example/womansafe/ui/components/CalendarEventDetailDialog.kt b/app/src/main/java/com/example/womansafe/ui/components/CalendarEventDetailDialog.kt
new file mode 100644
index 0000000..f1f6097
--- /dev/null
+++ b/app/src/main/java/com/example/womansafe/ui/components/CalendarEventDetailDialog.kt
@@ -0,0 +1,303 @@
+package com.example.womansafe.ui.components
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.*
+import androidx.compose.material3.*
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.window.Dialog
+import com.example.womansafe.data.model.calendar.CalendarEvent
+import com.example.womansafe.utils.DateUtils
+import java.time.format.DateTimeFormatter
+import java.util.*
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun CalendarEventDetailDialog(
+    event: CalendarEvent,
+    onDismiss: () -> Unit,
+    onEdit: (CalendarEvent) -> Unit,
+    onDelete: (CalendarEvent) -> Unit
+) {
+    Dialog(onDismissRequest = onDismiss) {
+        Card(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(16.dp),
+            shape = RoundedCornerShape(16.dp),
+            colors = CardDefaults.cardColors(
+                containerColor = MaterialTheme.colorScheme.surface
+            )
+        ) {
+            Column(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(20.dp)
+                    .verticalScroll(rememberScrollState())
+            ) {
+                // Заголовок с датой
+                Row(
+                    modifier = Modifier.fillMaxWidth(),
+                    verticalAlignment = Alignment.CenterVertically
+                ) {
+                    // Иконка типа события
+                    Box(
+                        modifier = Modifier
+                            .size(56.dp)
+                            .clip(CircleShape)
+                            .background(getEventIconBackgroundColor(event.type)),
+                        contentAlignment = Alignment.Center
+                    ) {
+                        Icon(
+                            imageVector = getEventIcon(event.type),
+                            contentDescription = null,
+                            tint = Color.White,
+                            modifier = Modifier.size(32.dp)
+                        )
+                    }
+
+                    Spacer(modifier = Modifier.width(16.dp))
+
+                    Column {
+                        Text(
+                            text = getEventTitle(event.type),
+                            style = MaterialTheme.typography.titleLarge,
+                            fontWeight = FontWeight.Bold
+                        )
+
+                        Text(
+                            text = event.date.format(DateTimeFormatter.ofPattern("d MMMM yyyy", Locale("ru"))),
+                            style = MaterialTheme.typography.bodyMedium,
+                            color = MaterialTheme.colorScheme.onSurfaceVariant
+                        )
+                    }
+                }
+
+                Divider(modifier = Modifier.padding(vertical = 16.dp))
+
+                // Детали события
+                event.flowIntensity?.let {
+                    DetailItem(
+                        title = "Интенсивность",
+                        value = getFlowIntensityLabel(it),
+                        icon = Icons.Default.Opacity
+                    )
+                }
+
+                event.mood?.let {
+                    DetailItem(
+                        title = "Настроение",
+                        value = getMoodLabel(it),
+                        icon = Icons.Default.Face
+                    )
+                }
+
+                event.symptoms?.takeIf { it.isNotEmpty() }?.let {
+                    DetailItem(
+                        title = "Симптомы",
+                        value = it.joinToString(", ") { symptom -> getSymptomLabel(symptom) },
+                        icon = Icons.Default.HealthAndSafety
+                    )
+                }
+
+                event.medications?.takeIf { it.isNotEmpty() }?.let {
+                    DetailItem(
+                        title = "Лекарства",
+                        value = it.joinToString(", "),
+                        icon = Icons.Default.Medication
+                    )
+                }
+
+                event.energyLevel?.let {
+                    DetailItem(
+                        title = "Уровень энергии",
+                        value = "$it/5",
+                        icon = Icons.Default.BatteryChargingFull
+                    )
+                }
+
+                event.sleepHours?.let {
+                    DetailItem(
+                        title = "Часы сна",
+                        value = "$it ч",
+                        icon = Icons.Default.Bedtime
+                    )
+                }
+
+                event.notes?.takeIf { it.isNotBlank() }?.let {
+                    DetailItem(
+                        title = "Заметки",
+                        value = it,
+                        icon = Icons.Default.Notes,
+                        maxLines = 5
+                    )
+                }
+
+                Spacer(modifier = Modifier.height(24.dp))
+
+                // Кнопки действий
+                Row(
+                    modifier = Modifier.fillMaxWidth(),
+                    horizontalArrangement = Arrangement.End
+                ) {
+                    TextButton(onClick = onDismiss) {
+                        Text("Закрыть")
+                    }
+
+                    TextButton(onClick = { onEdit(event) }) {
+                        Text("Редактировать")
+                    }
+
+                    TextButton(
+                        onClick = { onDelete(event) },
+                        colors = ButtonDefaults.textButtonColors(
+                            contentColor = MaterialTheme.colorScheme.error
+                        )
+                    ) {
+                        Text("Удалить")
+                    }
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun DetailItem(
+    title: String,
+    value: String,
+    icon: androidx.compose.ui.graphics.vector.ImageVector,
+    maxLines: Int = 2
+) {
+    Row(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(vertical = 8.dp),
+        verticalAlignment = Alignment.Top
+    ) {
+        Icon(
+            imageVector = icon,
+            contentDescription = null,
+            tint = MaterialTheme.colorScheme.primary,
+            modifier = Modifier
+                .padding(end = 16.dp, top = 2.dp)
+                .size(24.dp)
+        )
+
+        Column {
+            Text(
+                text = title,
+                style = MaterialTheme.typography.labelMedium,
+                color = MaterialTheme.colorScheme.onSurfaceVariant
+            )
+
+            Text(
+                text = value,
+                style = MaterialTheme.typography.bodyMedium,
+                maxLines = maxLines,
+                overflow = TextOverflow.Ellipsis
+            )
+        }
+    }
+}
+
+// Вспомогательные функции для получения информации о событии
+private fun getEventIcon(type: String): androidx.compose.ui.graphics.vector.ImageVector {
+    return when (type.lowercase()) {
+        "period" -> Icons.Default.Opacity
+        "ovulation" -> Icons.Default.Star
+        "symptoms" -> Icons.Default.Healing
+        "medication" -> Icons.Default.LocalPharmacy
+        "note" -> Icons.Default.Notes
+        "appointment" -> Icons.Default.Event
+        else -> Icons.Default.Check
+    }
+}
+
+private fun getEventIconBackgroundColor(type: String): Color {
+    return when (type.lowercase()) {
+        "period" -> Color(0xFFE91E63) // Розовый
+        "ovulation" -> Color(0xFF2196F3) // Голубой
+        "symptoms" -> Color(0xFFFFC107) // Желтый
+        "medication" -> Color(0xFF9C27B0) // Фиолетовый
+        "note" -> Color(0xFF607D8B) // Серо-синий
+        "appointment" -> Color(0xFF4CAF50) // Зеленый
+        else -> Color.Gray
+    }
+}
+
+private fun getEventTitle(type: String): String {
+    return when (type.lowercase()) {
+        "period" -> "Менструация"
+        "ovulation" -> "Овуляция"
+        "symptoms" -> "Симптомы"
+        "medication" -> "Лекарства"
+        "note" -> "Заметка"
+        "appointment" -> "Приём врача"
+        else -> type.replaceFirstChar { if (it.isLowerCase()) it.titlecase(Locale.getDefault()) else it.toString() }
+    }
+}
+
+private fun getFlowIntensityLabel(intensity: String): String {
+    return when (intensity.uppercase()) {
+        "SPOTTING" -> "Мажущие"
+        "LIGHT" -> "Легкие"
+        "MEDIUM" -> "Средние"
+        "HEAVY" -> "Сильные"
+        "VERY_HEAVY" -> "Очень сильные"
+        else -> intensity
+    }
+}
+
+private fun getMoodLabel(mood: String): String {
+    return when (mood.uppercase()) {
+        "VERY_HAPPY" -> "Отлично"
+        "HAPPY" -> "Хорошо"
+        "NEUTRAL" -> "Нормально"
+        "NORMAL" -> "Нормально"
+        "SAD" -> "Грустно"
+        "VERY_SAD" -> "Очень грустно"
+        "ANXIOUS" -> "Тревожно"
+        "IRRITATED" -> "Раздражение"
+        "IRRITABLE" -> "Раздражительность"
+        "SENSITIVE" -> "Чувствительность"
+        "CALM" -> "Спокойно"
+        "ENERGETIC" -> "Энергично"
+        "TIRED" -> "Устало"
+        else -> mood
+    }
+}
+
+private fun getSymptomLabel(symptom: String): String {
+    return when (symptom.uppercase()) {
+        "CRAMPS" -> "Спазмы"
+        "HEADACHE" -> "Головная боль"
+        "BACKACHE" -> "Боль в спине"
+        "NAUSEA" -> "Тошнота"
+        "FATIGUE" -> "Усталость"
+        "BLOATING" -> "Вздутие"
+        "BREAST_TENDERNESS" -> "Болезненность груди"
+        "ACNE" -> "Высыпания"
+        "MOOD_SWINGS" -> "Перепады настроения"
+        "CRAVINGS" -> "Тяга к еде"
+        "INSOMNIA" -> "Бессонница"
+        "DIZZINESS" -> "Головокружение"
+        "CONSTIPATION" -> "Запор"
+        "DIARRHEA" -> "Диарея"
+        "HOT_FLASHES" -> "Приливы"
+        "SPOTTING" -> "Мажущие выделения"
+        else -> symptom
+    }
+}
diff --git a/app/src/main/java/com/example/womansafe/ui/icons/CustomIcons.kt b/app/src/main/java/com/example/womansafe/ui/icons/CustomIcons.kt
new file mode 100644
index 0000000..2655969
--- /dev/null
+++ b/app/src/main/java/com/example/womansafe/ui/icons/CustomIcons.kt
@@ -0,0 +1,38 @@
+package com.example.womansafe.ui.icons
+
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Create
+import androidx.compose.material.icons.filled.Spa
+import androidx.compose.material.icons.filled.WaterDrop
+import androidx.compose.material.icons.outlined.Description
+import androidx.compose.material.icons.outlined.LocalHospital
+import androidx.compose.material.icons.outlined.Opacity
+import androidx.compose.material.icons.rounded.BarChart
+import androidx.compose.material.icons.rounded.CalendarMonth
+import androidx.compose.material.icons.rounded.Event
+import androidx.compose.material.icons.rounded.Lightbulb
+import androidx.compose.material.icons.rounded.NavigateNext
+import androidx.compose.material.icons.rounded.SentimentDissatisfied
+import androidx.compose.material.icons.rounded.Warning
+import androidx.compose.ui.graphics.vector.ImageVector
+
+/**
+ * Расширенные иконки для использования в приложении
+ */
+object CustomIcons {
+    // Иконки для календаря
+    val Healing: ImageVector = Icons.Outlined.LocalHospital
+    val Notes: ImageVector = Icons.Outlined.Description
+    val WaterDrop: ImageVector = Icons.Default.WaterDrop
+    val Contacts: ImageVector = Icons.Default.Create
+    val BarChart: ImageVector = Icons.Rounded.BarChart
+    val Lightbulb: ImageVector = Icons.Rounded.Lightbulb
+    val CalendarMonth: ImageVector = Icons.Rounded.CalendarMonth
+    val LocalHospital: ImageVector = Icons.Outlined.LocalHospital
+    val Dangerous: ImageVector = Icons.Rounded.Warning
+    val Spa: ImageVector = Icons.Default.Spa
+    val SentimentDissatisfied: ImageVector = Icons.Rounded.SentimentDissatisfied
+    val Opacity: ImageVector = Icons.Outlined.Opacity
+    val Event: ImageVector = Icons.Rounded.Event
+    val ChevronRight: ImageVector = Icons.Rounded.NavigateNext
+}
diff --git a/app/src/main/java/com/example/womansafe/ui/screens/AuthScreen.kt b/app/src/main/java/com/example/womansafe/ui/screens/AuthScreen.kt
index 7249294..decbc9a 100644
--- a/app/src/main/java/com/example/womansafe/ui/screens/AuthScreen.kt
+++ b/app/src/main/java/com/example/womansafe/ui/screens/AuthScreen.kt
@@ -18,6 +18,7 @@ import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
 import com.example.womansafe.data.model.UserResponse
 import com.example.womansafe.ui.viewmodel.AuthViewModel
+import com.example.womansafe.util.fixTouchEvents
 
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
@@ -318,7 +319,8 @@ fun UserProfileScreen(
     LazyColumn(
         modifier = Modifier
             .fillMaxSize()
-            .padding(16.dp),
+            .padding(16.dp)
+            .fixTouchEvents(),
         verticalArrangement = Arrangement.spacedBy(16.dp)
     ) {
         item {
diff --git a/app/src/main/java/com/example/womansafe/ui/screens/CalendarEntryScreen.kt b/app/src/main/java/com/example/womansafe/ui/screens/CalendarEntryScreen.kt
new file mode 100644
index 0000000..1a4f503
--- /dev/null
+++ b/app/src/main/java/com/example/womansafe/ui/screens/CalendarEntryScreen.kt
@@ -0,0 +1,487 @@
+package com.example.womansafe.ui.screens
+
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.lazy.LazyRow
+import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.selection.selectable
+import androidx.compose.foundation.selection.selectableGroup
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.*
+import androidx.compose.material3.*
+import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.semantics.Role
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.foundation.text.KeyboardOptions
+import androidx.compose.ui.text.input.KeyboardType
+import androidx.compose.ui.unit.dp
+import com.example.womansafe.data.model.calendar.*
+import com.example.womansafe.ui.icons.CustomIcons
+import com.example.womansafe.ui.viewmodel.CalendarViewModel
+import java.time.LocalDate
+import java.time.format.DateTimeFormatter
+import java.util.*
+
+/**
+ * Экран для добавления/редактирования записей в календаре
+ */
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun CalendarEntryScreen(
+    viewModel: CalendarViewModel,
+    selectedDate: LocalDate,
+    existingEntry: CalendarEntry? = null,
+    onClose: () -> Unit
+) {
+    // Форматтер для отображения даты
+    val dateFormatter = DateTimeFormatter.ofPattern("d MMMM yyyy", Locale("ru"))
+
+    // Состояние для полей формы
+    var entryType by remember { mutableStateOf(existingEntry?.entryType ?: EntryType.PERIOD) }
+    var flowIntensity by remember { mutableStateOf(existingEntry?.flowIntensity ?: FlowIntensity.MEDIUM) }
+    var mood by remember { mutableStateOf(existingEntry?.mood ?: Mood.NORMAL) }
+    var energyLevel by remember { mutableStateOf(existingEntry?.energyLevel ?: 3) }
+    var sleepHours by remember { mutableStateOf(existingEntry?.sleepHours?.toString() ?: "8.0") }
+    var selectedSymptoms by remember { mutableStateOf(existingEntry?.symptoms?.toMutableList() ?: mutableListOf()) }
+    var medications by remember { mutableStateOf(existingEntry?.medications?.joinToString(", ") ?: "") }
+    var notes by remember { mutableStateOf(existingEntry?.notes ?: "") }
+
+    Scaffold(
+        topBar = {
+            TopAppBar(
+                title = {
+                    Text(
+                        text = if (existingEntry != null) "Редактировать запись" else "Новая запись"
+                    )
+                },
+                navigationIcon = {
+                    IconButton(onClick = onClose) {
+                        Icon(Icons.Default.Close, contentDescription = "Закрыть")
+                    }
+                },
+                actions = {
+                    IconButton(
+                        onClick = {
+                            // Создаем или обновляем запись
+                            val entry = existingEntry?.copy(
+                                entryDate = selectedDate,
+                                entryType = entryType,
+                                flowIntensity = if (entryType == EntryType.PERIOD) flowIntensity else null,
+                                mood = mood,
+                                energyLevel = energyLevel,
+                                sleepHours = sleepHours.toFloatOrNull(),
+                                symptoms = selectedSymptoms,
+                                medications = if (medications.isBlank()) null else medications.split(",").map { it.trim() },
+                                notes = notes.ifBlank { null }
+                            ) ?: CalendarEntry(
+                                userId = "", // будет заменено в репозитории
+                                entryDate = selectedDate,
+                                entryType = entryType,
+                                flowIntensity = if (entryType == EntryType.PERIOD) flowIntensity else null,
+                                mood = mood,
+                                energyLevel = energyLevel,
+                                sleepHours = sleepHours.toFloatOrNull(),
+                                symptoms = if (selectedSymptoms.isEmpty()) null else selectedSymptoms,
+                                medications = if (medications.isBlank()) null else medications.split(",").map { it.trim() },
+                                notes = notes.ifBlank { null },
+                                entryId = existingEntry?.entryId ?: 0L
+                            )
+
+                            if (existingEntry != null) {
+                                viewModel.updateCalendarEntry(entry)
+                            } else {
+                                viewModel.addCalendarEntry(entry)
+                            }
+
+                            onClose()
+                        }
+                    ) {
+                        Icon(Icons.Default.Check, contentDescription = "Сохранить")
+                    }
+                }
+            )
+        }
+    ) { paddingValues ->
+        Column(
+            modifier = Modifier
+                .fillMaxSize()
+                .padding(paddingValues)
+                .padding(horizontal = 16.dp)
+                .verticalScroll(rememberScrollState())
+        ) {
+            // Заголовок с датой
+            Text(
+                text = selectedDate.format(dateFormatter),
+                style = MaterialTheme.typography.titleMedium,
+                fontWeight = FontWeight.Bold,
+                modifier = Modifier.padding(vertical = 16.dp)
+            )
+
+            // Выбор типа записи
+            Text(
+                text = "Тип записи",
+                style = MaterialTheme.typography.titleSmall,
+                fontWeight = FontWeight.Bold
+            )
+
+            EntryTypeSelector(
+                selectedType = entryType,
+                onTypeSelected = { entryType = it }
+            )
+
+            Spacer(modifier = Modifier.height(16.dp))
+
+            // Показываем дополнительные поля в зависимости от типа записи
+            when (entryType) {
+                EntryType.PERIOD -> {
+                    FlowIntensitySelector(
+                        selectedIntensity = flowIntensity,
+                        onIntensitySelected = { flowIntensity = it }
+                    )
+
+                    Spacer(modifier = Modifier.height(16.dp))
+                }
+                else -> { /* Другие поля будут отображаться всегда */ }
+            }
+
+            // Настроение
+            Text(
+                text = "Настроение",
+                style = MaterialTheme.typography.titleSmall,
+                fontWeight = FontWeight.Bold,
+                modifier = Modifier.padding(bottom = 8.dp)
+            )
+
+            MoodSelector(
+                selectedMood = mood,
+                onMoodSelected = { mood = it }
+            )
+
+            Spacer(modifier = Modifier.height(16.dp))
+
+            // Уровень энергии
+            Text(
+                text = "Уровень энергии: $energyLevel",
+                style = MaterialTheme.typography.titleSmall,
+                fontWeight = FontWeight.Bold,
+                modifier = Modifier.padding(bottom = 8.dp)
+            )
+
+            Slider(
+                value = energyLevel.toFloat(),
+                onValueChange = { energyLevel = it.toInt() },
+                valueRange = 1f..5f,
+                steps = 3
+            )
+
+            Spacer(modifier = Modifier.height(16.dp))
+
+            // Часы сна
+            OutlinedTextField(
+                value = sleepHours,
+                onValueChange = { sleepHours = it },
+                label = { Text("Часы сна") },
+                modifier = Modifier.fillMaxWidth(),
+                keyboardOptions = KeyboardOptions(
+                    keyboardType = KeyboardType.Number
+                )
+            )
+
+            Spacer(modifier = Modifier.height(16.dp))
+
+            // Симптомы
+            Text(
+                text = "Симптомы",
+                style = MaterialTheme.typography.titleSmall,
+                fontWeight = FontWeight.Bold,
+                modifier = Modifier.padding(bottom = 8.dp)
+            )
+
+            SymptomsSelector(
+                selectedSymptoms = selectedSymptoms,
+                onSymptomsChanged = { selectedSymptoms = it }
+            )
+
+            Spacer(modifier = Modifier.height(16.dp))
+
+            // Лекарства
+            OutlinedTextField(
+                value = medications,
+                onValueChange = { medications = it },
+                label = { Text("Лекарства (через запятую)") },
+                modifier = Modifier.fillMaxWidth()
+            )
+
+            Spacer(modifier = Modifier.height(16.dp))
+
+            // Заметки
+            OutlinedTextField(
+                value = notes,
+                onValueChange = { notes = it },
+                label = { Text("Заметки") },
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .heightIn(min = 120.dp),
+                maxLines = 5
+            )
+
+            Spacer(modifier = Modifier.height(32.dp))
+
+            // Кнопка удаления (только для существующих записей)
+            existingEntry?.let {
+                OutlinedButton(
+                    onClick = {
+                        viewModel.deleteCalendarEntry(existingEntry.id)
+                        onClose()
+                    },
+                    modifier = Modifier.fillMaxWidth(),
+                    colors = ButtonDefaults.outlinedButtonColors(
+                        contentColor = MaterialTheme.colorScheme.error
+                    )
+                ) {
+                    Icon(
+                        Icons.Default.Delete,
+                        contentDescription = null,
+                        modifier = Modifier.size(18.dp)
+                    )
+                    Spacer(modifier = Modifier.width(8.dp))
+                    Text("Удалить запись")
+                }
+
+                Spacer(modifier = Modifier.height(16.dp))
+            }
+        }
+    }
+}
+
+/**
+ * Селектор типа записи
+ */
+@Composable
+fun EntryTypeSelector(
+    selectedType: EntryType,
+    onTypeSelected: (EntryType) -> Unit
+) {
+    val entryTypes = listOf(
+        EntryType.PERIOD to "Менструация",
+        EntryType.OVULATION to "Овуляция",
+        EntryType.SYMPTOMS to "Симптомы",
+        EntryType.MEDICATION to "Лекарства",
+        EntryType.NOTE to "Заметка"
+    )
+
+    Row(
+        modifier = Modifier
+            .fillMaxWidth()
+            .selectableGroup()
+            .padding(vertical = 8.dp)
+    ) {
+        entryTypes.forEach { (type, label) ->
+            Row(
+                modifier = Modifier
+                    .weight(1f)
+                    .selectable(
+                        selected = type == selectedType,
+                        onClick = { onTypeSelected(type) },
+                        role = Role.RadioButton
+                    )
+                    .padding(4.dp),
+                verticalAlignment = Alignment.CenterVertically,
+                horizontalArrangement = Arrangement.Center
+            ) {
+                RadioButton(
+                    selected = type == selectedType,
+                    onClick = null
+                )
+
+                Text(
+                    text = label,
+                    style = MaterialTheme.typography.bodySmall,
+                    modifier = Modifier.padding(start = 4.dp)
+                )
+            }
+        }
+    }
+}
+
+/**
+ * Селектор интенсивности менструации
+ */
+@Composable
+fun FlowIntensitySelector(
+    selectedIntensity: FlowIntensity,
+    onIntensitySelected: (FlowIntensity) -> Unit
+) {
+    val intensities = listOf(
+        FlowIntensity.LIGHT to "Легкая",
+        FlowIntensity.MEDIUM to "Средняя",
+        FlowIntensity.HEAVY to "Сильная"
+    )
+
+    Column(modifier = Modifier.fillMaxWidth()) {
+        Text(
+            text = "Интенсивность",
+            style = MaterialTheme.typography.titleSmall,
+            fontWeight = FontWeight.Bold,
+            modifier = Modifier.padding(bottom = 8.dp)
+        )
+
+        Row(
+            modifier = Modifier
+                .fillMaxWidth()
+                .selectableGroup()
+                .padding(vertical = 8.dp)
+        ) {
+            intensities.forEach { (intensity, label) ->
+                Row(
+                    modifier = Modifier
+                        .weight(1f)
+                        .selectable(
+                            selected = intensity == selectedIntensity,
+                            onClick = { onIntensitySelected(intensity) },
+                            role = Role.RadioButton
+                        )
+                        .padding(4.dp),
+                    verticalAlignment = Alignment.CenterVertically,
+                    horizontalArrangement = Arrangement.Center
+                ) {
+                    RadioButton(
+                        selected = intensity == selectedIntensity,
+                        onClick = null
+                    )
+
+                    Text(
+                        text = label,
+                        style = MaterialTheme.typography.bodyMedium,
+                        modifier = Modifier.padding(start = 4.dp)
+                    )
+                }
+            }
+        }
+    }
+}
+
+/**
+ * Селектор настроения
+ */
+@Composable
+fun MoodSelector(
+    selectedMood: Mood,
+    onMoodSelected: (Mood) -> Unit
+) {
+    // Создаем список троек (настроение, метка, иконка) вместо использования вложенных Pair
+    val moods = listOf(
+        Triple(Mood.HAPPY, "Счастливое", Icons.Default.Mood),
+        Triple(Mood.NORMAL, "Обычное", Icons.Default.Face),
+        Triple(Mood.SAD, "Грустное", CustomIcons.SentimentDissatisfied),
+        Triple(Mood.IRRITATED, "Раздражение", CustomIcons.Dangerous),
+        Triple(Mood.ANXIOUS, "Тревожное", Icons.Default.Warning),
+        Triple(Mood.SENSITIVE, "Чувствительное", Icons.Default.Favorite),
+        Triple(Mood.CALM, "Спокойное", CustomIcons.Spa)
+    )
+
+    Column(modifier = Modifier.fillMaxWidth()) {
+        LazyRow {
+            items(moods.size) { index ->
+                val (mood, label, icon) = moods[index]
+                Column(
+                    horizontalAlignment = Alignment.CenterHorizontally,
+                    modifier = Modifier
+                        .padding(horizontal = 12.dp)
+                        .selectable(
+                            selected = mood == selectedMood,
+                            onClick = { onMoodSelected(mood) },
+                            role = Role.RadioButton
+                        )
+                ) {
+                    Icon(
+                        imageVector = icon,
+                        contentDescription = label,
+                        modifier = Modifier
+                            .size(48.dp)
+                            .padding(8.dp),
+                        tint = if (mood == selectedMood)
+                            MaterialTheme.colorScheme.primary
+                        else
+                            MaterialTheme.colorScheme.onSurfaceVariant
+                    )
+
+                    Text(
+                        text = label,
+                        style = MaterialTheme.typography.labelSmall,
+                        color = if (mood == selectedMood)
+                            MaterialTheme.colorScheme.primary
+                        else
+                            MaterialTheme.colorScheme.onSurfaceVariant
+                    )
+                }
+            }
+        }
+    }
+}
+
+/**
+ * Селектор симптомов
+ */
+@Composable
+fun SymptomsSelector(
+    selectedSymptoms: List<Symptom>,
+    onSymptomsChanged: (MutableList<Symptom>) -> Unit
+) {
+    val symptoms = listOf(
+        Symptom.CRAMPS to "Спазмы",
+        Symptom.HEADACHE to "Головная боль",
+        Symptom.BLOATING to "Вздутие",
+        Symptom.BACKACHE to "Боль в спине",
+        Symptom.FATIGUE to "Усталость",
+        Symptom.NAUSEA to "Тошнота",
+        Symptom.BREAST_TENDERNESS to "Боль в груди",
+        Symptom.ACNE to "Акне",
+        Symptom.CRAVINGS to "Тяга к еде",
+        Symptom.INSOMNIA to "Бессонница",
+        Symptom.DIZZINESS to "Головокружение",
+        Symptom.DIARRHEA to "Диарея",
+        Symptom.CONSTIPATION to "Запор"
+    )
+
+    Column {
+        symptoms.chunked(2).forEach { row ->
+            Row(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(vertical = 4.dp)
+            ) {
+                row.forEach { (symptom, label) ->
+                    Row(
+                        verticalAlignment = Alignment.CenterVertically,
+                        modifier = Modifier
+                            .weight(1f)
+                            .padding(end = 8.dp)
+                    ) {
+                        Checkbox(
+                            checked = selectedSymptoms.contains(symptom),
+                            onCheckedChange = { checked ->
+                                val newList = selectedSymptoms.toMutableList()
+                                if (checked) {
+                                    newList.add(symptom)
+                                } else {
+                                    newList.remove(symptom)
+                                }
+                                onSymptomsChanged(newList)
+                            }
+                        )
+
+                        Text(
+                            text = label,
+                            style = MaterialTheme.typography.bodyMedium
+                        )
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/app/src/main/java/com/example/womansafe/ui/screens/CalendarInsightsScreen.kt b/app/src/main/java/com/example/womansafe/ui/screens/CalendarInsightsScreen.kt
new file mode 100644
index 0000000..77984e6
--- /dev/null
+++ b/app/src/main/java/com/example/womansafe/ui/screens/CalendarInsightsScreen.kt
@@ -0,0 +1,542 @@
+package com.example.womansafe.ui.screens
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.ArrowBack
+import androidx.compose.material.icons.filled.DateRange
+import androidx.compose.material.icons.filled.FitnessCenter
+import androidx.compose.material.icons.filled.Info
+import androidx.compose.material.icons.filled.Insights
+import androidx.compose.material.icons.filled.Medication
+import androidx.compose.material.icons.filled.Mood
+import androidx.compose.material.icons.filled.TipsAndUpdates
+import androidx.compose.material.icons.outlined.CalendarMonth
+import androidx.compose.material.icons.outlined.Favorite
+import androidx.compose.material.icons.outlined.LocalHospital
+import androidx.compose.material3.*
+import androidx.compose.runtime.*
+import androidx.compose.runtime.livedata.observeAsState
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.viewmodel.compose.viewModel
+import com.example.womansafe.data.model.calendar.CycleData
+import com.example.womansafe.data.model.calendar.HealthInsight
+import com.example.womansafe.data.model.calendar.InsightType
+import com.example.womansafe.data.model.calendar.ConfidenceLevel
+import com.example.womansafe.data.model.calendar.Mood
+import com.example.womansafe.ui.viewmodel.CalendarViewModel
+import java.time.format.DateTimeFormatter
+import java.util.*
+
+/**
+ * Экран аналитики менструального цикла и инсайтов
+ */
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun CalendarInsightsScreen(
+    viewModel: CalendarViewModel = viewModel(),
+    onBackClick: () -> Unit
+) {
+    val calendarUiState by viewModel.calendarUiState.observeAsState()
+    val isLoading by viewModel.isLoading.observeAsState(false)
+
+    Scaffold(
+        topBar = {
+            TopAppBar(
+                title = { Text("Аналитика и рекомендации") },
+                navigationIcon = {
+                    IconButton(onClick = onBackClick) {
+                        Icon(Icons.Default.ArrowBack, contentDescription = "Назад")
+                    }
+                }
+            )
+        }
+    ) { paddingValues ->
+        if (isLoading) {
+            Box(
+                modifier = Modifier
+                    .fillMaxSize()
+                    .padding(paddingValues),
+                contentAlignment = Alignment.Center
+            ) {
+                CircularProgressIndicator()
+            }
+        } else {
+            LazyColumn(
+                modifier = Modifier
+                    .fillMaxSize()
+                    .padding(paddingValues)
+                    .padding(horizontal = 16.dp),
+                verticalArrangement = Arrangement.spacedBy(16.dp)
+            ) {
+                item {
+                    CycleStatistics(cycleData = calendarUiState?.cycleData)
+                }
+
+                // Разделитель
+                item {
+                    Divider(modifier = Modifier.padding(vertical = 8.dp))
+                    Text(
+                        text = "Персонализированные рекомендации",
+                        style = MaterialTheme.typography.titleLarge,
+                        fontWeight = FontWeight.Bold,
+                        modifier = Modifier.padding(vertical = 8.dp)
+                    )
+                }
+
+                // Список инсайтов
+                calendarUiState?.insights?.let { insights ->
+                    if (insights.isNotEmpty()) {
+                        items(insights) { insight ->
+                            InsightItem(
+                                insight = insight,
+                                onDismiss = { viewModel.dismissInsight(insight.id) }
+                            )
+                        }
+                    } else {
+                        item {
+                            EmptyInsightsMessage()
+                        }
+                    }
+                } ?: item {
+                    EmptyInsightsMessage()
+                }
+
+                // Добавляем пространство внизу
+                item {
+                    Spacer(modifier = Modifier.height(32.dp))
+                }
+            }
+        }
+    }
+}
+
+/**
+ * Статистика цикла
+ */
+@Composable
+fun CycleStatistics(cycleData: CycleData?) {
+    val dateFormatter = DateTimeFormatter.ofPattern("d MMMM", Locale("ru"))
+
+    Card(
+        modifier = Modifier.fillMaxWidth(),
+        shape = RoundedCornerShape(12.dp),
+        elevation = CardDefaults.cardElevation(defaultElevation = 2.dp)
+    ) {
+        Column(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(16.dp)
+        ) {
+            Text(
+                text = "Статистика цикла",
+                style = MaterialTheme.typography.titleMedium,
+                fontWeight = FontWeight.Bold
+            )
+
+            Spacer(modifier = Modifier.height(16.dp))
+
+            if (cycleData != null) {
+                // Основные показатели
+                StatisticRow(
+                    label = "Средняя длина цикла:",
+                    value = "${cycleData.averageCycleLength} дней"
+                )
+
+                StatisticRow(
+                    label = "Средняя продолжительность менструации:",
+                    value = "${cycleData.averagePeriodLength} дней"
+                )
+
+                StatisticRow(
+                    label = "Регулярность цикла:",
+                    value = "${cycleData.regularityScore}/100"
+                )
+
+                Spacer(modifier = Modifier.height(16.dp))
+
+                // Прогнозы
+                cycleData.nextPeriodPredicted?.let { nextPeriod ->
+                    Text(
+                        text = "Прогноз следующего цикла",
+                        style = MaterialTheme.typography.titleSmall,
+                        fontWeight = FontWeight.Bold
+                    )
+
+                    Spacer(modifier = Modifier.height(8.dp))
+
+                    StatisticRow(
+                        label = "Начало следующего цикла:",
+                        value = nextPeriod.format(dateFormatter)
+                    )
+
+                    // Прогноз овуляции
+                    cycleData.ovulationDate?.let { ovulationDate ->
+                        StatisticRow(
+                            label = "Ожидаемая овуляция:",
+                            value = ovulationDate.format(dateFormatter)
+                        )
+                    }
+
+                    // Фертильное окно
+                    if (cycleData.fertileWindowStart != null && cycleData.fertileWindowEnd != null) {
+                        StatisticRow(
+                            label = "Фертильное окно:",
+                            value = "${cycleData.fertileWindowStart.format(dateFormatter)} - ${cycleData.fertileWindowEnd.format(dateFormatter)}"
+                        )
+                    }
+                }
+
+                Spacer(modifier = Modifier.height(16.dp))
+
+                // Диаграмма цикла
+                CycleGraph(cycleData = cycleData)
+
+            } else {
+                // Пустое состояние
+                Text(
+                    text = "Нет данных о цикле. Добавьте информацию о своем цикле для отображения статистики.",
+                    style = MaterialTheme.typography.bodyMedium,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant
+                )
+            }
+        }
+    }
+}
+
+/**
+ * Строка со статистическим показателем
+ */
+@Composable
+fun StatisticRow(label: String, value: String) {
+    Row(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(vertical = 4.dp),
+        horizontalArrangement = Arrangement.SpaceBetween
+    ) {
+        Text(
+            text = label,
+            style = MaterialTheme.typography.bodyMedium,
+            color = MaterialTheme.colorScheme.onSurfaceVariant,
+            modifier = Modifier.weight(1f)
+        )
+
+        Text(
+            text = value,
+            style = MaterialTheme.typography.bodyMedium,
+            fontWeight = FontWeight.Bold
+        )
+    }
+}
+
+/**
+ * Упрощенная диаграмма цикла
+ */
+@Composable
+fun CycleGraph(cycleData: CycleData) {
+    val totalDays = cycleData.cycleLength
+    val periodDays = cycleData.periodLength
+    val ovulationDay = cycleData.ovulationDate?.let {
+        val startDate = cycleData.periodStart ?: cycleData.lastPeriodStartDate
+        if (startDate != null) {
+            it.toEpochDay() - startDate.toEpochDay()
+        } else {
+            null
+        }
+    }?.toInt() ?: (totalDays / 2)
+
+    Column(modifier = Modifier.fillMaxWidth()) {
+        Text(
+            text = "Текущий цикл",
+            style = MaterialTheme.typography.titleSmall,
+            fontWeight = FontWeight.Bold,
+            modifier = Modifier.padding(bottom = 8.dp)
+        )
+
+        Box(
+            modifier = Modifier
+                .fillMaxWidth()
+                .height(24.dp)
+                .clip(RoundedCornerShape(12.dp))
+                .background(MaterialTheme.colorScheme.surfaceVariant)
+        ) {
+            // Отображение фазы менструации
+            Box(
+                modifier = Modifier
+                    .fillMaxHeight()
+                    .width(((periodDays.toFloat() / totalDays) * 100).dp)
+                    .clip(RoundedCornerShape(12.dp))
+                    .background(Color(0xFFE57373)) // Красный для менструации
+                    .align(Alignment.CenterStart)
+            )
+
+            // Отображение овуляции
+            Box(
+                modifier = Modifier
+                    .size(24.dp)
+                    .offset(x = ((ovulationDay.toFloat() / totalDays) * 100).dp - 12.dp)
+                    .clip(CircleShape)
+                    .background(Color(0xFF64B5F6)) // Синий для овуляции
+                    .align(Alignment.CenterStart)
+            )
+        }
+
+        Spacer(modifier = Modifier.height(8.dp))
+
+        // Легенда
+        Row(
+            modifier = Modifier.fillMaxWidth(),
+            verticalAlignment = Alignment.CenterVertically
+        ) {
+            Box(
+                modifier = Modifier
+                    .size(12.dp)
+                    .clip(CircleShape)
+                    .background(Color(0xFFE57373))
+            )
+
+            Text(
+                text = "Менструация",
+                style = MaterialTheme.typography.labelSmall,
+                modifier = Modifier.padding(start = 4.dp, end = 16.dp)
+            )
+
+            Box(
+                modifier = Modifier
+                    .size(12.dp)
+                    .clip(CircleShape)
+                    .background(Color(0xFF64B5F6))
+            )
+
+            Text(
+                text = "Овуляция",
+                style = MaterialTheme.typography.labelSmall,
+                modifier = Modifier.padding(start = 4.dp)
+            )
+        }
+    }
+}
+
+/**
+ * Элемент списка инсайтов
+ */
+@Composable
+fun InsightItem(
+    insight: HealthInsight,
+    onDismiss: () -> Unit
+) {
+    val (icon, color) = when (insight.insightType) {
+        InsightType.CYCLE_REGULARITY -> Pair(
+            Icons.Outlined.CalendarMonth,
+            MaterialTheme.colorScheme.primary
+        )
+        InsightType.PERIOD_LENGTH -> Pair(
+            Icons.Outlined.Favorite,
+            Color(0xFFE57373)
+        )
+        InsightType.SYMPTOM_PATTERN -> Pair(
+            Icons.Default.Insights,
+            MaterialTheme.colorScheme.tertiary
+        )
+        InsightType.MOOD_CORRELATION -> Pair(
+            Icons.Filled.Mood,
+            Color(0xFF81C784)
+        )
+        InsightType.PERIOD_PREDICTION -> Pair(
+            Icons.Default.DateRange,
+            Color(0xFF64B5F6)
+        )
+        InsightType.HEALTH_TIP -> Pair(
+            Icons.Default.TipsAndUpdates,
+            Color(0xFFFFC107)
+        )
+        InsightType.MEDICATION_REMINDER -> Pair(
+            Icons.Default.Medication,
+            Color(0xFF9C27B0)
+        )
+        InsightType.EXERCISE_SUGGESTION -> Pair(
+            Icons.Default.FitnessCenter,
+            Color(0xFF607D8B)
+        )
+        else -> Pair(Icons.Default.Info, MaterialTheme.colorScheme.outline)
+    }
+
+    Card(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(vertical = 4.dp),
+        shape = RoundedCornerShape(12.dp),
+        elevation = CardDefaults.cardElevation(defaultElevation = 1.dp)
+    ) {
+        Column(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(16.dp)
+        ) {
+            // Заголовок и иконка
+            Row(
+                modifier = Modifier.fillMaxWidth(),
+                verticalAlignment = Alignment.CenterVertically
+            ) {
+                Icon(
+                    imageVector = icon,
+                    contentDescription = null,
+                    tint = color,
+                    modifier = Modifier.size(24.dp)
+                )
+
+                Spacer(modifier = Modifier.width(12.dp))
+
+                Text(
+                    text = insight.title,
+                    style = MaterialTheme.typography.titleMedium,
+                    fontWeight = FontWeight.Bold,
+                    modifier = Modifier.weight(1f)
+                )
+
+                // Индикатор достоверности
+                ConfidenceBadge(confidence = insight.confidenceLevel)
+            }
+
+            Spacer(modifier = Modifier.height(8.dp))
+
+            // Описание инсайта
+            Text(
+                text = insight.description,
+                style = MaterialTheme.typography.bodyMedium,
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
+                modifier = Modifier.padding(vertical = 8.dp)
+            )
+
+            // Рекомендация
+            Card(
+                modifier = Modifier.fillMaxWidth(),
+                shape = RoundedCornerShape(8.dp),
+                colors = CardDefaults.cardColors(
+                    containerColor = MaterialTheme.colorScheme.secondaryContainer
+                )
+            ) {
+                Column(
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .padding(12.dp)
+                ) {
+                    Text(
+                        text = "Рекомендация:",
+                        style = MaterialTheme.typography.labelLarge,
+                        fontWeight = FontWeight.Bold
+                    )
+
+                    Spacer(modifier = Modifier.height(4.dp))
+
+                    Text(
+                        text = insight.recommendation,
+                        style = MaterialTheme.typography.bodyMedium,
+                        color = MaterialTheme.colorScheme.onSecondaryContainer
+                    )
+                }
+            }
+
+            // Информация об источниках данных
+            Text(
+                text = "На основе ${insight.dataPointsUsed} записей",
+                style = MaterialTheme.typography.labelSmall,
+                color = MaterialTheme.colorScheme.outline,
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(top = 12.dp)
+                    .align(Alignment.End)
+            )
+
+            // Кнопка "скрыть"
+            TextButton(
+                onClick = onDismiss,
+                modifier = Modifier.align(Alignment.End)
+            ) {
+                Text("Скрыть рекомендацию")
+            }
+        }
+    }
+}
+
+/**
+ * Индикатор достоверности инсайта
+ */
+@Composable
+fun ConfidenceBadge(confidence: ConfidenceLevel) {
+    val (color, text) = when (confidence) {
+        ConfidenceLevel.HIGH -> Pair(
+            Color(0xFF4CAF50),
+            "Высокая точность"
+        )
+        ConfidenceLevel.MEDIUM -> Pair(
+            Color(0xFFFFC107),
+            "Средняя точность"
+        )
+        ConfidenceLevel.LOW -> Pair(
+            Color(0xFFFF5722),
+            "Низкая точность"
+        )
+    }
+
+    Box(
+        modifier = Modifier
+            .clip(RoundedCornerShape(4.dp))
+            .background(color.copy(alpha = 0.2f))
+            .padding(horizontal = 6.dp, vertical = 2.dp)
+    ) {
+        Text(
+            text = text,
+            style = MaterialTheme.typography.labelSmall,
+            color = color
+        )
+    }
+}
+
+/**
+ * Сообщение при отсутствии инсайтов
+ */
+@Composable
+fun EmptyInsightsMessage() {
+    Column(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(vertical = 24.dp),
+        horizontalAlignment = Alignment.CenterHorizontally
+    ) {
+        Icon(
+            imageVector = Icons.Default.Insights,
+            contentDescription = null,
+            modifier = Modifier.size(48.dp),
+            tint = MaterialTheme.colorScheme.outline
+        )
+
+        Spacer(modifier = Modifier.height(16.dp))
+
+        Text(
+            text = "Пока нет персональных рекомендаций",
+            style = MaterialTheme.typography.titleMedium,
+            fontWeight = FontWeight.Bold
+        )
+
+        Spacer(modifier = Modifier.height(8.dp))
+
+        Text(
+            text = "Продолжайте вести календарь, и мы сможем предоставить вам полезные советы на основе ваших данных",
+            style = MaterialTheme.typography.bodyMedium,
+            color = MaterialTheme.colorScheme.onSurfaceVariant,
+            textAlign = androidx.compose.ui.text.style.TextAlign.Center
+        )
+    }
+}
diff --git a/app/src/main/java/com/example/womansafe/ui/screens/CalendarScreen.kt b/app/src/main/java/com/example/womansafe/ui/screens/CalendarScreen.kt
index 9e0eacb..bea15ab 100644
--- a/app/src/main/java/com/example/womansafe/ui/screens/CalendarScreen.kt
+++ b/app/src/main/java/com/example/womansafe/ui/screens/CalendarScreen.kt
@@ -1,924 +1,711 @@
 package com.example.womansafe.ui.screens
 
 import androidx.compose.foundation.background
+import androidx.compose.foundation.border
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.LazyRow
+import androidx.compose.foundation.lazy.grid.GridCells
+import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
+import androidx.compose.foundation.lazy.grid.items
 import androidx.compose.foundation.lazy.items
-import androidx.compose.foundation.lazy.LazyListState
-import androidx.compose.foundation.lazy.rememberLazyListState
-import androidx.compose.foundation.rememberScrollState
 import androidx.compose.foundation.shape.CircleShape
 import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.foundation.text.KeyboardOptions
-import androidx.compose.foundation.verticalScroll
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.*
 import androidx.compose.material3.*
 import androidx.compose.runtime.*
+import androidx.compose.runtime.livedata.observeAsState
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.text.input.KeyboardType
+import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
+import androidx.lifecycle.viewmodel.compose.viewModel
 import com.example.womansafe.data.model.*
+import com.example.womansafe.data.model.calendar.CycleData
+import com.example.womansafe.data.model.calendar.HealthInsight
+import com.example.womansafe.data.model.calendar.CalendarEntry
 import com.example.womansafe.ui.viewmodel.CalendarViewModel
-import com.example.womansafe.util.DateUtils
+import com.example.womansafe.ui.viewmodel.DayType
+import java.time.DayOfWeek
 import java.time.LocalDate
+import java.time.YearMonth
 import java.time.format.DateTimeFormatter
-import java.time.temporal.ChronoUnit
+import java.time.format.TextStyle
+import java.util.*
 
-@OptIn(ExperimentalMaterial3Api::class)
+/**
+ * Главный экран менструального календаря
+ */
 @Composable
 fun CalendarScreen(
-    calendarViewModel: CalendarViewModel,
-    modifier: Modifier = Modifier
+    modifier: Modifier = Modifier,
+    viewModel: CalendarViewModel,
+    onAddEntryClick: (LocalDate) -> Unit,
+    onViewInsightsClick: () -> Unit
 ) {
-    val uiState = calendarViewModel.uiState
-    val scrollState = rememberLazyListState()
+    // Наблюдение за состоянием
+    val calendarUiState by viewModel.calendarUiState.observeAsState()
+    val selectedDate by viewModel.selectedDate.observeAsState(LocalDate.now())
+    val isLoading by viewModel.isLoading.observeAsState(false)
+    val errorMessage = calendarUiState?.errorMessage
 
-    // Автоскролл к выбранной дате
-    LaunchedEffect(uiState.selectedDate) {
-        val today = LocalDate.now()
-        val daysDiff = ChronoUnit.DAYS.between(today, uiState.selectedDate).toInt()
-        if (daysDiff in -30..30) {
-            scrollState.animateScrollToItem(daysDiff + 30)
+    // Выбранный месяц для отображения
+    var currentMonth by remember { mutableStateOf(YearMonth.from(LocalDate.now())) }
+
+    // Обработка ошибок
+    LaunchedEffect(errorMessage) {
+        errorMessage?.let {
+            // Здесь можно показать сообщение об ошибке (например, Snackbar)
+            // После отображения ошибки очищаем сообщение
+            viewModel.clearErrorMessage()
         }
     }
 
     Column(
         modifier = modifier
             .fillMaxSize()
-            .padding(horizontal = 16.dp)
+            .padding(16.dp)
     ) {
-        Spacer(modifier = Modifier.height(16.dp))
+        // Заголовок с кнопками навигации по месяцам
+        MonthNavigator(
+            currentMonth = currentMonth,
+            onPreviousMonth = { currentMonth = currentMonth.minusMonths(1) },
+            onNextMonth = { currentMonth = currentMonth.plusMonths(1) },
+        )
 
-        // Заголовок с месяцем и навигацией
-        MonthHeader(
-            currentMonth = uiState.currentMonth,
-            onPreviousMonth = { calendarViewModel.changeMonth(-1) },
-            onNextMonth = { calendarViewModel.changeMonth(1) },
-            onSettingsClick = { calendarViewModel.showSettingsDialog() }
+        Spacer(modifier = Modifier.height(8.dp))
+
+        // Календарная сетка с днями недели и числами
+        MonthCalendarView(
+            currentMonth = currentMonth,
+            selectedDate = selectedDate,
+            specialDays = calendarUiState?.specialDays ?: emptyMap(),
+            onDateSelected = { date -> viewModel.selectDate(date) }
         )
 
         Spacer(modifier = Modifier.height(16.dp))
 
-        // Горизонтальный скролл дней
-        HorizontalDayScroll(
-            selectedDate = uiState.selectedDate,
-            events = uiState.events,
-            predictions = uiState.predictions,
-            onDateSelect = { calendarViewModel.selectDate(it) },
-            scrollState = scrollState
+        // Данные выбранного дня и записи
+        SelectedDayDetails(
+            selectedDate = selectedDate,
+            entries = calendarUiState?.selectedDateEntries ?: emptyList(),
+            cycleData = calendarUiState?.cycleData,
+            onAddEntryClick = { onAddEntryClick(selectedDate) }
         )
 
-        Spacer(modifier = Modifier.height(24.dp))
-
-        // Информация о выбранном дне
-        SelectedDateInfo(
-            selectedDate = uiState.selectedDate,
-            events = uiState.events[uiState.selectedDate] ?: emptyList(),
-            predictions = uiState.predictions,
-            onAddEvent = { calendarViewModel.showEventDialog() },
-            onRemoveEvent = { type -> calendarViewModel.removeEvent(uiState.selectedDate, type) }
-        )
-
-        Spacer(modifier = Modifier.height(16.dp))
-
-        // Прогнозы и статистика
-        if (uiState.predictions != null || uiState.statistics != null) {
-            PredictionsCard(
-                predictions = uiState.predictions,
-                statistics = uiState.statistics
+        // Показ инсайтов о здоровье, если они есть
+        calendarUiState?.insights?.takeIf { it.isNotEmpty() }?.let { insights ->
+            Spacer(modifier = Modifier.height(16.dp))
+            InsightsPreview(
+                insights = insights,
+                onViewAllClick = onViewInsightsClick,
+                onDismiss = { viewModel.dismissInsight(it) }
             )
         }
-    }
 
-    // Диалог добавления события
-    if (uiState.showEventDialog) {
-        AddEventDialog(
-            selectedDate = uiState.selectedDate,
-            onDismiss = { calendarViewModel.hideEventDialog() },
-            onAddEvent = { type, mood, symptoms, notes, flowIntensity ->
-                calendarViewModel.addEvent(
-                    date = uiState.selectedDate,
-                    type = type,
-                    mood = mood,
-                    symptoms = symptoms,
-                    notes = notes,
-                    flowIntensity = flowIntensity
-                )
-                calendarViewModel.hideEventDialog()
+        // Индикатор загрузки
+        if (isLoading) {
+            Box(
+                modifier = Modifier.fillMaxSize(),
+                contentAlignment = Alignment.Center
+            ) {
+                CircularProgressIndicator()
             }
-        )
-    }
-
-    // Диалог настроек цикла
-    if (uiState.showSettingsDialog) {
-        CycleSettingsDialog(
-            settings = uiState.settings,
-            onDismiss = { calendarViewModel.hideSettingsDialog() },
-            onSave = { settings ->
-                calendarViewModel.updateCycleSettings(settings)
-                calendarViewModel.hideSettingsDialog()
-            }
-        )
-    }
-
-    // Обработка ошибок
-    uiState.error?.let { error ->
-        LaunchedEffect(error) {
-            // TODO: Показать snackbar с ошибкой
         }
     }
 }
 
+/**
+ * Навигация по месяцам календаря
+ */
 @Composable
-private fun MonthHeader(
-    currentMonth: LocalDate,
+fun MonthNavigator(
+    currentMonth: YearMonth,
     onPreviousMonth: () -> Unit,
-    onNextMonth: () -> Unit,
-    onSettingsClick: () -> Unit
+    onNextMonth: () -> Unit
 ) {
-    Card(
+    val monthFormatter = DateTimeFormatter.ofPattern("LLLL yyyy", Locale("ru"))
+
+    Row(
         modifier = Modifier.fillMaxWidth(),
-        shape = RoundedCornerShape(16.dp)
+        horizontalArrangement = Arrangement.SpaceBetween,
+        verticalAlignment = Alignment.CenterVertically
     ) {
-        Row(
-            modifier = Modifier
-                .fillMaxWidth()
-                .padding(16.dp),
-            horizontalArrangement = Arrangement.SpaceBetween,
-            verticalAlignment = Alignment.CenterVertically
+        IconButton(onClick = onPreviousMonth) {
+            Icon(Icons.Default.KeyboardArrowLeft, contentDescription = "Предыдущий месяц")
+        }
+
+        Text(
+            text = currentMonth.format(monthFormatter).replaceFirstChar {
+                if (it.isLowerCase()) it.titlecase(Locale("ru")) else it.toString()
+            },
+            style = MaterialTheme.typography.titleLarge,
+            fontWeight = FontWeight.Bold
+        )
+
+        IconButton(onClick = onNextMonth) {
+            Icon(Icons.Default.KeyboardArrowRight, contentDescription = "Следующий месяц")
+        }
+    }
+}
+
+/**
+ * Календарная сетка на месяц
+ */
+@Composable
+fun MonthCalendarView(
+    currentMonth: YearMonth,
+    selectedDate: LocalDate,
+    specialDays: Map<LocalDate, DayType>,
+    onDateSelected: (LocalDate) -> Unit
+) {
+    Column {
+        // Дни недели (заголовок)
+        DaysOfWeekHeader()
+
+        // Дни месяца
+        val startDate = currentMonth.atDay(1)
+        val endDate = currentMonth.atEndOfMonth()
+
+        // Получаем все даты для отображения (включая дни из предыдущего и следующего месяца для заполнения сетки)
+        val firstDayOfGrid = startDate.minusDays(startDate.dayOfWeek.value.toLong() % 7)
+        val lastDayOfGrid = endDate.plusDays(6 - endDate.dayOfWeek.value.toLong() % 7)
+
+        val daysToShow = mutableListOf<LocalDate>()
+        var currentDate = firstDayOfGrid
+        while (!currentDate.isAfter(lastDayOfGrid)) {
+            daysToShow.add(currentDate)
+            currentDate = currentDate.plusDays(1)
+        }
+
+        LazyVerticalGrid(
+            columns = GridCells.Fixed(7),
+            modifier = Modifier.fillMaxWidth(),
+            contentPadding = PaddingValues(0.dp)
         ) {
-            IconButton(onClick = onPreviousMonth) {
-                Icon(
-                    imageVector = Icons.Filled.KeyboardArrowLeft,
-                    contentDescription = "Предыдущий месяц"
+            items(daysToShow) { date ->
+                DayCell(
+                    date = date,
+                    isSelected = date == selectedDate,
+                    isCurrentMonth = date.month == currentMonth.month,
+                    dayType = specialDays[date] ?: DayType.NORMAL,
+                    onClick = { onDateSelected(date) }
                 )
             }
+        }
+    }
+}
 
-            Text(
-                text = DateUtils.formatDate(currentMonth, "LLLL yyyy"),
-                style = MaterialTheme.typography.titleLarge,
-                fontWeight = FontWeight.Bold
-            )
-
-            Row {
-                IconButton(onClick = onSettingsClick) {
-                    Icon(
-                        imageVector = Icons.Filled.Settings,
-                        contentDescription = "Настройки цикла"
-                    )
-                }
-                IconButton(onClick = onNextMonth) {
-                    Icon(
-                        imageVector = Icons.Filled.KeyboardArrowRight,
-                        contentDescription = "Следующий месяц"
-                    )
-                }
+/**
+ * Заголовок с днями недели
+ */
+@Composable
+fun DaysOfWeekHeader() {
+    Row(modifier = Modifier.fillMaxWidth()) {
+        for (dayOfWeek in DayOfWeek.values()) {
+            Box(
+                modifier = Modifier
+                    .weight(1f)
+                    .padding(4.dp),
+                contentAlignment = Alignment.Center
+            ) {
+                Text(
+                    text = dayOfWeek.getDisplayName(TextStyle.SHORT, Locale("ru")).uppercase(),
+                    style = MaterialTheme.typography.labelSmall,
+                    fontWeight = FontWeight.Bold
+                )
             }
         }
     }
 }
 
+/**
+ * Ячейка календаря для отдельного дня
+ */
 @Composable
-private fun HorizontalDayScroll(
-    selectedDate: LocalDate,
-    events: Map<LocalDate, List<CalendarEvent>>,
-    predictions: CyclePrediction?,
-    onDateSelect: (LocalDate) -> Unit,
-    scrollState: LazyListState
-) {
-    val today = DateUtils.getCurrentDate()
-
-    // Генерируем дни для показа (от -30 до +60 дней от сегодня)
-    val days = (-30..60).map { dayOffset ->
-        today.plusDays(dayOffset.toLong())
-    }
-
-    LazyRow(
-        state = scrollState,
-        horizontalArrangement = Arrangement.spacedBy(8.dp),
-        contentPadding = PaddingValues(horizontal = 16.dp)
-    ) {
-        items(days) { date ->
-            DayItem(
-                date = date,
-                isSelected = date.isEqual(selectedDate),
-                isToday = DateUtils.isSameDay(date, today),
-                events = events[date] ?: emptyList(),
-                predictions = predictions,
-                onClick = { onDateSelect(date) }
-            )
-        }
-    }
-}
-
-@Composable
-private fun DayItem(
+fun DayCell(
     date: LocalDate,
     isSelected: Boolean,
-    isToday: Boolean,
-    events: List<CalendarEvent>,
-    predictions: CyclePrediction?,
+    isCurrentMonth: Boolean,
+    dayType: DayType,
     onClick: () -> Unit
 ) {
+    // Цвета для разных типов дней
     val backgroundColor = when {
         isSelected -> MaterialTheme.colorScheme.primary
-        isToday -> MaterialTheme.colorScheme.secondaryContainer
-        else -> MaterialTheme.colorScheme.surface
+        !isCurrentMonth -> Color.Transparent
+        else -> Color.Transparent
     }
 
     val textColor = when {
         isSelected -> MaterialTheme.colorScheme.onPrimary
-        isToday -> MaterialTheme.colorScheme.onSecondaryContainer
+        !isCurrentMonth -> MaterialTheme.colorScheme.outline.copy(alpha = 0.5f)
+        LocalDate.now() == date -> MaterialTheme.colorScheme.primary
         else -> MaterialTheme.colorScheme.onSurface
     }
 
-    // Получение дня недели и числа месяца
-    val dayOfWeek = DateUtils.formatDate(date, "EEE")
-    val dayOfMonth = date.dayOfMonth
+    // Индикатор специального дня
+    val indicatorColor = when (dayType) {
+        DayType.PERIOD -> Color(0xFFE57373) // Красный для менструации
+        DayType.OVULATION -> Color(0xFF64B5F6) // Синий для овуляции
+        DayType.FERTILE -> Color(0xFF81C784) // Зеленый для фертильного окна
+        DayType.PREDICTED_PERIOD -> Color(0xFFE57373).copy(alpha = 0.5f) // Полупрозрачный красный для прогноза
+        DayType.NORMAL -> Color.Transparent
+    }
 
-    // Определяем цвет индикатора событий
-    val eventIndicatorColor = getEventIndicatorColor(events, predictions, date)
-
-    Column(
-        horizontalAlignment = Alignment.CenterHorizontally,
+    Box(
         modifier = Modifier
-            .width(60.dp)
-            .clip(RoundedCornerShape(12.dp))
+            .aspectRatio(1f)
+            .padding(2.dp)
+            .clip(CircleShape)
             .background(backgroundColor)
-            .clickable { onClick() }
-            .padding(8.dp)
+            .border(
+                width = if (isSelected) 0.dp else if (LocalDate.now() == date) 1.dp else 0.dp,
+                color = if (LocalDate.now() == date) MaterialTheme.colorScheme.primary else Color.Transparent,
+                shape = CircleShape
+            )
+            .clickable { onClick() },
+        contentAlignment = Alignment.Center
     ) {
-        // День недели
-        Text(
-            text = dayOfWeek,
-            style = MaterialTheme.typography.bodySmall,
-            color = textColor.copy(alpha = 0.7f),
-            fontSize = 10.sp
-        )
-
-        // Число
-        Text(
-            text = dayOfMonth.toString(),
-            style = MaterialTheme.typography.titleMedium,
-            fontWeight = if (isSelected || isToday) FontWeight.Bold else FontWeight.Normal,
-            color = textColor
-        )
-
-        // Индикаторы событий
-        Row(
-            horizontalArrangement = Arrangement.spacedBy(2.dp),
-            modifier = Modifier.height(8.dp)
+        Column(
+            horizontalAlignment = Alignment.CenterHorizontally,
+            verticalArrangement = Arrangement.Center
         ) {
-            eventIndicatorColor.forEach { color ->
+            Text(
+                text = date.dayOfMonth.toString(),
+                color = textColor,
+                style = MaterialTheme.typography.bodySmall,
+                fontWeight = if (LocalDate.now() == date) FontWeight.Bold else FontWeight.Normal
+            )
+
+            if (dayType != DayType.NORMAL) {
+                Spacer(modifier = Modifier.height(2.dp))
                 Box(
                     modifier = Modifier
-                        .size(6.dp)
+                        .size(4.dp)
                         .clip(CircleShape)
-                        .background(color)
+                        .background(indicatorColor)
                 )
             }
         }
     }
 }
 
+/**
+ * Детали выбранного дня и записи
+ */
 @Composable
-private fun SelectedDateInfo(
+fun SelectedDayDetails(
     selectedDate: LocalDate,
-    events: List<CalendarEvent>,
-    predictions: CyclePrediction?,
-    onAddEvent: () -> Unit,
-    onRemoveEvent: (CalendarEventType) -> Unit
+    entries: List<CalendarEntry>,
+    cycleData: CycleData?,
+    onAddEntryClick: () -> Unit
+) {
+    val dateFormatter = DateTimeFormatter.ofPattern("d MMMM", Locale("ru"))
+
+    Column(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(horizontal = 8.dp)
+    ) {
+        // Заголовок выбранного дня
+        Row(
+            modifier = Modifier.fillMaxWidth(),
+            horizontalArrangement = Arrangement.SpaceBetween,
+            verticalAlignment = Alignment.CenterVertically
+        ) {
+            Text(
+                text = selectedDate.format(dateFormatter),
+                style = MaterialTheme.typography.titleMedium,
+                fontWeight = FontWeight.Bold
+            )
+
+            IconButton(onClick = onAddEntryClick) {
+                Icon(Icons.Default.Add, contentDescription = "Добавить запись")
+            }
+        }
+
+        Spacer(modifier = Modifier.height(8.dp))
+
+        // Информация о специальном дне
+        cycleData?.let {
+            when {
+                selectedDate == it.cycleStartDate -> {
+                    SpecialDayInfo(
+                        title = "Начало цикла",
+                        description = "Сегодня первый день вашего менструального цикла.",
+                        color = Color(0xFFE57373)
+                    )
+                }
+                selectedDate == it.ovulationDate -> {
+                    SpecialDayInfo(
+                        title = "День овуляции",
+                        description = "Сегодня ваш день овуляции - наивысшая вероятность зачатия.",
+                        color = Color(0xFF64B5F6)
+                    )
+                }
+                it.fertileWindowStart?.let { start ->
+                    it.fertileWindowEnd?.let { end ->
+                        selectedDate in start..end
+                    }
+                } == true -> {
+                    SpecialDayInfo(
+                        title = "Фертильное окно",
+                        description = "Вы находитесь в фертильном периоде с повышенной вероятностью зачатия.",
+                        color = Color(0xFF81C784)
+                    )
+                }
+            }
+        }
+
+        Spacer(modifier = Modifier.height(16.dp))
+
+        // Список записей для выбранного дня
+        if (entries.isNotEmpty()) {
+            Text(
+                text = "Записи",
+                style = MaterialTheme.typography.titleSmall,
+                fontWeight = FontWeight.Bold
+            )
+
+            Spacer(modifier = Modifier.height(8.dp))
+
+            LazyColumn(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .heightIn(max = 200.dp)
+            ) {
+                items(entries) { entry ->
+                    EntryItem(entry = entry)
+                    Spacer(modifier = Modifier.height(8.dp))
+                }
+            }
+        } else {
+            // Пустое состояние
+            Box(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(vertical = 24.dp),
+                contentAlignment = Alignment.Center
+            ) {
+                Text(
+                    text = "Нет записей на выбранную дату",
+                    style = MaterialTheme.typography.bodyMedium,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant
+                )
+            }
+        }
+    }
+}
+
+/**
+ * Информация о специальном дне (менструация, овуляция и т.д.)
+ */
+@Composable
+fun SpecialDayInfo(
+    title: String,
+    description: String,
+    color: Color
 ) {
+    Card(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(vertical = 4.dp),
+        shape = RoundedCornerShape(12.dp),
+        colors = CardDefaults.cardColors(
+            containerColor = color.copy(alpha = 0.15f)
+        )
+    ) {
+        Row(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(12.dp),
+            verticalAlignment = Alignment.CenterVertically
+        ) {
+            Box(
+                modifier = Modifier
+                    .size(12.dp)
+                    .clip(CircleShape)
+                    .background(color)
+            )
+
+            Spacer(modifier = Modifier.width(12.dp))
+
+            Column {
+                Text(
+                    text = title,
+                    style = MaterialTheme.typography.titleSmall,
+                    fontWeight = FontWeight.Bold
+                )
+
+                Text(
+                    text = description,
+                    style = MaterialTheme.typography.bodySmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant
+                )
+            }
+        }
+    }
+}
+
+/**
+ * Элемент записи для выбранного дня
+ */
+@Composable
+fun EntryItem(entry: CalendarEntry) {
     Card(
         modifier = Modifier.fillMaxWidth(),
-        shape = RoundedCornerShape(16.dp)
+        shape = RoundedCornerShape(8.dp)
     ) {
         Column(
-            modifier = Modifier.padding(20.dp)
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(16.dp)
         ) {
+            // Заголовок с типом записи
+            Row(
+                modifier = Modifier.fillMaxWidth(),
+                verticalAlignment = Alignment.CenterVertically
+            ) {
+                val (icon, title) = when (entry.entryType) {
+                    com.example.womansafe.data.model.calendar.EntryType.PERIOD -> Pair(
+                        Icons.Default.Favorite,
+                        "Менструация: ${entry.flowIntensity?.name?.lowercase()?.replaceFirstChar { it.uppercase() } ?: ""}"
+                    )
+                    com.example.womansafe.data.model.calendar.EntryType.OVULATION -> Pair(Icons.Default.Star, "Овуляция")
+                    com.example.womansafe.data.model.calendar.EntryType.SYMPTOMS -> Pair(Icons.Default.Warning, "Симптомы")
+                    com.example.womansafe.data.model.calendar.EntryType.MEDICATION -> Pair(Icons.Default.Healing, "Медикаменты")
+                    com.example.womansafe.data.model.calendar.EntryType.NOTE -> Pair(Icons.Default.Info, "Заметка")
+                    com.example.womansafe.data.model.calendar.EntryType.APPOINTMENT -> Pair(Icons.Default.Event, "Приём врача")
+                }
+
+                Icon(
+                    imageVector = icon,
+                    contentDescription = null,
+                    tint = MaterialTheme.colorScheme.primary
+                )
+
+                Spacer(modifier = Modifier.width(8.dp))
+
+                Text(
+                    text = title,
+                    style = MaterialTheme.typography.titleSmall,
+                    fontWeight = FontWeight.Bold
+                )
+            }
+
+            Spacer(modifier = Modifier.height(8.dp))
+
+            // Детали записи
+            entry.symptoms?.takeIf { it.isNotEmpty() }?.let { symptoms ->
+                EntryDetailRow(title = "Симптомы:", content = symptoms.joinToString(", ") {
+                    it.name.replace("_", " ").lowercase().replaceFirstChar { c -> c.uppercase() }
+                })
+            }
+
+            entry.mood?.let { mood ->
+                EntryDetailRow(title = "Настроение:", content = mood.name.lowercase().replaceFirstChar { it.uppercase() })
+            }
+
+            entry.energyLevel?.let { energy ->
+                EntryDetailRow(title = "Энергия:", content = "$energy из 5")
+            }
+
+            entry.sleepHours?.let { sleep ->
+                EntryDetailRow(title = "Сон:", content = "$sleep часов")
+            }
+
+            entry.medications?.takeIf { it.isNotEmpty() }?.let { meds ->
+                EntryDetailRow(title = "Лекарства:", content = meds.joinToString(", "))
+            }
+
+            entry.notes?.takeIf { it.isNotEmpty() }?.let { notes ->
+                Spacer(modifier = Modifier.height(4.dp))
+                Text(
+                    text = notes,
+                    style = MaterialTheme.typography.bodyMedium,
+                    modifier = Modifier.fillMaxWidth()
+                )
+            }
+        }
+    }
+}
+
+/**
+ * Строка с деталями записи
+ */
+@Composable
+fun EntryDetailRow(title: String, content: String) {
+    Row(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(vertical = 2.dp),
+        verticalAlignment = Alignment.CenterVertically
+    ) {
+        Text(
+            text = title,
+            style = MaterialTheme.typography.bodySmall,
+            fontWeight = FontWeight.Bold,
+            modifier = Modifier.width(90.dp)
+        )
+
+        Text(
+            text = content,
+            style = MaterialTheme.typography.bodySmall
+        )
+    }
+}
+
+/**
+ * Предварительный просмотр инсайтов о здоровье
+ */
+@Composable
+fun InsightsPreview(
+    insights: List<HealthInsight>,
+    onViewAllClick: () -> Unit,
+    onDismiss: (Long) -> Unit
+) {
+    Card(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(vertical = 8.dp),
+        shape = RoundedCornerShape(16.dp),
+        colors = CardDefaults.cardColors(
+            containerColor = MaterialTheme.colorScheme.secondaryContainer
+        )
+    ) {
+        Column(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(16.dp)
+        ) {
+            // Заголовок
             Row(
                 modifier = Modifier.fillMaxWidth(),
                 horizontalArrangement = Arrangement.SpaceBetween,
                 verticalAlignment = Alignment.CenterVertically
             ) {
                 Text(
-                    text = DateUtils.formatDate(selectedDate, "d MMMM yyyy"),
+                    text = "Ваши инсайты",
                     style = MaterialTheme.typography.titleMedium,
-                    fontWeight = FontWeight.SemiBold
+                    fontWeight = FontWeight.Bold
                 )
 
-                IconButton(onClick = onAddEvent) {
-                    Icon(
-                        imageVector = Icons.Filled.Add,
-                        contentDescription = "Добавить событие"
+                TextButton(onClick = onViewAllClick) {
+                    Text(text = "Все")
+                }
+            }
+
+            Spacer(modifier = Modifier.height(8.dp))
+
+            // Инсайты в прокручиваемом ряду
+            LazyRow(
+                horizontalArrangement = Arrangement.spacedBy(12.dp)
+            ) {
+                items(insights.take(3)) { insight ->
+                    InsightCard(
+                        insight = insight,
+                        onDismiss = { onDismiss(insight.id) }
                     )
                 }
             }
-
-            Spacer(modifier = Modifier.height(16.dp))
-
-            if (events.isEmpty() && !isPredictedDate(selectedDate, predictions)) {
-                Text(
-                    text = "Нет событий на этот день",
-                    style = MaterialTheme.typography.bodyMedium,
-                    color = MaterialTheme.colorScheme.onSurfaceVariant
-                )
-            } else {
-                // Показываем события
-                events.forEach { event ->
-                    EventItem(
-                        event = event,
-                        onRemove = { onRemoveEvent(event.type) }
-                    )
-                    Spacer(modifier = Modifier.height(8.dp))
-                }
-
-                // Показываем прогнозы для этого дня
-                predictions?.let { pred ->
-                    when {
-                        DateUtils.isDateInRange(selectedDate, pred.nextPeriodStart, pred.nextPeriodEnd) -> {
-                            PredictionItem(
-                                type = "Прогноз месячных",
-                                color = MaterialTheme.colorScheme.error.copy(alpha = 0.3f),
-                                confidence = pred.confidence
-                            )
-                        }
-                        selectedDate.isEqual(pred.nextOvulation) -> {
-                            PredictionItem(
-                                type = "Прогноз овуляции",
-                                color = MaterialTheme.colorScheme.primary.copy(alpha = 0.3f),
-                                confidence = pred.confidence
-                            )
-                        }
-                        DateUtils.isDateInRange(selectedDate, pred.fertileWindowStart, pred.fertileWindowEnd) -> {
-                            PredictionItem(
-                                type = "Период фертильности",
-                                color = MaterialTheme.colorScheme.secondary.copy(alpha = 0.3f),
-                                confidence = pred.confidence
-                            )
-                        }
-                    }
-                }
-            }
         }
     }
 }
 
+/**
+ * Карточка с инсайтом о здоровье
+ */
 @Composable
-private fun EventItem(
-    event: CalendarEvent,
-    onRemove: () -> Unit
-) {
-    Row(
-        modifier = Modifier
-            .fillMaxWidth()
-            .clip(RoundedCornerShape(8.dp))
-            .background(getEventColor(event.type).copy(alpha = 0.1f))
-            .padding(12.dp),
-        horizontalArrangement = Arrangement.SpaceBetween,
-        verticalAlignment = Alignment.CenterVertically
-    ) {
-        Column(modifier = Modifier.weight(1f)) {
-            Text(
-                text = getEventTypeName(event.type),
-                style = MaterialTheme.typography.bodyMedium,
-                fontWeight = FontWeight.Medium,
-                color = getEventColor(event.type)
-            )
-
-            event.mood?.let { mood ->
-                Text(
-                    text = "Настроение: ${getMoodName(mood)}",
-                    style = MaterialTheme.typography.bodySmall,
-                    color = MaterialTheme.colorScheme.onSurfaceVariant
-                )
-            }
-
-            if (event.symptoms.isNotEmpty()) {
-                Text(
-                    text = "Симптомы: ${event.symptoms.size}",
-                    style = MaterialTheme.typography.bodySmall,
-                    color = MaterialTheme.colorScheme.onSurfaceVariant
-                )
-            }
-
-            if (event.notes.isNotBlank()) {
-                Text(
-                    text = event.notes,
-                    style = MaterialTheme.typography.bodySmall,
-                    color = MaterialTheme.colorScheme.onSurfaceVariant
-                )
-            }
-        }
-
-        if (event.isActual) {
-            IconButton(onClick = onRemove) {
-                Icon(
-                    imageVector = Icons.Filled.Close,
-                    contentDescription = "Удалить событие",
-                    tint = MaterialTheme.colorScheme.error,
-                    modifier = Modifier.size(16.dp)
-                )
-            }
-        }
-    }
-}
-
-@Composable
-private fun PredictionItem(
-    type: String,
-    color: Color,
-    confidence: Float
-) {
-    Row(
-        modifier = Modifier
-            .fillMaxWidth()
-            .clip(RoundedCornerShape(8.dp))
-            .background(color)
-            .padding(12.dp),
-        verticalAlignment = Alignment.CenterVertically
-    ) {
-        Icon(
-            imageVector = Icons.Filled.Info,
-            contentDescription = "Прогноз",
-            tint = MaterialTheme.colorScheme.onSurfaceVariant,
-            modifier = Modifier.size(16.dp)
-        )
-        Spacer(modifier = Modifier.width(8.dp))
-        Column {
-            Text(
-                text = type,
-                style = MaterialTheme.typography.bodyMedium,
-                fontWeight = FontWeight.Medium
-            )
-            Text(
-                text = "Вероятность: ${(confidence * 100).toInt()}%",
-                style = MaterialTheme.typography.bodySmall,
-                color = MaterialTheme.colorScheme.onSurfaceVariant
-            )
-        }
-    }
-}
-
-@Composable
-private fun PredictionsCard(
-    predictions: CyclePrediction?,
-    statistics: CycleStatistics?
+fun InsightCard(
+    insight: HealthInsight,
+    onDismiss: () -> Unit
 ) {
     Card(
-        modifier = Modifier.fillMaxWidth(),
-        shape = RoundedCornerShape(16.dp)
+        modifier = Modifier.width(280.dp),
+        shape = RoundedCornerShape(12.dp)
     ) {
         Column(
-            modifier = Modifier.padding(20.dp)
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(16.dp)
         ) {
+            // Заголовок и уровень достоверности
+            Row(
+                modifier = Modifier.fillMaxWidth(),
+                horizontalArrangement = Arrangement.SpaceBetween,
+                verticalAlignment = Alignment.CenterVertically
+            ) {
+                Text(
+                    text = insight.title,
+                    style = MaterialTheme.typography.titleSmall,
+                    fontWeight = FontWeight.Bold,
+                    modifier = Modifier.weight(1f)
+                )
+
+                val confidenceColor = when (insight.confidenceLevel) {
+                    com.example.womansafe.data.model.calendar.ConfidenceLevel.HIGH -> Color(0xFF4CAF50)
+                    com.example.womansafe.data.model.calendar.ConfidenceLevel.MEDIUM -> Color(0xFFFFC107)
+                    com.example.womansafe.data.model.calendar.ConfidenceLevel.LOW -> Color(0xFFFF5722)
+                }
+
+                Box(
+                    modifier = Modifier
+                        .clip(RoundedCornerShape(4.dp))
+                        .background(confidenceColor.copy(alpha = 0.2f))
+                        .padding(horizontal = 6.dp, vertical = 2.dp)
+                ) {
+                    Text(
+                        text = when (insight.confidenceLevel) {
+                            com.example.womansafe.data.model.calendar.ConfidenceLevel.HIGH -> "Высокая точность"
+                            com.example.womansafe.data.model.calendar.ConfidenceLevel.MEDIUM -> "Средняя точность"
+                            com.example.womansafe.data.model.calendar.ConfidenceLevel.LOW -> "Низкая точность"
+                        },
+                        style = MaterialTheme.typography.labelSmall,
+                        color = confidenceColor
+                    )
+                }
+            }
+
+            Spacer(modifier = Modifier.height(8.dp))
+
+            // Описание инсайта
             Text(
-                text = "Прогнозы и статистика",
-                style = MaterialTheme.typography.titleMedium,
-                fontWeight = FontWeight.SemiBold
+                text = insight.description,
+                style = MaterialTheme.typography.bodySmall,
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
+                modifier = Modifier.heightIn(min = 60.dp)
             )
 
-            Spacer(modifier = Modifier.height(16.dp))
+            Spacer(modifier = Modifier.height(8.dp))
 
-            predictions?.let { pred ->
-                PredictionRow("Следующие месячные", pred.nextPeriodStart)
-                PredictionRow("Овуляция", pred.nextOvulation)
-            }
+            // Рекомендация
+            Text(
+                text = "Рекомендация:",
+                style = MaterialTheme.typography.labelSmall,
+                fontWeight = FontWeight.Bold
+            )
 
-            statistics?.let { stats ->
-                Spacer(modifier = Modifier.height(8.dp))
-                Text(
-                    text = "Средняя длина цикла: ${stats.averageCycleLength.toInt()} дней",
-                    style = MaterialTheme.typography.bodyMedium
-                )
-                Text(
-                    text = "Вариация: ±${stats.cycleVariation.toInt()} дней",
-                    style = MaterialTheme.typography.bodyMedium
-                )
-            }
-        }
-    }
-}
+            Text(
+                text = insight.recommendation,
+                style = MaterialTheme.typography.bodySmall
+            )
 
-@Composable
-private fun PredictionRow(
-    label: String,
-    date: LocalDate
-) {
-    Row(
-        modifier = Modifier.fillMaxWidth(),
-        horizontalArrangement = Arrangement.SpaceBetween
-    ) {
-        Text(
-            text = label,
-            style = MaterialTheme.typography.bodyMedium
-        )
-        Text(
-            text = DateUtils.formatDate(date, "d MMM"),
-            style = MaterialTheme.typography.bodyMedium,
-            fontWeight = FontWeight.Medium,
-            color = MaterialTheme.colorScheme.primary
-        )
-    }
-}
+            Spacer(modifier = Modifier.height(12.dp))
 
-@OptIn(ExperimentalMaterial3Api::class)
-@Composable
-private fun AddEventDialog(
-    selectedDate: LocalDate,
-    onDismiss: () -> Unit,
-    onAddEvent: (CalendarEventType, MoodType?, List<SymptomType>, String, Int?) -> Unit
-) {
-    var selectedEventType by remember { mutableStateOf(CalendarEventType.MENSTRUATION) }
-    var selectedMood by remember { mutableStateOf<MoodType?>(null) }
-    var selectedSymptoms by remember { mutableStateOf(setOf<SymptomType>()) }
-    var notes by remember { mutableStateOf("") }
-    var flowIntensity by remember { mutableStateOf<Int?>(null) }
-
-    AlertDialog(
-        onDismissRequest = onDismiss,
-        title = {
-            Text("Добавить событие на ${DateUtils.formatDate(selectedDate, "d MMMM")}")
-        },
-        text = {
-            Column(
-                modifier = Modifier.verticalScroll(rememberScrollState()),
-                verticalArrangement = Arrangement.spacedBy(16.dp)
-            ) {
-                // Тип события
-                Text(
-                    text = "Тип события",
-                    style = MaterialTheme.typography.labelMedium,
-                    fontWeight = FontWeight.Medium
-                )
-
-                Row {
-                    listOf(
-                        CalendarEventType.MENSTRUATION to "Месячные",
-                        CalendarEventType.OVULATION to "Овуляция"
-                    ).forEach { (type, name) ->
-                        FilterChip(
-                            onClick = { selectedEventType = type },
-                            label = { Text(name) },
-                            selected = selectedEventType == type,
-                            modifier = Modifier.padding(end = 8.dp)
-                        )
-                    }
-                }
-
-                // Интенсивность (только для месячных)
-                if (selectedEventType == CalendarEventType.MENSTRUATION) {
-                    Text(
-                        text = "Интенсивность",
-                        style = MaterialTheme.typography.labelMedium,
-                        fontWeight = FontWeight.Medium
-                    )
-
-                    Row {
-                        (1..5).forEach { intensity ->
-                            FilterChip(
-                                onClick = { flowIntensity = intensity },
-                                label = { Text(intensity.toString()) },
-                                selected = flowIntensity == intensity,
-                                modifier = Modifier.padding(end = 4.dp)
-                            )
-                        }
-                    }
-                }
-
-                // Настроение
-                Text(
-                    text = "Настроение",
-                    style = MaterialTheme.typography.labelMedium,
-                    fontWeight = FontWeight.Medium
-                )
-
-                Row {
-                    MoodType.values().forEach { mood ->
-                        FilterChip(
-                            onClick = {
-                                selectedMood = if (selectedMood == mood) null else mood
-                            },
-                            label = { Text(getMoodEmoji(mood)) },
-                            selected = selectedMood == mood,
-                            modifier = Modifier.padding(end = 4.dp)
-                        )
-                    }
-                }
-
-                // Симптомы
-                Text(
-                    text = "Симптомы",
-                    style = MaterialTheme.typography.labelMedium,
-                    fontWeight = FontWeight.Medium
-                )
-
-                Column(
-                    verticalArrangement = Arrangement.spacedBy(4.dp)
-                ) {
-                    // Создаем строки по 2 симптома, безопасно обрабатывая границы массива
-                    val symptoms = SymptomType.values().toList()
-                    // Обходим список с шагом 2, чтобы обрабатывать симптомы парами
-                    for (i in symptoms.indices step 2) {
-                        Row {
-                            // Первый симптом в строке (всегда существует)
-                            FilterChip(
-                                onClick = {
-                                    val symptom = symptoms[i]
-                                    selectedSymptoms = if (selectedSymptoms.contains(symptom)) {
-                                        selectedSymptoms - symptom
-                                    } else {
-                                        selectedSymptoms + symptom
-                                    }
-                                },
-                                label = { Text(getSymptomName(symptoms[i])) },
-                                selected = selectedSymptoms.contains(symptoms[i]),
-                                modifier = Modifier
-                                    .weight(1f)
-                                    .padding(end = 4.dp)
-                            )
-
-                            // Второй симптом в строке (проверяем, что он существует)
-                            if (i + 1 < symptoms.size) {
-                                FilterChip(
-                                    onClick = {
-                                        val symptom = symptoms[i + 1]
-                                        selectedSymptoms = if (selectedSymptoms.contains(symptom)) {
-                                            selectedSymptoms - symptom
-                                        } else {
-                                            selectedSymptoms + symptom
-                                        }
-                                    },
-                                    label = { Text(getSymptomName(symptoms[i + 1])) },
-                                    selected = selectedSymptoms.contains(symptoms[i + 1]),
-                                    modifier = Modifier
-                                        .weight(1f)
-                                        .padding(end = 4.dp)
-                                )
-                            } else {
-                                // Пустое место для выравнивания
-                                Spacer(modifier = Modifier.weight(1f))
-                            }
-                        }
-                    }
-                }
-
-                // Заметки
-                OutlinedTextField(
-                    value = notes,
-                    onValueChange = { notes = it },
-                    label = { Text("Заметки") },
-                    modifier = Modifier.fillMaxWidth(),
-                    maxLines = 3
-                )
-            }
-        },
-        confirmButton = {
+            // Кнопка отклонения инсайта
             TextButton(
-                onClick = {
-                    onAddEvent(
-                        selectedEventType,
-                        selectedMood,
-                        selectedSymptoms.toList(),
-                        notes,
-                        flowIntensity
-                    )
-                }
+                onClick = onDismiss,
+                modifier = Modifier.align(Alignment.End)
             ) {
-                Text("Добавить")
-            }
-        },
-        dismissButton = {
-            TextButton(onClick = onDismiss) {
-                Text("Отмена")
-            }
-        }
-    )
-}
-
-@OptIn(ExperimentalMaterial3Api::class)
-@Composable
-private fun CycleSettingsDialog(
-    settings: CycleSettings,
-    onDismiss: () -> Unit,
-    onSave: (CycleSettings) -> Unit
-) {
-    var cycleLength by remember { mutableStateOf(settings.averageCycleLength.toString()) }
-    var periodLength by remember { mutableStateOf(settings.averagePeriodLength.toString()) }
-    var lastPeriodDate by remember { mutableStateOf(settings.lastPeriodStart) }
-    var reminderDays by remember { mutableStateOf(settings.reminderDaysBefore.toString()) }
-    var trackSymptoms by remember { mutableStateOf(settings.trackSymptoms) }
-    var trackMood by remember { mutableStateOf(settings.trackMood) }
-    var showPredictions by remember { mutableStateOf(settings.showPredictions) }
-
-    AlertDialog(
-        onDismissRequest = onDismiss,
-        title = { Text("Настройки цикла") },
-        text = {
-            Column(
-                verticalArrangement = Arrangement.spacedBy(16.dp)
-            ) {
-                OutlinedTextField(
-                    value = cycleLength,
-                    onValueChange = { cycleLength = it },
-                    label = { Text("Средняя длина цикла (дни)") },
-                    modifier = Modifier.fillMaxWidth(),
-                    singleLine = true,
-                    keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Number)
-                )
-
-                OutlinedTextField(
-                    value = periodLength,
-                    onValueChange = { periodLength = it },
-                    label = { Text("Длина менструации (дни)") },
-                    modifier = Modifier.fillMaxWidth(),
-                    singleLine = true,
-                    keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Number)
-                )
-
-                OutlinedTextField(
-                    value = reminderDays,
-                    onValueChange = { reminderDays = it },
-                    label = { Text("Напоминать за (дни)") },
-                    modifier = Modifier.fillMaxWidth(),
-                    singleLine = true,
-                    keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Number)
-                )
-
-                // Переключатели для отслеживания симптомов и настроения
-                Row(
-                    modifier = Modifier.fillMaxWidth(),
-                    horizontalArrangement = Arrangement.SpaceBetween,
-                    verticalAlignment = Alignment.CenterVertically
-                ) {
-                    Text("Отслеживать симптомы")
-                    Switch(
-                        checked = trackSymptoms,
-                        onCheckedChange = { trackSymptoms = it }
-                    )
-                }
-
-                Row(
-                    modifier = Modifier.fillMaxWidth(),
-                    horizontalArrangement = Arrangement.SpaceBetween,
-                    verticalAlignment = Alignment.CenterVertically
-                ) {
-                    Text("Отслеживать настроение")
-                    Switch(
-                        checked = trackMood,
-                        onCheckedChange = { trackMood = it }
-                    )
-                }
-
-                Row(
-                    modifier = Modifier.fillMaxWidth(),
-                    horizontalArrangement = Arrangement.SpaceBetween,
-                    verticalAlignment = Alignment.CenterVertically
-                ) {
-                    Text("Показывать прогнозы")
-                    Switch(
-                        checked = showPredictions,
-                        onCheckedChange = { showPredictions = it }
-                    )
-                }
-
-                // TODO: Добавить выбор даты последних месячных
-                lastPeriodDate?.let { date ->
-                    Text(
-                        text = "Последние месячные: ${date.format(DateTimeFormatter.ofPattern("d MMMM yyyy"))}",
-                        style = MaterialTheme.typography.bodyMedium
-                    )
-                }
-            }
-        },
-        confirmButton = {
-            TextButton(
-                onClick = {
-                    val newSettings = settings.copy(
-                        averageCycleLength = cycleLength.toIntOrNull() ?: settings.averageCycleLength,
-                        averagePeriodLength = periodLength.toIntOrNull() ?: settings.averagePeriodLength,
-                        reminderDaysBefore = reminderDays.toIntOrNull() ?: settings.reminderDaysBefore,
-                        lastPeriodStart = lastPeriodDate,
-                        trackSymptoms = trackSymptoms,
-                        trackMood = trackMood,
-                        showPredictions = showPredictions
-                    )
-                    onSave(newSettings)
-                }
-            ) {
-                Text("Сохранить")
-            }
-        },
-        dismissButton = {
-            TextButton(onClick = onDismiss) {
-                Text("Отмена")
-            }
-        }
-    )
-}
-
-// Вспомогательные функции
-private fun getEventIndicatorColor(
-    events: List<CalendarEvent>,
-    predictions: CyclePrediction?,
-    date: LocalDate
-): List<Color> {
-    val colors = mutableListOf<Color>()
-
-    events.forEach { event ->
-        colors.add(getEventColor(event.type))
-    }
-
-    // Добавляем цвета прогнозов
-    predictions?.let { pred ->
-        when {
-            DateUtils.isDateInRange(date, pred.nextPeriodStart, pred.nextPeriodEnd) -> {
-                if (!events.any { it.type == CalendarEventType.MENSTRUATION }) {
-                    colors.add(Color.Red.copy(alpha = 0.5f))
-                }
-            }
-            date.isEqual(pred.nextOvulation) -> {
-                if (!events.any { it.type == CalendarEventType.OVULATION }) {
-                    colors.add(Color.Blue.copy(alpha = 0.5f))
-                }
-            }
-            DateUtils.isDateInRange(date, pred.fertileWindowStart, pred.fertileWindowEnd) -> {
-                if (!events.any { it.type == CalendarEventType.FERTILE_WINDOW }) {
-                    colors.add(Color.Green.copy(alpha = 0.5f))
-                }
+                Text(text = "Скрыть")
             }
         }
     }
-
-    return colors.take(3) // Максимум 3 индикатора
-}
-
-private fun getEventColor(type: CalendarEventType): Color {
-    return when (type) {
-        CalendarEventType.MENSTRUATION -> Color.Red
-        CalendarEventType.OVULATION -> Color.Blue
-        CalendarEventType.FERTILE_WINDOW -> Color.Green
-        CalendarEventType.PREDICTED_MENSTRUATION -> Color.Red.copy(alpha = 0.5f)
-        CalendarEventType.PREDICTED_OVULATION -> Color.Blue.copy(alpha = 0.5f)
-    }
-}
-
-private fun getEventTypeName(type: CalendarEventType): String {
-    return when (type) {
-        CalendarEventType.MENSTRUATION -> "Месячные"
-        CalendarEventType.OVULATION -> "Овуляция"
-        CalendarEventType.FERTILE_WINDOW -> "Фертильность"
-        CalendarEventType.PREDICTED_MENSTRUATION -> "Прогноз месячных"
-        CalendarEventType.PREDICTED_OVULATION -> "Прогноз овуляции"
-    }
-}
-
-private fun getMoodName(mood: MoodType): String {
-    return when (mood) {
-        MoodType.EXCELLENT -> "Отлично"
-        MoodType.GOOD -> "Хорошо"
-        MoodType.NORMAL -> "Нормально"
-        MoodType.BAD -> "Плохо"
-        MoodType.TERRIBLE -> "Ужасно"
-    }
-}
-
-private fun getMoodEmoji(mood: MoodType): String {
-    return when (mood) {
-        MoodType.EXCELLENT -> "😄"
-        MoodType.GOOD -> "😊"
-        MoodType.NORMAL -> "😐"
-        MoodType.BAD -> "😞"
-        MoodType.TERRIBLE -> "😫"
-    }
-}
-
-private fun getSymptomName(symptom: SymptomType): String {
-    return when (symptom) {
-        SymptomType.CRAMPS -> "Спазмы"
-        SymptomType.HEADACHE -> "Головная боль"
-        SymptomType.BLOATING -> "Вздутие"
-        SymptomType.BREAST_TENDERNESS -> "Болезненность груди"
-        SymptomType.MOOD_SWINGS -> "Перепады настроения"
-        SymptomType.FATIGUE -> "Усталость"
-        SymptomType.ACNE -> "Акне"
-        SymptomType.CRAVINGS -> "Тяга к еде"
-        SymptomType.BACK_PAIN -> "Боль в спине"
-        SymptomType.NAUSEA -> "Тошнота"
-    }
-}
-
-private fun isPredictedDate(date: LocalDate, predictions: CyclePrediction?): Boolean {
-    predictions ?: return false
-
-    return DateUtils.isDateInRange(date, predictions.nextPeriodStart, predictions.nextPeriodEnd) ||
-           date.isEqual(predictions.nextOvulation) ||
-           DateUtils.isDateInRange(date, predictions.fertileWindowStart, predictions.fertileWindowEnd)
 }
diff --git a/app/src/main/java/com/example/womansafe/ui/screens/ContactPickerScreen.kt b/app/src/main/java/com/example/womansafe/ui/screens/ContactPickerScreen.kt
new file mode 100644
index 0000000..688ebf5
--- /dev/null
+++ b/app/src/main/java/com/example/womansafe/ui/screens/ContactPickerScreen.kt
@@ -0,0 +1,224 @@
+package com.example.womansafe.ui.screens
+
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.ArrowBack
+import androidx.compose.material.icons.filled.Person
+import androidx.compose.material.icons.filled.Search
+import androidx.compose.material3.*
+import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.vector.rememberVectorPainter
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import coil.compose.rememberAsyncImagePainter
+import com.example.womansafe.util.ContactsHelper
+import com.example.womansafe.util.PermissionManager
+import com.example.womansafe.util.RequestPermissions
+import com.example.womansafe.util.fixTouchEvents
+import kotlinx.coroutines.launch
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun ContactPickerScreen(
+    onContactSelected: (ContactsHelper.Contact, String) -> Unit,
+    onBackPressed: () -> Unit
+) {
+    val context = LocalContext.current
+    val contactsHelper = remember { ContactsHelper(context) }
+    val coroutineScope = rememberCoroutineScope()
+
+    var contacts by remember { mutableStateOf<List<ContactsHelper.Contact>>(emptyList()) }
+    var isLoading by remember { mutableStateOf(true) }
+    var searchQuery by remember { mutableStateOf("") }
+    var showRelationshipDialog by remember { mutableStateOf<ContactsHelper.Contact?>(null) }
+
+    // Фильтрованные контакты на основе поискового запроса
+    val filteredContacts = remember(contacts, searchQuery) {
+        if (searchQuery.isBlank()) contacts
+        else contacts.filter {
+            it.name.contains(searchQuery, ignoreCase = true) ||
+            it.phoneNumber.contains(searchQuery)
+        }
+    }
+
+    // Запрос разрешения на чтение контактов
+    RequestPermissions(
+        permissions = listOf(PermissionManager.PERMISSION_CONTACTS),
+        onAllPermissionsGranted = {
+            // Загружаем контакты после получения разрешения
+            coroutineScope.launch {
+                isLoading = true
+                contacts = contactsHelper.getContacts()
+                isLoading = false
+            }
+        },
+        onPermissionDenied = { deniedPermissions ->
+            // Показываем сообщение, если пользователь отклонил разрешение
+            isLoading = false
+        }
+    )
+
+    Scaffold(
+        topBar = {
+            TopAppBar(
+                title = { Text("Выбрать контакт") },
+                navigationIcon = {
+                    IconButton(onClick = onBackPressed) {
+                        Icon(Icons.Default.ArrowBack, contentDescription = "Назад")
+                    }
+                },
+                actions = {
+                    // Строка поиска
+                    OutlinedTextField(
+                        value = searchQuery,
+                        onValueChange = { searchQuery = it },
+                        placeholder = { Text("Поиск") },
+                        singleLine = true,
+                        leadingIcon = { Icon(Icons.Default.Search, contentDescription = null) },
+                        modifier = Modifier
+                            .fillMaxWidth(0.7f)
+                            .padding(end = 8.dp)
+                    )
+                }
+            )
+        }
+    ) { paddingValues ->
+        if (isLoading) {
+            // Показываем индикатор загрузки
+            Box(
+                modifier = Modifier
+                    .fillMaxSize()
+                    .padding(paddingValues),
+                contentAlignment = Alignment.Center
+            ) {
+                CircularProgressIndicator()
+            }
+        } else if (contacts.isEmpty()) {
+            // Показываем сообщение, если контакты не найдены
+            Box(
+                modifier = Modifier
+                    .fillMaxSize()
+                    .padding(paddingValues),
+                contentAlignment = Alignment.Center
+            ) {
+                Text("Контакты не найдены или нет разрешения на доступ к контактам")
+            }
+        } else {
+            // Показываем список контактов
+            LazyColumn(
+                modifier = Modifier
+                    .fillMaxSize()
+                    .padding(paddingValues)
+                    .fixTouchEvents()
+            ) {
+                items(filteredContacts) { contact ->
+                    ContactItem(
+                        contact = contact,
+                        onClick = { showRelationshipDialog = contact }
+                    )
+                }
+            }
+        }
+    }
+
+    // Диалог выбора отношения к контакту
+    showRelationshipDialog?.let { contact ->
+        var relationship by remember { mutableStateOf("") }
+
+        AlertDialog(
+            onDismissRequest = { showRelationshipDialog = null },
+            title = { Text("Укажите отношение") },
+            text = {
+                Column {
+                    Text("Контакт: ${contact.name}")
+                    Spacer(modifier = Modifier.height(16.dp))
+                    OutlinedTextField(
+                        value = relationship,
+                        onValueChange = { relationship = it },
+                        label = { Text("Отношение (например: Мама, Папа, Друг)") },
+                        modifier = Modifier.fillMaxWidth()
+                    )
+                }
+            },
+            confirmButton = {
+                TextButton(
+                    onClick = {
+                        onContactSelected(contact, relationship)
+                        showRelationshipDialog = null
+                    },
+                    enabled = relationship.isNotBlank()
+                ) {
+                    Text("Добавить")
+                }
+            },
+            dismissButton = {
+                TextButton(onClick = { showRelationshipDialog = null }) {
+                    Text("Отмена")
+                }
+            }
+        )
+    }
+}
+
+@Composable
+fun ContactItem(
+    contact: ContactsHelper.Contact,
+    onClick: () -> Unit
+) {
+    Card(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(horizontal = 16.dp, vertical = 8.dp)
+            .clickable(onClick = onClick)
+    ) {
+        Row(
+            modifier = Modifier
+                .padding(16.dp)
+                .fillMaxWidth(),
+            verticalAlignment = Alignment.CenterVertically
+        ) {
+            // Аватар контакта
+            val painter = if (contact.photoUri != null) {
+                rememberAsyncImagePainter(contact.photoUri)
+            } else {
+                rememberVectorPainter(Icons.Default.Person)
+            }
+
+            Image(
+                painter = painter,
+                contentDescription = null,
+                modifier = Modifier
+                    .size(48.dp)
+                    .clip(CircleShape),
+                contentScale = ContentScale.Crop
+            )
+
+            Spacer(modifier = Modifier.width(16.dp))
+
+            Column(modifier = Modifier.weight(1f)) {
+                Text(
+                    text = contact.name,
+                    style = MaterialTheme.typography.titleMedium,
+                    maxLines = 1,
+                    overflow = TextOverflow.Ellipsis
+                )
+                Text(
+                    text = contact.phoneNumber,
+                    style = MaterialTheme.typography.bodyMedium,
+                    color = Color.Gray
+                )
+            }
+        }
+    }
+}
diff --git a/app/src/main/java/com/example/womansafe/ui/screens/EmergencyContactsScreen.kt b/app/src/main/java/com/example/womansafe/ui/screens/EmergencyContactsScreen.kt
index 3b9efdc..cf8ac92 100644
--- a/app/src/main/java/com/example/womansafe/ui/screens/EmergencyContactsScreen.kt
+++ b/app/src/main/java/com/example/womansafe/ui/screens/EmergencyContactsScreen.kt
@@ -10,20 +10,25 @@ import androidx.compose.material3.*
 import androidx.compose.runtime.*
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.unit.dp
 import com.example.womansafe.data.model.EmergencyContactCreate
 import com.example.womansafe.data.model.EmergencyContactResponse
 import com.example.womansafe.ui.viewmodel.EmergencyContactsViewModel
+import com.example.womansafe.util.ContactsHelper
+import com.example.womansafe.util.fixTouchEvents
 
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
 fun EmergencyContactsScreen(
     emergencyContactsViewModel: EmergencyContactsViewModel,
-    modifier: Modifier = Modifier
+    modifier: Modifier = Modifier,
+    onNavigateToContactPicker: () -> Unit
 ) {
     val uiState = emergencyContactsViewModel.uiState
     var showAddDialog by remember { mutableStateOf(false) }
+    var showContactPickerDialog by remember { mutableStateOf(false) }
 
     LaunchedEffect(Unit) {
         emergencyContactsViewModel.loadContacts()
@@ -47,7 +52,7 @@ fun EmergencyContactsScreen(
             )
 
             FloatingActionButton(
-                onClick = { showAddDialog = true },
+                onClick = { showContactPickerDialog = true },
                 containerColor = MaterialTheme.colorScheme.primary,
                 modifier = Modifier.size(48.dp)
             ) {
@@ -97,7 +102,7 @@ fun EmergencyContactsScreen(
                 CircularProgressIndicator()
             }
         } else if (uiState.contacts.isEmpty()) {
-            EmptyContactsCard(onAddContact = { showAddDialog = true })
+            EmptyContactsCard(onAddContact = { showContactPickerDialog = true })
         } else {
             LazyColumn(
                 verticalArrangement = Arrangement.spacedBy(12.dp)
@@ -125,6 +130,17 @@ fun EmergencyContactsScreen(
         )
     }
 
+    // Диалог выбора контакта
+    if (showContactPickerDialog) {
+        ContactPickerDialog(
+            onDismiss = { showContactPickerDialog = false },
+            onContactSelected = { contact ->
+                emergencyContactsViewModel.addContact(contact)
+                showContactPickerDialog = false
+            }
+        )
+    }
+
     // Обработка ошибок
     uiState.error?.let { error ->
         LaunchedEffect(error) {
@@ -367,3 +383,76 @@ private fun AddContactDialog(
         }
     )
 }
+
+@Composable
+private fun ContactPickerDialog(
+    onDismiss: () -> Unit,
+    onContactSelected: (EmergencyContactCreate) -> Unit
+) {
+    val context = LocalContext.current
+    var showContactPicker by remember { mutableStateOf(false) }
+
+    if (showContactPicker) {
+        // Используем полноэкранный контактный пикер
+        AlertDialog(
+            onDismissRequest = { onDismiss() },
+            title = { Text("Переход к выбору контактов") },
+            text = {
+                Text("Вы будете перенаправлены на экран выбора контактов из телефонной книги.")
+            },
+            confirmButton = {
+                TextButton(onClick = {
+                    showContactPicker = false
+                    onDismiss()
+                    // Здесь будет логика перехода на ContactPickerScreen
+                }) {
+                    Text("Понятно")
+                }
+            }
+        )
+    } else {
+        AlertDialog(
+            onDismissRequest = onDismiss,
+            title = { Text("Выберите способ добавления") },
+            text = {
+                Column(
+                    verticalArrangement = Arrangement.spacedBy(16.dp)
+                ) {
+                    Button(
+                        onClick = { showContactPicker = true },
+                        modifier = Modifier.fillMaxWidth()
+                    ) {
+                        Icon(
+                            imageVector = Icons.Default.Contacts,
+                            contentDescription = null
+                        )
+                        Spacer(modifier = Modifier.width(8.dp))
+                        Text("Выбрать из контактов")
+                    }
+
+                    Button(
+                        onClick = {
+                            onDismiss()
+                            // Показываем диалог ручного добавления
+                            // (используем существующий диалог добавления контакта)
+                        },
+                        modifier = Modifier.fillMaxWidth()
+                    ) {
+                        Icon(
+                            imageVector = Icons.Default.Add,
+                            contentDescription = null
+                        )
+                        Spacer(modifier = Modifier.width(8.dp))
+                        Text("Добавить вручную")
+                    }
+                }
+            },
+            confirmButton = { },
+            dismissButton = {
+                TextButton(onClick = onDismiss) {
+                    Text("Отмена")
+                }
+            }
+        )
+    }
+}
diff --git a/app/src/main/java/com/example/womansafe/ui/screens/EnhancedCalendarScreen.kt b/app/src/main/java/com/example/womansafe/ui/screens/EnhancedCalendarScreen.kt
new file mode 100644
index 0000000..5adf454
--- /dev/null
+++ b/app/src/main/java/com/example/womansafe/ui/screens/EnhancedCalendarScreen.kt
@@ -0,0 +1,1312 @@
+package com.example.womansafe.ui.screens
+
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.core.Spring
+import androidx.compose.animation.core.spring
+import androidx.compose.animation.expandVertically
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.animation.shrinkVertically
+import androidx.compose.foundation.background
+import androidx.compose.foundation.border
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.LazyRow
+import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.lazy.rememberLazyListState
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.*
+import androidx.compose.material3.*
+import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Brush
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import com.example.womansafe.data.model.calendar.*
+import com.example.womansafe.ui.components.CalendarEventDetailDialog
+import com.example.womansafe.ui.theme.AppColors
+import com.example.womansafe.ui.viewmodel.EnhancedCalendarViewModel
+import com.example.womansafe.utils.DateUtils
+import java.time.LocalDate
+import java.time.YearMonth
+import java.time.format.DateTimeFormatter
+import java.time.format.TextStyle
+import java.time.temporal.ChronoUnit
+import java.util.*
+import kotlin.math.absoluteValue
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun EnhancedCalendarScreen(
+    viewModel: EnhancedCalendarViewModel,
+    modifier: Modifier = Modifier,
+    onNavigateToAnalytics: () -> Unit = {},
+    onNavigateToInsights: () -> Unit = {}
+) {
+    val uiState = viewModel.uiState
+    val scrollState = rememberLazyListState()
+
+    // Загрузка данных при первом открытии
+    LaunchedEffect(Unit) {
+        viewModel.loadInitialData()
+    }
+
+    // Автоскролл к выбранной дате
+    LaunchedEffect(uiState.selectedDate) {
+        val today = LocalDate.now()
+        val daysDiff = ChronoUnit.DAYS.between(today, uiState.selectedDate).toInt()
+        if (daysDiff in -30..30) {
+            scrollState.animateScrollToItem(daysDiff + 30)
+        }
+    }
+
+    Scaffold(
+        topBar = {
+            TopAppBar(
+                title = { Text("Мой календарь") },
+                colors = TopAppBarDefaults.topAppBarColors(
+                    containerColor = MaterialTheme.colorScheme.primaryContainer,
+                    titleContentColor = MaterialTheme.colorScheme.onPrimaryContainer
+                ),
+                actions = {
+                    IconButton(onClick = onNavigateToAnalytics) {
+                        Icon(
+                            imageVector = Icons.Default.BarChart,
+                            contentDescription = "Аналитика цикла"
+                        )
+                    }
+                    IconButton(onClick = onNavigateToInsights) {
+                        Badge(
+                            modifier = Modifier.offset(x = (-10).dp, y = 5.dp),
+                            containerColor = if (uiState.insights.any { !it.isDismissed })
+                                MaterialTheme.colorScheme.error else Color.Transparent
+                        ) {
+                            val newInsightsCount = uiState.insights.count { !it.isDismissed }
+                            if (newInsightsCount > 0) {
+                                Text(newInsightsCount.toString())
+                            }
+                        }
+                        Icon(
+                            imageVector = Icons.Default.Lightbulb,
+                            contentDescription = "Инсайты"
+                        )
+                    }
+                }
+            )
+        },
+        floatingActionButton = {
+            ExtendedFloatingActionButton(
+                onClick = { viewModel.showEventDialog() },
+                containerColor = MaterialTheme.colorScheme.primary,
+                contentColor = MaterialTheme.colorScheme.onPrimary,
+                icon = { Icon(Icons.Default.Add, contentDescription = null) },
+                text = { Text("Добавить") }
+            )
+        }
+    ) { paddingValues ->
+        Column(
+            modifier = modifier
+                .fillMaxSize()
+                .padding(paddingValues)
+                .padding(horizontal = 16.dp)
+        ) {
+            // Секция месяца и навигации
+            EnhancedMonthHeader(
+                currentMonth = uiState.currentMonth,
+                onPreviousMonth = { viewModel.changeMonth(-1) },
+                onNextMonth = { viewModel.changeMonth(1) },
+                onSettingsClick = { viewModel.showSettingsDialog() }
+            )
+
+            Spacer(modifier = Modifier.height(12.dp))
+
+            // Информация о текущем цикле
+            uiState.predictions?.let { predictions ->
+                CycleProgressCard(
+                    nextPeriodDate = predictions.nextPeriodStart,
+                    ovulationDate = predictions.nextOvulation,
+                    daysUntilNextPeriod = ChronoUnit.DAYS.between(LocalDate.now(), predictions.nextPeriodStart).toInt()
+                )
+            }
+
+            Spacer(modifier = Modifier.height(16.dp))
+
+            // Календарь с горизонтальным скроллингом дней
+            EnhancedHorizontalCalendar(
+                selectedDate = uiState.selectedDate,
+                events = uiState.events,
+                predictions = uiState.predictions,
+                onDateSelect = { viewModel.selectDate(it) },
+                scrollState = scrollState
+            )
+
+            Spacer(modifier = Modifier.height(16.dp))
+
+            // Информация о выбранной дате и события
+            EnhancedDateDetail(
+                selectedDate = uiState.selectedDate,
+                events = uiState.events[uiState.selectedDate] ?: emptyList(),
+                predictions = uiState.predictions,
+                onAddEvent = { viewModel.showEventDialog() },
+                onEventClick = { viewModel.selectEvent(it) }
+            )
+
+            // Предстоящие события и прогнозы
+            uiState.predictions?.let { predictions ->
+                val upcomingEvents = getUpcomingEvents(predictions)
+                if (upcomingEvents.isNotEmpty()) {
+                    Spacer(modifier = Modifier.height(16.dp))
+                    UpcomingEventsCard(upcomingEvents)
+                }
+            }
+        }
+    }
+
+    // Диалог с деталями события
+    uiState.selectedEvent?.let { event ->
+        CalendarEventDetailDialog(
+            event = event,
+            onDismiss = { viewModel.clearSelectedEvent() },
+            onEdit = { viewModel.showEventDialog(it) },
+            onDelete = { viewModel.deleteCalendarEntry(event.id.toLong()) }
+        )
+    }
+
+    // Диалог добавления/редактирования события
+    if (uiState.showEventDialog) {
+        EnhancedEventDialog(
+            selectedDate = uiState.selectedDate,
+            existingEvent = uiState.editingEvent,
+            onDismiss = { viewModel.hideEventDialog() },
+            onSaveEvent = { event, type, flow, mood, symptoms, meds, notes, energy, sleep ->
+                val energyInt = energy?.toString()?.toIntOrNull()
+                val newEntry = CalendarEntry(
+                    id = 0L, // Используем автоинкремент, Room сам присвоит id
+                    userId = "", // Заполнить актуальным userId
+                    entryDate = uiState.selectedDate,
+                    entryType = type,
+                    flowIntensity = flow,
+                    mood = mood,
+                    energyLevel = energyInt,
+                    sleepHours = sleep,
+                    symptoms = symptoms,
+                    medications = meds,
+                    notes = notes,
+                    entryId = event?.id?.toLong() ?: 0L // приведение к Long
+                )
+                if (event == null) {
+                    viewModel.addCalendarEntry(newEntry)
+                } else {
+                    viewModel.updateCalendarEntry(newEntry)
+                }
+                viewModel.hideEventDialog()
+            }
+        )
+    }
+
+    // Отображение ошибок
+    uiState.error?.let { error ->
+        LaunchedEffect(error) {
+            // TODO: Показать snackbar
+            // viewModel.clearError()
+        }
+    }
+}
+
+@Composable
+private fun EnhancedMonthHeader(
+    currentMonth: LocalDate,
+    onPreviousMonth: () -> Unit,
+    onNextMonth: () -> Unit,
+    onSettingsClick: () -> Unit
+) {
+    Card(
+        modifier = Modifier.fillMaxWidth(),
+        shape = RoundedCornerShape(16.dp),
+        colors = CardDefaults.cardColors(
+            containerColor = MaterialTheme.colorScheme.primaryContainer,
+            contentColor = MaterialTheme.colorScheme.onPrimaryContainer
+        )
+    ) {
+        Row(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(16.dp),
+            horizontalArrangement = Arrangement.SpaceBetween,
+            verticalAlignment = Alignment.CenterVertically
+        ) {
+            IconButton(onClick = onPreviousMonth) {
+                Icon(
+                    imageVector = Icons.Filled.KeyboardArrowLeft,
+                    contentDescription = "Предыдущий месяц"
+                )
+            }
+
+            Text(
+                text = currentMonth.format(DateTimeFormatter.ofPattern("LLLL yyyy", Locale("ru"))),
+                style = MaterialTheme.typography.titleLarge,
+                fontWeight = FontWeight.Bold
+            )
+
+            Row {
+                IconButton(onClick = onSettingsClick) {
+                    Icon(
+                        imageVector = Icons.Filled.Settings,
+                        contentDescription = "Настройки цикла"
+                    )
+                }
+                IconButton(onClick = onNextMonth) {
+                    Icon(
+                        imageVector = Icons.Filled.KeyboardArrowRight,
+                        contentDescription = "Следующий месяц"
+                    )
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun CycleProgressCard(
+    nextPeriodDate: LocalDate,
+    ovulationDate: LocalDate,
+    daysUntilNextPeriod: Int
+) {
+    Card(
+        modifier = Modifier.fillMaxWidth(),
+        shape = RoundedCornerShape(16.dp),
+        colors = CardDefaults.cardColors(
+            containerColor = MaterialTheme.colorScheme.surface
+        )
+    ) {
+        Column(
+            modifier = Modifier.padding(16.dp)
+        ) {
+            // Прогресс цикла
+            val totalDays = 28 // Средняя длина цикла
+            val progressDays = totalDays - daysUntilNextPeriod
+            LinearProgressIndicator(
+                progress = (progressDays.toFloat() / totalDays).coerceIn(0f, 1f),
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .height(8.dp)
+                    .clip(RoundedCornerShape(4.dp)),
+                color = MaterialTheme.colorScheme.primary,
+                trackColor = MaterialTheme.colorScheme.surfaceVariant
+            )
+
+            Spacer(modifier = Modifier.height(12.dp))
+
+            // Информация о следующем периоде
+            Row(
+                modifier = Modifier.fillMaxWidth(),
+                horizontalArrangement = Arrangement.SpaceBetween,
+                verticalAlignment = Alignment.CenterVertically
+            ) {
+                Column {
+                    Text(
+                        text = "Следующие месячные через",
+                        style = MaterialTheme.typography.bodyMedium
+                    )
+                    Text(
+                        text = "$daysUntilNextPeriod дней",
+                        style = MaterialTheme.typography.titleMedium,
+                        fontWeight = FontWeight.Bold,
+                        color = MaterialTheme.colorScheme.primary
+                    )
+                }
+
+                Text(
+                    text = nextPeriodDate.format(DateTimeFormatter.ofPattern("d MMMM", Locale("ru"))),
+                    style = MaterialTheme.typography.titleMedium,
+                    fontWeight = FontWeight.Medium
+                )
+            }
+
+            Spacer(modifier = Modifier.height(8.dp))
+
+            // Информация об овуляции
+            val daysUntilOvulation = ChronoUnit.DAYS.between(LocalDate.now(), ovulationDate).toInt()
+
+            Row(
+                modifier = Modifier.fillMaxWidth(),
+                horizontalArrangement = Arrangement.SpaceBetween,
+                verticalAlignment = Alignment.CenterVertically
+            ) {
+                Column {
+                    Text(
+                        text = "Овуляция через",
+                        style = MaterialTheme.typography.bodyMedium
+                    )
+                    Text(
+                        text = "$daysUntilOvulation дней",
+                        style = MaterialTheme.typography.titleMedium,
+                        fontWeight = FontWeight.Bold,
+                        color = MaterialTheme.colorScheme.secondary
+                    )
+                }
+
+                Text(
+                    text = ovulationDate.format(DateTimeFormatter.ofPattern("d MMMM", Locale("ru"))),
+                    style = MaterialTheme.typography.titleMedium,
+                    fontWeight = FontWeight.Medium
+                )
+            }
+        }
+    }
+}
+
+@Composable
+private fun EnhancedHorizontalCalendar(
+    selectedDate: LocalDate,
+    events: Map<LocalDate, List<CalendarEvent>>,
+    predictions: CyclePrediction?,
+    onDateSelect: (LocalDate) -> Unit,
+    scrollState: androidx.compose.foundation.lazy.LazyListState
+) {
+    val today = LocalDate.now()
+
+    // Генерируем дни для показа (от -30 до +60 дней от сегодня)
+    val days = (-30..60).map { dayOffset ->
+        today.plusDays(dayOffset.toLong())
+    }
+
+    Column {
+        // Дни недели (заголовки)
+        Row(
+            modifier = Modifier.fillMaxWidth(),
+            horizontalArrangement = Arrangement.SpaceBetween
+        ) {
+            listOf("Пн", "Вт", "Ср", "Чт", "Пт", "Сб", "Вс").forEach { day ->
+                Text(
+                    text = day,
+                    style = MaterialTheme.typography.bodySmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                    modifier = Modifier.width(40.dp),
+                    textAlign = TextAlign.Center
+                )
+            }
+        }
+
+        Spacer(modifier = Modifier.height(8.dp))
+
+        // Календарь
+        LazyRow(
+            state = scrollState,
+            horizontalArrangement = Arrangement.spacedBy(4.dp),
+            modifier = Modifier.fillMaxWidth()
+        ) {
+            items(days) { date ->
+                EnhancedDayItem(
+                    date = date,
+                    isSelected = date.isEqual(selectedDate),
+                    isToday = date.isEqual(today),
+                    events = events[date] ?: emptyList(),
+                    predictions = predictions,
+                    onClick = { onDateSelect(date) }
+                )
+            }
+        }
+    }
+}
+
+@Composable
+private fun EnhancedDayItem(
+    date: LocalDate,
+    isSelected: Boolean,
+    isToday: Boolean,
+    events: List<CalendarEvent>,
+    predictions: CyclePrediction?,
+    onClick: () -> Unit
+) {
+    val isPeriodDay = predictions != null &&
+        DateUtils.isDateInRange(date, predictions.nextPeriodStart, predictions.nextPeriodEnd)
+
+    val isOvulationDay = predictions != null && date.isEqual(predictions.nextOvulation)
+
+    val isFertileDay = predictions != null &&
+        DateUtils.isDateInRange(date, predictions.fertileWindowStart, predictions.fertileWindowEnd) &&
+        !isOvulationDay
+
+    val backgroundColor = when {
+        isSelected -> MaterialTheme.colorScheme.primaryContainer
+        isToday -> MaterialTheme.colorScheme.secondaryContainer
+        isPeriodDay -> Color(0xFFFCE4EC).copy(alpha = 0.7f) // Светло-розовый
+        isOvulationDay -> Color(0xFFE3F2FD).copy(alpha = 0.7f) // Светло-голубой
+        isFertileDay -> Color(0xFFE0F7FA).copy(alpha = 0.7f) // Светло-бирюзовый
+        else -> MaterialTheme.colorScheme.surface
+    }
+
+    val borderColor = when {
+        isSelected -> MaterialTheme.colorScheme.primary
+        isToday -> MaterialTheme.colorScheme.secondary
+        else -> Color.Transparent
+    }
+
+    val textColor = when {
+        isSelected -> MaterialTheme.colorScheme.onPrimaryContainer
+        isToday -> MaterialTheme.colorScheme.onSecondaryContainer
+        isPeriodDay -> Color(0xFFE91E63) // Розовый
+        isOvulationDay -> Color(0xFF2196F3) // Голубой
+        isFertileDay -> Color(0xFF00BCD4) // Бирюзовый
+        else -> MaterialTheme.colorScheme.onSurface
+    }
+
+    Column(
+        horizontalAlignment = Alignment.CenterHorizontally,
+        modifier = Modifier
+            .width(40.dp)
+            .clip(RoundedCornerShape(8.dp))
+            .background(backgroundColor)
+            .border(
+                width = if (isSelected || isToday) 2.dp else 0.dp,
+                color = borderColor,
+                shape = RoundedCornerShape(8.dp)
+            )
+            .clickable { onClick() }
+            .padding(vertical = 8.dp, horizontal = 4.dp)
+    ) {
+        // День недели
+        Text(
+            text = date.format(DateTimeFormatter.ofPattern("EE", Locale("ru"))).take(1),
+            style = MaterialTheme.typography.bodySmall,
+            color = textColor.copy(alpha = 0.7f),
+            fontSize = 10.sp
+        )
+
+        // Число
+        Text(
+            text = date.dayOfMonth.toString(),
+            style = MaterialTheme.typography.bodyLarge,
+            fontWeight = if (isSelected || isToday) FontWeight.Bold else FontWeight.Normal,
+            color = textColor
+        )
+
+        // Индикаторы событий
+        if (events.isNotEmpty()) {
+            Spacer(modifier = Modifier.height(2.dp))
+            Row(
+                horizontalArrangement = Arrangement.Center,
+                modifier = Modifier.fillMaxWidth()
+            ) {
+                repeat(minOf(events.size, 3)) {
+                    Box(
+                        modifier = Modifier
+                            .padding(horizontal = 1.dp)
+                            .size(4.dp)
+                            .clip(CircleShape)
+                            .background(Color.Gray.copy(alpha = 0.7f))
+                    )
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun EnhancedDateDetail(
+    selectedDate: LocalDate,
+    events: List<CalendarEvent>,
+    predictions: CyclePrediction?,
+    onAddEvent: () -> Unit,
+    onEventClick: (CalendarEvent) -> Unit
+) {
+    val dateFormatter = DateTimeFormatter.ofPattern("d MMMM yyyy", Locale("ru"))
+
+    Column(
+        modifier = Modifier.fillMaxWidth()
+    ) {
+        // Заголовок с выбранной датой
+        Text(
+            text = selectedDate.format(dateFormatter),
+            style = MaterialTheme.typography.titleLarge,
+            fontWeight = FontWeight.Bold
+        )
+
+        Spacer(modifier = Modifier.height(8.dp))
+
+        // События на выбранную дату
+        if (events.isEmpty()) {
+            Card(
+                modifier = Modifier.fillMaxWidth(),
+                colors = CardDefaults.cardColors(
+                    containerColor = MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.5f)
+                )
+            ) {
+                Column(
+                    horizontalAlignment = Alignment.CenterHorizontally,
+                    modifier = Modifier.padding(16.dp)
+                ) {
+                    // Прогноз дня (если есть)
+                    val dayPrediction = getDayPrediction(selectedDate, predictions)
+                    if (dayPrediction.isNotEmpty()) {
+                        Text(
+                            text = dayPrediction,
+                            style = MaterialTheme.typography.bodyLarge,
+                            color = MaterialTheme.colorScheme.onSurfaceVariant
+                        )
+                        Spacer(modifier = Modifier.height(16.dp))
+                    } else {
+                        Text(
+                            text = "Нет событий на эту дату",
+                            style = MaterialTheme.typography.bodyLarge,
+                            color = MaterialTheme.colorScheme.onSurfaceVariant
+                        )
+                        Spacer(modifier = Modifier.height(16.dp))
+                    }
+
+                    Button(
+                        onClick = onAddEvent,
+                        colors = ButtonDefaults.buttonColors(
+                            containerColor = MaterialTheme.colorScheme.primary
+                        )
+                    ) {
+                        Icon(
+                            imageVector = Icons.Default.Add,
+                            contentDescription = null
+                        )
+                        Spacer(modifier = Modifier.width(8.dp))
+                        Text("Добавить запись")
+                    }
+                }
+            }
+        } else {
+            // События на этот день
+            LazyColumn(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .heightIn(max = 300.dp),
+                verticalArrangement = Arrangement.spacedBy(8.dp)
+            ) {
+                items(events) { event ->
+                    EventCard(
+                        event = event,
+                        onClick = { onEventClick(event) }
+                    )
+                }
+
+                item {
+                    Spacer(modifier = Modifier.height(8.dp))
+                    OutlinedButton(
+                        onClick = onAddEvent,
+                        modifier = Modifier.fillMaxWidth()
+                    ) {
+                        Icon(
+                            imageVector = Icons.Default.Add,
+                            contentDescription = null
+                        )
+                        Spacer(modifier = Modifier.width(8.dp))
+                        Text("Добавить запись")
+                    }
+                }
+            }
+        }
+    }
+}
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+private fun EventCard(
+    event: CalendarEvent,
+    onClick: () -> Unit
+) {
+    Card(
+        onClick = onClick,
+        modifier = Modifier.fillMaxWidth(),
+        colors = CardDefaults.cardColors(
+            containerColor = getEventBackgroundColor(event.type)
+        )
+    ) {
+        Row(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(16.dp),
+            verticalAlignment = Alignment.CenterVertically
+        ) {
+            // Иконка события
+            Box(
+                modifier = Modifier
+                    .size(40.dp)
+                    .clip(CircleShape)
+                    .background(getEventIconBackgroundColor(event.type)),
+                contentAlignment = Alignment.Center
+            ) {
+                Icon(
+                    imageVector = getEventIcon(event.type),
+                    contentDescription = null,
+                    tint = Color.White,
+                    modifier = Modifier.size(24.dp)
+                )
+            }
+
+            Spacer(modifier = Modifier.width(16.dp))
+
+            // Информация о событии
+            Column(
+                modifier = Modifier.weight(1f)
+            ) {
+                Text(
+                    text = getEventTitle(event.type),
+                    style = MaterialTheme.typography.titleMedium,
+                    fontWeight = FontWeight.SemiBold
+                )
+
+                // Дополнительная информация о событии
+                val details = getEventDetails(event)
+                if (details.isNotEmpty()) {
+                    Text(
+                        text = details,
+                        style = MaterialTheme.typography.bodyMedium,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant,
+                        maxLines = 2,
+                        overflow = TextOverflow.Ellipsis
+                    )
+                }
+            }
+
+            Spacer(modifier = Modifier.width(8.dp))
+
+            // Индикатор для перехода к деталям
+            Icon(
+                imageVector = Icons.Default.ChevronRight,
+                contentDescription = "Подробнее",
+                tint = MaterialTheme.colorScheme.onSurfaceVariant
+            )
+        }
+    }
+}
+
+@Composable
+private fun UpcomingEventsCard(
+    events: List<Pair<LocalDate, String>>
+) {
+    Card(
+        modifier = Modifier.fillMaxWidth(),
+        colors = CardDefaults.cardColors(
+            containerColor = MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.3f)
+        )
+    ) {
+        Column(
+            modifier = Modifier.padding(16.dp)
+        ) {
+            Text(
+                text = "Предстоящие события",
+                style = MaterialTheme.typography.titleMedium,
+                fontWeight = FontWeight.Bold
+            )
+
+            Spacer(modifier = Modifier.height(12.dp))
+
+            events.forEach { (date, description) ->
+                Row(
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .padding(vertical = 6.dp),
+                    verticalAlignment = Alignment.CenterVertically
+                ) {
+                    val daysUntil = ChronoUnit.DAYS.between(LocalDate.now(), date).toInt()
+                    val dateString = when {
+                        daysUntil == 0 -> "Сегодня"
+                        daysUntil == 1 -> "Завтра"
+                        daysUntil == 2 -> "Послезавтра"
+                        else -> "Через $daysUntil дней"
+                    }
+
+                    Column(modifier = Modifier.weight(1f)) {
+                        Text(
+                            text = description,
+                            style = MaterialTheme.typography.bodyLarge,
+                            fontWeight = FontWeight.Medium
+                        )
+                        Text(
+                            text = "$dateString (${date.format(DateTimeFormatter.ofPattern("d MMMM", Locale("ru")))})",
+                            style = MaterialTheme.typography.bodySmall,
+                            color = MaterialTheme.colorScheme.onSurfaceVariant
+                        )
+                    }
+
+                    val reminderColor = when {
+                        daysUntil <= 2 -> MaterialTheme.colorScheme.primary
+                        else -> MaterialTheme.colorScheme.outline
+                    }
+
+                    Icon(
+                        imageVector = Icons.Default.Notifications,
+                        contentDescription = null,
+                        tint = reminderColor,
+                        modifier = Modifier.size(20.dp)
+                    )
+                }
+
+                if (events.indexOf(Pair(date, description)) < events.size - 1) {
+                    Divider(modifier = Modifier.padding(vertical = 4.dp))
+                }
+            }
+        }
+    }
+}
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+private fun EnhancedEventDialog(
+    selectedDate: LocalDate,
+    existingEvent: CalendarEvent? = null,
+    onDismiss: () -> Unit,
+    onSaveEvent: (CalendarEvent?, EntryType, FlowIntensity?, Mood?, List<Symptom>?, List<String>?, String?, Int?, Float?) -> Unit
+) {
+    val isEditMode = existingEvent != null
+
+    var selectedEntryType by remember {
+        mutableStateOf(existingEvent?.type?.let { EntryType.valueOf(it.uppercase()) } ?: EntryType.PERIOD)
+    }
+    var selectedFlowIntensity by remember {
+        mutableStateOf(existingEvent?.flowIntensity?.let { FlowIntensity.valueOf(it.uppercase()) })
+    }
+    var selectedMood by remember {
+        mutableStateOf(existingEvent?.mood?.let { Mood.valueOf(it.uppercase()) })
+    }
+    var selectedSymptoms by remember {
+        mutableStateOf(existingEvent?.symptoms?.map { Symptom.valueOf(it.uppercase()) }?.toSet() ?: emptySet())
+    }
+    var notes by remember { mutableStateOf(existingEvent?.notes ?: "") }
+    var medications by remember { mutableStateOf(existingEvent?.medications?.joinToString(", ") ?: "") }
+    var energyLevel by remember { mutableStateOf(existingEvent?.energyLevel?.toString() ?: "") }
+    var sleepHours by remember { mutableStateOf(existingEvent?.sleepHours?.toString() ?: "") }
+
+    var showSymptomPicker by remember { mutableStateOf(false) }
+
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        title = {
+            Text(
+                text = if (isEditMode) "Редактировать запись" else "Добавить запись",
+                style = MaterialTheme.typography.headlineSmall
+            )
+        },
+        text = {
+            Column(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .verticalScroll(rememberScrollState()),
+                verticalArrangement = Arrangement.spacedBy(16.dp)
+            ) {
+                // Дата
+                Text(
+                    text = "Дата: ${selectedDate.format(DateTimeFormatter.ofPattern("d MMMM yyyy", Locale("ru")))}",
+                    style = MaterialTheme.typography.bodyLarge,
+                    fontWeight = FontWeight.Medium
+                )
+
+                // Тип записи
+                Text(
+                    text = "Тип записи",
+                    style = MaterialTheme.typography.labelLarge
+                )
+
+                Row(
+                    modifier = Modifier.fillMaxWidth(),
+                    horizontalArrangement = Arrangement.spacedBy(8.dp)
+                ) {
+                    EntryTypeFilterChip(
+                        type = EntryType.PERIOD,
+                        selected = selectedEntryType == EntryType.PERIOD,
+                        onSelect = { selectedEntryType = EntryType.PERIOD },
+                        modifier = Modifier.weight(1f)
+                    )
+
+                    EntryTypeFilterChip(
+                        type = EntryType.SYMPTOMS,
+                        selected = selectedEntryType == EntryType.SYMPTOMS,
+                        onSelect = { selectedEntryType = EntryType.SYMPTOMS },
+                        modifier = Modifier.weight(1f)
+                    )
+                }
+
+                Row(
+                    modifier = Modifier.fillMaxWidth(),
+                    horizontalArrangement = Arrangement.spacedBy(8.dp)
+                ) {
+                    EntryTypeFilterChip(
+                        type = EntryType.MEDICATION,
+                        selected = selectedEntryType == EntryType.MEDICATION,
+                        onSelect = { selectedEntryType = EntryType.MEDICATION },
+                        modifier = Modifier.weight(1f)
+                    )
+
+                    EntryTypeFilterChip(
+                        type = EntryType.NOTE,
+                        selected = selectedEntryType == EntryType.NOTE,
+                        onSelect = { selectedEntryType = EntryType.NOTE },
+                        modifier = Modifier.weight(1f)
+                    )
+                }
+
+                // Интенсивность (только для месячных)
+                AnimatedVisibility(
+                    visible = selectedEntryType == EntryType.PERIOD,
+                    enter = fadeIn() + expandVertically(
+                        animationSpec = spring(
+                            dampingRatio = Spring.DampingRatioMediumBouncy,
+                            stiffness = Spring.StiffnessLow
+                        )
+                    ),
+                    exit = fadeOut() + shrinkVertically()
+                ) {
+                    Column {
+                        Text(
+                            text = "Интенсивность",
+                            style = MaterialTheme.typography.labelLarge
+                        )
+
+                        Spacer(modifier = Modifier.height(4.dp))
+
+                        Row(
+                            modifier = Modifier.fillMaxWidth(),
+                            horizontalArrangement = Arrangement.SpaceBetween
+                        ) {
+                            FlowIntensity.values().forEach { intensity ->
+                                FilterChip(
+                                    selected = selectedFlowIntensity == intensity,
+                                    onClick = { selectedFlowIntensity = intensity },
+                                    label = {
+                                        Text(
+                                            text = getFlowIntensityLabel(intensity),
+                                            fontSize = 11.sp
+                                        )
+                                    },
+                                    colors = FilterChipDefaults.filterChipColors(
+                                        selectedContainerColor = getFlowIntensityColor(intensity)
+                                    )
+                                )
+                            }
+                        }
+                    }
+                }
+
+                // Настроение
+                Column {
+                    Text(
+                        text = "Настроение",
+                        style = MaterialTheme.typography.labelLarge
+                    )
+
+                    Spacer(modifier = Modifier.height(4.dp))
+
+                    LazyRow(
+                        horizontalArrangement = Arrangement.spacedBy(8.dp)
+                    ) {
+                        items(Mood.values()) { mood ->
+                            FilterChip(
+                                selected = selectedMood == mood,
+                                onClick = {
+                                    selectedMood = if (selectedMood == mood) null else mood
+                                },
+                                label = {
+                                    Text(
+                                        text = "${getMoodEmoji(mood)} ${getMoodLabel(mood)}",
+                                        fontSize = 12.sp
+                                    )
+                                }
+                            )
+                        }
+                    }
+                }
+
+                // Симптомы
+                Column {
+                    Row(
+                        modifier = Modifier.fillMaxWidth(),
+                        horizontalArrangement = Arrangement.SpaceBetween,
+                        verticalAlignment = Alignment.CenterVertically
+                    ) {
+                        Text(
+                            text = "Симптомы (${selectedSymptoms.size})",
+                            style = MaterialTheme.typography.labelLarge
+                        )
+
+                        TextButton(onClick = { showSymptomPicker = !showSymptomPicker }) {
+                            Text(if (showSymptomPicker) "Скрыть" else "Выбрать")
+                        }
+                    }
+
+                    AnimatedVisibility(
+                        visible = showSymptomPicker,
+                        enter = fadeIn() + expandVertically(),
+                        exit = fadeOut() + shrinkVertically()
+                    ) {
+                        Column {
+                            Symptom.values().forEach { symptom ->
+                                Row(
+                                    modifier = Modifier
+                                        .fillMaxWidth()
+                                        .padding(vertical = 4.dp),
+                                    verticalAlignment = Alignment.CenterVertically
+                                ) {
+                                    Checkbox(
+                                        checked = selectedSymptoms.contains(symptom),
+                                        onCheckedChange = { checked ->
+                                            selectedSymptoms = if (checked) {
+                                                selectedSymptoms + symptom
+                                            } else {
+                                                selectedSymptoms - symptom
+                                            }
+                                        }
+                                    )
+
+                                    Text(
+                                        text = getSymptomLabel(symptom),
+                                        style = MaterialTheme.typography.bodyMedium
+                                    )
+                                }
+                            }
+                        }
+                    }
+
+                    if (selectedSymptoms.isNotEmpty() && !showSymptomPicker) {
+                        Spacer(modifier = Modifier.height(8.dp))
+                        Row(
+                            horizontalArrangement = Arrangement.spacedBy(8.dp)
+                        ) {
+                            selectedSymptoms.forEach { symptom ->
+                                AssistChip(
+                                    onClick = { },
+                                    label = {
+                                        Text(
+                                            text = getSymptomLabel(symptom),
+                                            fontSize = 12.sp
+                                        )
+                                    },
+                                    leadingIcon = {
+                                        Icon(
+                                            imageVector = Icons.Default.Check,
+                                            contentDescription = null,
+                                            modifier = Modifier.size(16.dp)
+                                        )
+                                    }
+                                )
+                            }
+                        }
+                    }
+                }
+
+                // Лекарства (если тип MEDICATION)
+                AnimatedVisibility(visible = selectedEntryType == EntryType.MEDICATION) {
+                    OutlinedTextField(
+                        value = medications,
+                        onValueChange = { medications = it },
+                        label = { Text("Принятые лекарства") },
+                        modifier = Modifier.fillMaxWidth(),
+                        placeholder = { Text("Например: Ибупрофен, Парацетамол") }
+                    )
+                }
+
+                // Уровень энергии
+                Column {
+                    Text(
+                        text = "Уровень энергии",
+                        style = MaterialTheme.typography.labelLarge
+                    )
+
+                    Spacer(modifier = Modifier.height(8.dp))
+
+                    Row(
+                        modifier = Modifier.fillMaxWidth(),
+                        horizontalArrangement = Arrangement.SpaceEvenly
+                    ) {
+                        (1..5).forEach { level ->
+                            FilterChip(
+                                selected = energyLevel == level.toString(),
+                                onClick = {
+                                    energyLevel = if (energyLevel == level.toString()) "" else level.toString()
+                                },
+                                label = {
+                                    Text(
+                                        text = when(level) {
+                                            1 -> "Очень низкий"
+                                            2 -> "Низкий"
+                                            3 -> "Средний"
+                                            4 -> "Высокий"
+                                            5 -> "Очень высокий"
+                                            else -> level.toString()
+                                        },
+                                        fontSize = 12.sp
+                                    )
+                                }
+                            )
+                        }
+                    }
+                }
+
+                // Сон
+                OutlinedTextField(
+                    value = sleepHours,
+                    onValueChange = { sleepHours = it },
+                    label = { Text("Сон (часы)") },
+                    modifier = Modifier.fillMaxWidth(),
+                    placeholder = { Text("Например: 8") }
+                )
+
+                // Заметки
+                OutlinedTextField(
+                    value = notes,
+                    onValueChange = { notes = it },
+                    label = { Text("Заметки") },
+                    modifier = Modifier.fillMaxWidth(),
+                    minLines = 3
+                )
+            }
+        },
+        confirmButton = {
+            Button(
+                onClick = {
+                    onSaveEvent(
+                        existingEvent,
+                        selectedEntryType,
+                        selectedFlowIntensity,
+                        selectedMood,
+                        selectedSymptoms.toList(),
+                        if (medications.isBlank()) emptyList() else medications.split(",").map { it.trim() },
+                        notes.takeIf { it.isNotBlank() },
+                        energyLevel.toIntOrNull(),
+                        sleepHours.toFloatOrNull()
+                    )
+                }
+            ) {
+                Text(if (isEditMode) "Сохранить" else "Добавить")
+            }
+        },
+        dismissButton = {
+            TextButton(onClick = onDismiss) {
+                Text("Отмена")
+            }
+        }
+    )
+}
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+private fun EntryTypeFilterChip(
+    type: EntryType,
+    selected: Boolean,
+    onSelect: () -> Unit,
+    modifier: Modifier = Modifier
+) {
+    FilterChip(
+        selected = selected,
+        onClick = onSelect,
+        label = {
+            Text(
+                text = getEntryTypeLabel(type),
+                fontSize = 13.sp
+            )
+        },
+        leadingIcon = {
+            Icon(
+                imageVector = getEventIcon(type.toString()),
+                contentDescription = null,
+                modifier = Modifier.size(18.dp)
+            )
+        },
+        modifier = modifier
+    )
+}
+
+// Вспомогательные функции
+private fun getDayPrediction(date: LocalDate, predictions: CyclePrediction?): String {
+    if (predictions == null) return ""
+
+    return when {
+        date.isEqual(predictions.nextPeriodStart) -> "Начало месячных"
+        DateUtils.isDateInRange(date, predictions.nextPeriodStart, predictions.nextPeriodEnd) -> "Месячные"
+        date.isEqual(predictions.nextOvulation) -> "Овуляция"
+        DateUtils.isDateInRange(date, predictions.fertileWindowStart, predictions.fertileWindowEnd) -> "Фертильный день"
+        else -> ""
+    }
+}
+
+private fun getUpcomingEvents(predictions: CyclePrediction): List<Pair<LocalDate, String>> {
+    val today = LocalDate.now()
+    val events = mutableListOf<Pair<LocalDate, String>>()
+
+    if (today.isBefore(predictions.nextPeriodStart) || today.isEqual(predictions.nextPeriodStart)) {
+        events.add(Pair(predictions.nextPeriodStart, "Начало месячных"))
+    }
+
+    if (today.isBefore(predictions.nextOvulation) || today.isEqual(predictions.nextOvulation)) {
+        events.add(Pair(predictions.nextOvulation, "Овуляция"))
+    }
+
+    if (today.isBefore(predictions.fertileWindowStart) || today.isEqual(predictions.fertileWindowStart)) {
+        events.add(Pair(predictions.fertileWindowStart, "Начало фертильного окна"))
+    }
+
+    return events.sortedBy { it.first }
+}
+
+@Composable
+private fun getEventBackgroundColor(type: String): Color {
+    return when (type.lowercase()) {
+        "period" -> Color(0xFFFCE4EC).copy(alpha = 0.3f) // Светло-розовый
+        "ovulation" -> Color(0xFFE3F2FD).copy(alpha = 0.3f) // Светло-голубой
+        "symptoms" -> Color(0xFFFFF9C4).copy(alpha = 0.3f) // Светло-желтый
+        "medication" -> Color(0xFFE1F5FE).copy(alpha = 0.3f) // Светло-голубой
+        "note" -> Color(0xFFF5F5F5).copy(alpha = 0.3f) // Светло-серый
+        "appointment" -> Color(0xFFE8F5E9).copy(alpha = 0.3f) // Светло-зеленый
+        else -> MaterialTheme.colorScheme.surface
+    }
+}
+
+@Composable
+private fun getEventIconBackgroundColor(type: String): Color {
+    return when (type.lowercase()) {
+        "period" -> Color(0xFFE91E63) // Розовый
+        "ovulation" -> Color(0xFF2196F3) // Голубой
+        "symptoms" -> Color(0xFFFFC107) // Желтый
+        "medication" -> Color(0xFF9C27B0) // Фиолетовый
+        "note" -> Color(0xFF607D8B) // Серо-синий
+        "appointment" -> Color(0xFF4CAF50) // Зеленый
+        else -> Color.Gray
+    }
+}
+
+private fun getEventIcon(type: String): androidx.compose.ui.graphics.vector.ImageVector {
+    return when (type.lowercase()) {
+        "period" -> Icons.Default.Opacity
+        "ovulation" -> Icons.Default.Star
+        "symptoms" -> Icons.Default.Healing
+        "medication" -> Icons.Default.LocalPharmacy
+        "note" -> Icons.Default.Notes
+        "appointment" -> Icons.Default.Event
+        else -> Icons.Default.Check
+    }
+}
+
+private fun getEventTitle(type: String): String {
+    return when (type.lowercase()) {
+        "period" -> "Месячные"
+        "ovulation" -> "Овуляция"
+        "symptoms" -> "Симптомы"
+        "medication" -> "Лекарства"
+        "note" -> "Заметка"
+        "appointment" -> "Приём врача"
+        else -> type.replaceFirstChar { if (it.isLowerCase()) it.titlecase(Locale.getDefault()) else it.toString() }
+    }
+}
+
+private fun getEntryTypeLabel(type: EntryType): String {
+    return when (type) {
+        EntryType.PERIOD -> "Месячные"
+        EntryType.OVULATION -> "Овуляция"
+        EntryType.SYMPTOMS -> "Симптомы"
+        EntryType.MEDICATION -> "Лекарства"
+        EntryType.NOTE -> "Заметка"
+        EntryType.APPOINTMENT -> "Приём врача"
+    }
+}
+
+private fun getEventDetails(event: CalendarEvent): String {
+    val details = mutableListOf<String>()
+
+    event.flowIntensity?.let {
+        details.add("Интенсивность: ${getFlowIntensityLabel(FlowIntensity.valueOf(it.uppercase()))}")
+    }
+
+    event.mood?.let {
+        details.add("Настроение: ${getMoodLabel(Mood.valueOf(it.uppercase()))}")
+    }
+
+    event.symptoms?.takeIf { it.isNotEmpty() }?.let {
+        details.add("Симптомы: ${it.size}")
+    }
+
+    event.notes?.takeIf { it.isNotBlank() }?.let {
+        details.add(it)
+    }
+
+    return details.joinToString(" · ")
+}
+
+private fun getFlowIntensityLabel(intensity: FlowIntensity): String {
+    return when (intensity) {
+        FlowIntensity.SPOTTING -> "Мажущие"
+        FlowIntensity.LIGHT -> "Легкие"
+        FlowIntensity.MEDIUM -> "Средние"
+        FlowIntensity.HEAVY -> "Сильные"
+        FlowIntensity.VERY_HEAVY -> "Очень сильные"
+        else -> "Неизвестно"
+    }
+}
+
+private fun getFlowIntensityColor(intensity: FlowIntensity): Color {
+    return when (intensity) {
+        FlowIntensity.SPOTTING -> Color(0xFFFCE4EC)
+        FlowIntensity.LIGHT -> Color(0xFFF8BBD0)
+        FlowIntensity.MEDIUM -> Color(0xFFF06292)
+        FlowIntensity.HEAVY -> Color(0xFFEC407A)
+        FlowIntensity.VERY_HEAVY -> Color(0xFFD81B60)
+    }
+}
+
+private fun getMoodLabel(mood: Mood): String {
+    return when (mood) {
+        Mood.VERY_HAPPY -> "Отлично"
+        Mood.HAPPY -> "Хорошо"
+        Mood.NEUTRAL -> "Нормально"
+        Mood.SAD -> "Грустно"
+        Mood.VERY_SAD -> "Очень грустно"
+        Mood.ANXIOUS -> "Тревожно"
+        Mood.IRRITABLE -> "Раздражительность"
+        Mood.CALM -> "Спокойно"
+        Mood.ENERGETIC -> "Энергично"
+        Mood.TIRED -> "Устало"
+        else -> "Неизвестно"
+    }
+}
+
+private fun getMoodEmoji(mood: Mood): String {
+    return when (mood) {
+        Mood.VERY_HAPPY -> "😀"
+        Mood.HAPPY -> "🙂"
+        Mood.NEUTRAL -> "😐"
+        Mood.SAD -> "🙁"
+        Mood.VERY_SAD -> "😢"
+        Mood.ANXIOUS -> "😰"
+        Mood.IRRITABLE -> "😠"
+        Mood.CALM -> "😌"
+        Mood.ENERGETIC -> "⚡"
+        Mood.TIRED -> "😴"
+        else -> "❓"
+    }
+}
+
+private fun getSymptomLabel(symptom: Symptom): String {
+    return when (symptom) {
+        Symptom.CRAMPS -> "Спазмы"
+        Symptom.HEADACHE -> "Головная боль"
+        Symptom.BACKACHE -> "Боль в спине"
+        Symptom.NAUSEA -> "Тошнота"
+        Symptom.FATIGUE -> "Усталость"
+        Symptom.BLOATING -> "Вздутие"
+        Symptom.BREAST_TENDERNESS -> "Болезненность груди"
+        Symptom.ACNE -> "Высыпания"
+        Symptom.MOOD_SWINGS -> "Перепады настроения"
+        Symptom.CRAVINGS -> "Тяга к еде"
+        Symptom.INSOMNIA -> "Бессонница"
+        Symptom.DIZZINESS -> "Головокружение"
+        Symptom.CONSTIPATION -> "Запор"
+        Symptom.DIARRHEA -> "Диарея"
+        Symptom.HOT_FLASHES -> "Приливы"
+        Symptom.SPOTTING -> "Мажущие выделения"
+    }
+}
diff --git a/app/src/main/java/com/example/womansafe/ui/screens/MainScreen.kt b/app/src/main/java/com/example/womansafe/ui/screens/MainScreen.kt
index 145362b..164563b 100644
--- a/app/src/main/java/com/example/womansafe/ui/screens/MainScreen.kt
+++ b/app/src/main/java/com/example/womansafe/ui/screens/MainScreen.kt
@@ -3,7 +3,9 @@ package com.example.womansafe.ui.screens
 import androidx.compose.foundation.layout.*
 import androidx.compose.material3.*
 import androidx.compose.runtime.*
+import androidx.compose.runtime.livedata.observeAsState
 import androidx.compose.ui.Modifier
+import androidx.lifecycle.viewmodel.compose.viewModel
 import androidx.navigation.NavHostController
 import androidx.navigation.compose.NavHost
 import androidx.navigation.compose.composable
@@ -15,6 +17,7 @@ import com.example.womansafe.ui.viewmodel.CalendarViewModel
 import com.example.womansafe.ui.viewmodel.EmergencyContactsViewModel
 import com.example.womansafe.ui.viewmodel.EmergencyViewModel
 import com.example.womansafe.ui.viewmodel.ProfileSettingsViewModel
+import java.time.LocalDate
 
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
@@ -51,6 +54,9 @@ private fun MainNavHost(
     authViewModel: AuthViewModel,
     modifier: Modifier = Modifier
 ) {
+    // Создаем ViewModel для календаря здесь для общего доступа
+    val calendarViewModel: CalendarViewModel = viewModel()
+
     NavHost(
         navController = navController,
         startDestination = BottomNavItem.Home.route,
@@ -64,8 +70,12 @@ private fun MainNavHost(
             EmergencyScreen(emergencyViewModel = EmergencyViewModel())
         }
 
+        // Заменяем прямой вызов CalendarScreen на вложенную навигацию
         composable(BottomNavItem.Calendar.route) {
-            CalendarScreen(calendarViewModel = CalendarViewModel())
+            CalendarNavigation(
+                calendarViewModel = calendarViewModel,
+                navController = navController
+            )
         }
 
         composable(BottomNavItem.Profile.route) {
@@ -78,7 +88,10 @@ private fun MainNavHost(
 
         // Дополнительные экраны
         composable("emergency_contacts") {
-            EmergencyContactsScreen(emergencyContactsViewModel = EmergencyContactsViewModel())
+            EmergencyContactsScreen(
+                emergencyContactsViewModel = EmergencyContactsViewModel(),
+                onNavigateToContactPicker = { navController.navigate("contact_picker") }
+            )
         }
 
         composable("profile_settings") {
@@ -87,5 +100,45 @@ private fun MainNavHost(
                 onNavigateBack = { navController.popBackStack() }
             )
         }
+
+        // Экраны календаря
+        composable("calendar_entry/{date}") { backStackEntry ->
+            val dateString = backStackEntry.arguments?.getString("date") ?: LocalDate.now().toString()
+            val date = LocalDate.parse(dateString)
+
+            CalendarEntryScreen(
+                viewModel = calendarViewModel,
+                selectedDate = date,
+                onClose = { navController.popBackStack() }
+            )
+        }
+
+        composable("calendar_insights") {
+            CalendarInsightsScreen(
+                viewModel = calendarViewModel,
+                onBackClick = { navController.popBackStack() }
+            )
+        }
     }
 }
+
+/**
+ * Вложенная навигация для календаря
+ */
+@Composable
+fun CalendarNavigation(
+    calendarViewModel: CalendarViewModel,
+    navController: NavHostController
+) {
+    val selectedDate by calendarViewModel.selectedDate.observeAsState(LocalDate.now())
+
+    CalendarScreen(
+        viewModel = calendarViewModel,
+        onAddEntryClick = { date ->
+            navController.navigate("calendar_entry/${date}")
+        },
+        onViewInsightsClick = {
+            navController.navigate("calendar_insights")
+        }
+    )
+}
diff --git a/app/src/main/java/com/example/womansafe/ui/theme/AppColors.kt b/app/src/main/java/com/example/womansafe/ui/theme/AppColors.kt
new file mode 100644
index 0000000..4a84359
--- /dev/null
+++ b/app/src/main/java/com/example/womansafe/ui/theme/AppColors.kt
@@ -0,0 +1,33 @@
+package com.example.womansafe.ui.theme
+
+import androidx.compose.ui.graphics.Color
+
+/**
+ * Цвета приложения для использования в EnhancedCalendarScreen и других компонентах
+ */
+object AppColors {
+    // Основные цвета приложения
+    val PrimaryPink = Color(0xFFE91E63)
+    val SecondaryBlue = Color(0xFF2196F3)
+    val TertiaryGreen = Color(0xFF4CAF50)
+
+    // Цвета для индикаторов менструального цикла
+    val PeriodColor = Color(0xFFE91E63)
+    val PeriodLightColor = Color(0xFFF8BBD0)
+    val OvulationColor = Color(0xFF2196F3)
+    val OvulationLightColor = Color(0xFFBBDEFB)
+    val FertileColor = Color(0xFF00BCD4)
+    val FertileLightColor = Color(0xFFB2EBF2)
+
+    // Цвета настроений
+    val HappyColor = Color(0xFF4CAF50)
+    val NeutralColor = Color(0xFF9E9E9E)
+    val SadColor = Color(0xFF9C27B0)
+    val IrritatedColor = Color(0xFFFF5722)
+    val AnxiousColor = Color(0xFFFFEB3B)
+
+    // Цвета для симптомов
+    val SymptomColor = Color(0xFFFFC107)
+    val MedicationColor = Color(0xFF673AB7)
+    val NoteColor = Color(0xFF607D8B)
+}
diff --git a/app/src/main/java/com/example/womansafe/ui/viewmodel/AuthViewModel.kt b/app/src/main/java/com/example/womansafe/ui/viewmodel/AuthViewModel.kt
index 366b92d..05adb0f 100644
--- a/app/src/main/java/com/example/womansafe/ui/viewmodel/AuthViewModel.kt
+++ b/app/src/main/java/com/example/womansafe/ui/viewmodel/AuthViewModel.kt
@@ -23,15 +23,24 @@ class AuthViewModel : ViewModel() {
             try {
                 // Определяем, что введено - email или username
                 val isEmail = usernameOrEmail.contains("@")
+                println("=== LOGIN ATTEMPT ===")
+                println("Input: $usernameOrEmail, isEmail: $isEmail")
+
                 val response = repository.login(
                     email = if (isEmail) usernameOrEmail else null,
                     username = if (!isEmail) usernameOrEmail else null,
                     password = password
                 )
 
+                println("Login Response Code: ${response.code()}")
+                println("Login Response Message: ${response.message()}")
+                println("Login Response Body: ${response.body()}")
+                println("Login Response Error Body: ${response.errorBody()?.string()}")
+
                 if (response.isSuccessful) {
                     val token = response.body()
                     token?.let {
+                        println("Login Success: Token received - ${it.accessToken.take(10)}...")
                         NetworkClient.setAuthToken(it.accessToken)
                         uiState = uiState.copy(
                             isLoading = false,
@@ -41,14 +50,33 @@ class AuthViewModel : ViewModel() {
                         )
                         // Получаем профиль пользователя сразу после успешного входа
                         getCurrentUser()
+                    } ?: run {
+                        println("Login Error: Token is null in successful response")
+                        uiState = uiState.copy(
+                            isLoading = false,
+                            error = "Ошибка авторизации: Получен пустой токен"
+                        )
                     }
                 } else {
+                    val errorBody = response.errorBody()?.string() ?: "Неизвестная ошибка"
+                    println("Login Error: ${response.code()} - $errorBody")
+
+                    // Более специфичные сообщения для разных кодов ошибок
+                    val errorMessage = when (response.code()) {
+                        401 -> "Неверный логин или пароль"
+                        403 -> "Доступ запрещен"
+                        404 -> "Пользователь не найден"
+                        else -> "Ошибка авторизации: ${response.code()} - $errorBody"
+                    }
+
                     uiState = uiState.copy(
                         isLoading = false,
-                        error = "Ошибка авторизации: ${response.code()} - ${response.message()}"
+                        error = errorMessage
                     )
                 }
             } catch (e: Exception) {
+                println("Login Exception: ${e.message}")
+                e.printStackTrace()
                 uiState = uiState.copy(
                     isLoading = false,
                     error = "Ошибка сети: ${e.message}"
@@ -61,6 +89,10 @@ class AuthViewModel : ViewModel() {
         viewModelScope.launch {
             uiState = uiState.copy(isLoading = true, error = null)
             try {
+                println("=== REGISTER ATTEMPT ===")
+                println("Username: $username, Email: $email, Full Name: $fullName, Phone Number: $phoneNumber")
+                println("Password length: ${password.length}")
+
                 val response = repository.register(
                     email = email,
                     username = username,
@@ -69,26 +101,68 @@ class AuthViewModel : ViewModel() {
                     phoneNumber = phoneNumber
                 )
 
+                println("Register Response Code: ${response.code()}")
+                println("Register Response Message: ${response.message()}")
+                println("Register Response Body: ${response.body()}")
+                println("Register Response Error Body: ${response.errorBody()?.string()}")
+
                 if (response.isSuccessful) {
                     val userResponse = response.body()
                     userResponse?.let {
+                        println("Registration Success: User ID: ${it.id}, Username: ${it.username}")
+
+                        // После успешной регистрации выполняем автоматический вход
+                        println("Attempting auto-login after registration")
+                        // Выбираем имя пользователя или email для входа
+                        val loginIdentifier = username.ifBlank { email }
+
                         uiState = uiState.copy(
                             isLoading = false,
-                            isLoggedIn = true,
-                            user = it,
-                            registrationSuccess = true
+                            user = it
+                        )
+
+                        // Выполняем автоматический вход
+                        login(loginIdentifier, password)
+                    } ?: run {
+                        println("Register Error: User object is null in successful response")
+                        uiState = uiState.copy(
+                            isLoading = false,
+                            error = "Ошибка регистрации: Получен пустой ответ"
                         )
                     }
                 } else {
+                    val errorBody = response.errorBody()?.string() ?: "Неизвестная ошибка"
+                    println("Register Error: ${response.code()} - $errorBody")
+
+                    // Более специфичные сообщения для разных кодов ошибок
+                    val errorMessage = when (response.code()) {
+                        400 -> {
+                            if (errorBody.contains("email", ignoreCase = true)) {
+                                "Этот email уже используется или имеет неверный формат"
+                            } else if (errorBody.contains("username", ignoreCase = true)) {
+                                "Это имя пользователя уже используется"
+                            } else if (errorBody.contains("password", ignoreCase = true)) {
+                                "Пароль не соответствует требованиям безопасности"
+                            } else {
+                                "Ошибка в отправленных данных: $errorBody"
+                            }
+                        }
+                        409 -> "Пользователь с таким email или именем уже существует"
+                        422 -> "Неверный формат данных: $errorBody"
+                        else -> "Ошибка регистрации: ${response.code()} - $errorBody"
+                    }
+
                     uiState = uiState.copy(
                         isLoading = false,
-                        error = "Ошибка регистрации: ${response.code()} - ${response.message()}"
+                        error = errorMessage
                     )
                 }
             } catch (e: Exception) {
+                println("Register Exception: ${e.message}")
+                e.printStackTrace()
                 uiState = uiState.copy(
                     isLoading = false,
-                    error = "Ошибка сети: ${e.message}"
+                    error = "Ошибка сети при регистрации: ${e.message}"
                 )
             }
         }
@@ -178,8 +252,43 @@ class AuthViewModel : ViewModel() {
         }
     }
 
+    // Метод для автоматического входа с использованием сохраненного токена
+    fun autoLogin(token: String) {
+        viewModelScope.launch {
+            uiState = uiState.copy(isLoading = true, error = null)
+            try {
+                println("=== AUTO LOGIN ATTEMPT ===")
+                println("Using saved token: ${token.take(10)}...")
+
+                // Устанавливаем токен в NetworkClient
+                NetworkClient.setAuthToken(token)
+
+                // Устанавливаем состояние авторизации
+                uiState = uiState.copy(
+                    isLoading = false,
+                    isLoggedIn = true,
+                    token = token
+                )
+
+                // Получаем профиль пользователя
+                getCurrentUser()
+            } catch (e: Exception) {
+                println("Auto Login Exception: ${e.message}")
+                e.printStackTrace()
+
+                // В случае ошибки сбрасываем токен и состояние
+                NetworkClient.clearAuthToken()
+                uiState = uiState.copy(
+                    isLoading = false,
+                    error = "Ошибка автоматического входа: ${e.message}"
+                )
+            }
+        }
+    }
+
     fun logout() {
-        NetworkClient.setAuthToken(null)
+        // Очищаем токен в NetworkClient
+        NetworkClient.clearAuthToken()
         uiState = AuthUiState()
     }
 
diff --git a/app/src/main/java/com/example/womansafe/ui/viewmodel/CalendarViewModel.kt b/app/src/main/java/com/example/womansafe/ui/viewmodel/CalendarViewModel.kt
index 5caf4b7..9636fd4 100644
--- a/app/src/main/java/com/example/womansafe/ui/viewmodel/CalendarViewModel.kt
+++ b/app/src/main/java/com/example/womansafe/ui/viewmodel/CalendarViewModel.kt
@@ -1,572 +1,255 @@
 package com.example.womansafe.ui.viewmodel
 
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.setValue
-import androidx.lifecycle.ViewModel
+import android.app.Application
+import androidx.lifecycle.AndroidViewModel
+import androidx.lifecycle.LiveData
+import androidx.lifecycle.MutableLiveData
 import androidx.lifecycle.viewModelScope
-import com.example.womansafe.data.model.*
-import com.example.womansafe.data.repository.ApiRepository
-import kotlinx.coroutines.*
+import com.example.womansafe.data.api.CalendarApi
+import com.example.womansafe.data.local.CalendarDatabase
+import com.example.womansafe.data.model.calendar.*
+import com.example.womansafe.data.network.NetworkClient
+import com.example.womansafe.data.repository.CalendarRepository
+import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.launch
 import java.time.LocalDate
 import java.time.temporal.ChronoUnit
-import kotlin.math.abs
-import kotlin.math.min
-import kotlin.math.pow
-import kotlin.math.roundToInt
 
-data class CalendarUiState(
-    val isLoading: Boolean = false,
-    val currentMonth: LocalDate = LocalDate.now(),
-    val selectedDate: LocalDate = LocalDate.now(),
-    val events: Map<LocalDate, List<CalendarEvent>> = emptyMap(),
-    val predictions: CyclePrediction? = null,
-    val settings: CycleSettings = CycleSettings(),
-    val statistics: CycleStatistics? = null,
-    val showEventDialog: Boolean = false,
-    val showSettingsDialog: Boolean = false,
-    val error: String? = null,
-    val lastRefreshed: Long = 0 // Время последнего успешного обновления данных
-)
+/**
+ * ViewModel для функциональности менструального календаря
+ */
+class CalendarViewModel(application: Application) : AndroidViewModel(application) {
 
-class CalendarViewModel : ViewModel() {
-    private val repository = ApiRepository()
+    // Состояние UI
+    private val _calendarUiState = MutableLiveData(CalendarUiState())
+    val calendarUiState: LiveData<CalendarUiState> = _calendarUiState
 
-    var uiState by mutableStateOf(CalendarUiState())
-        private set
+    // Состояние загрузки
+    private val _isLoading = MutableLiveData(false)
+    val isLoading: LiveData<Boolean> = _isLoading
 
-    private var loadJob: Job? = null
-    private var retryCount = 0
-    private val maxRetryCount = 5
-    private val cacheValidityDuration = 30 * 60 * 1000 // 30 минут
-    private var debounceJob: Job? = null
+    // Сообщения об ошибках
+    private val _error = MutableLiveData<String?>(null)
+    val error: LiveData<String?> = _error
 
-    // Для определения, инициализирован ли ViewModel уже
-    private var initialized = false
+    // Дата, выбранная пользователем
+    private val _selectedDate = MutableLiveData(LocalDate.now())
+    val selectedDate: LiveData<LocalDate> = _selectedDate
 
-    companion object {
-        // Статические переменные для предотвращения одновременных запросов из разных экземпляров
-        @Volatile
-        private var isRequestInProgress = false
-        private var lastRefreshTimestamp = 0L
-        private const val GLOBAL_COOLDOWN = 2000L // Минимальный интервал между запросами (2 секунды)
-        // Максимальное количество неудачных запросов перед временным отключением
-        private const val MAX_ERROR_COUNT = 3
-        // Счетчик неудачных запросов
-        private var errorCount = 0
-        // Время последней ошибки
-        private var lastErrorTimestamp = 0L
-        // Интервал охлаждения при ошибках (увеличивается экспоненциально)
-        private var errorCooldownInterval = 5000L // Начинаем с 5 секунд
-    }
+    // Репозиторий для работы с данными календаря
+    private val repository: CalendarRepository
+
+    // Месяц, просматриваемый пользователем
+    private var viewingMonth: LocalDate = LocalDate.now()
 
     init {
-        // Добавляем небольшую задержку для предотвращения одновременных запросов
+        // Инициализация репозитория
+        val calendarApi = NetworkClient.createService(CalendarApi::class.java)
+        val calendarDao = CalendarDatabase.getDatabase(application).calendarDao()
+        repository = CalendarRepository(calendarDao, calendarApi)
+
+        // Загрузка данных
+        loadCalendarEntries()
+        loadCycleData()
+    }
+
+    /**
+     * Загрузка записей календаря
+     */
+    private fun loadCalendarEntries() {
         viewModelScope.launch {
-            delay(100L * (0..5).random()) // Случайная задержка до 500 мс
-            if (!initialized) {
-                initialized = true
-                loadInitialData()
-            }
-        }
-    }
-
-    private fun loadInitialData() {
-        debounceJob?.cancel()
-        debounceJob = viewModelScope.launch {
-            delay(300) // Добавляем задержку для дебаунсинга
-            loadCalendarData()
-            loadCycleSettings()
-        }
-    }
-
-    fun loadCalendarData() {
-        // Если запрос уже выполняется глобально, не начинаем новый
-        if (isRequestInProgress) {
-            return
-        }
-
-        // Глобальная проверка интервала между запросами
-        val now = System.currentTimeMillis()
-        if (now - lastRefreshTimestamp < GLOBAL_COOLDOWN) {
-            return
-        }
-
-        // Проверка интервала охлаждения при ошибках
-        if (errorCount >= MAX_ERROR_COUNT && now - lastErrorTimestamp < errorCooldownInterval) {
-            uiState = uiState.copy(
-                error = "Временное ограничение запросов из-за ошибок. Повторите через ${(errorCooldownInterval / 1000).toInt()} секунд."
-            )
-            return
-        }
-
-        // Если данные были обновлены недавно и это не первая загрузка, не делаем запрос
-        if (uiState.events.isNotEmpty() &&
-            now - uiState.lastRefreshed < cacheValidityDuration) {
-            return
-        }
-
-        // Отменяем предыдущий запрос и дебаунс, если они выполняются
-        loadJob?.cancel()
-        debounceJob?.cancel()
-
-        // Используем дебаунсинг для предотвращения частых запросов
-        debounceJob = viewModelScope.launch {
-            delay(300) // Задержка в 300 мс для дебаунсинга
-
-            loadJob = launch {
-                try {
-                    isRequestInProgress = true // Устанавливаем глобальный флаг запроса
-                    lastRefreshTimestamp = System.currentTimeMillis()
-
-                    uiState = uiState.copy(isLoading = true, error = null)
-
-                    // Загружаем события календаря
-                    val response = repository.getCalendarEntries()
-                    if (response.isSuccessful) {
-                        // Сбрасываем счетчики ошибок при успехе
-                        errorCount = 0
-                        errorCooldownInterval = 5000L // Сбрасываем до начального значения
-                        retryCount = 0
-
-                        // Обрабатываем ответ API
-                        response.body()?.let { calendarResponse ->
-                            // Преобразуем API ответ в объекты домена
-                            val events = processCalendarEntries(calendarResponse)
-
-                            // Обновляем настройки и прогнозы из данных API
-                            updateCycleInfoFromResponse(calendarResponse.cycle_info)
-
-                            // Генерируем прогнозы на основе данных
-                            generatePredictions()
-
-                            // Рассчитываем статистику
-                            calculateStatistics()
-
-                            // Обновляем состояние UI
-                            uiState = uiState.copy(
-                                isLoading = false,
-                                events = events,
-                                lastRefreshed = System.currentTimeMillis(),
-                                error = null
-                            )
-                        }
-                    } else if (response.code() == 429) {
-                        // Обработка Too Many Requests с экспоненциальным откатом
-                        handleRateLimitExceeded()
-                    } else {
-                        // Увеличиваем счетчик ошибок
-                        handleApiError(response.code().toString())
-                    }
-                } catch (e: Exception) {
-                    if (e is CancellationException) throw e
-
-                    // Увеличиваем счетчик ошибок
-                    handleApiError(e.message ?: "Неизвестная ошибка")
-                } finally {
-                    isRequestInProgress = false // Сбрасываем флаг в любом случае
-                }
-            }
-        }
-    }
-
-    private fun handleApiError(errorMsg: String) {
-        errorCount++
-        lastErrorTimestamp = System.currentTimeMillis()
-
-        // Экспоненциально увеличиваем время ожидания при повторных ошибках
-        if (errorCount >= MAX_ERROR_COUNT) {
-            errorCooldownInterval = (errorCooldownInterval * 2).coerceAtMost(60000L) // максимум 1 минута
-            uiState = uiState.copy(
-                isLoading = false,
-                error = "Ошибка API: $errorMsg. Повторные запросы ограничены на ${errorCooldownInterval/1000} сек."
-            )
-        } else {
-            uiState = uiState.copy(
-                isLoading = false,
-                error = "Ошибка API: $errorMsg"
-            )
-        }
-    }
-
-    // Преобразует API-ответ в события календаря
-    private fun processCalendarEntries(response: CalendarEntriesResponse): Map<LocalDate, List<CalendarEvent>> {
-        val result = mutableMapOf<LocalDate, MutableList<CalendarEvent>>()
-
-        response.entries.forEach { entry ->
+            _isLoading.value = true
             try {
-                val date = LocalDate.parse(entry.date)
-                val event = CalendarEvent(
-                    id = entry.id,
-                    date = date,
-                    type = CalendarEventType.valueOf(entry.type),
-                    isActual = !entry.is_predicted,
-                    isPredicted = entry.is_predicted,
-                    mood = entry.mood?.let { MoodType.valueOf(it) },
-                    symptoms = entry.symptoms.mapNotNull {
-                        try { SymptomType.valueOf(it) } catch (e: Exception) { null }
-                    },
-                    notes = entry.notes ?: "",
-                    flowIntensity = entry.flow_intensity
-                )
-
-                if (result.containsKey(date)) {
-                    result[date]?.add(event)
-                } else {
-                    result[date] = mutableListOf(event)
+                // Получение записей из репозитория как Flow
+                repository.getCalendarEntriesFlow("userId").collect { entries: List<CalendarEntry> ->
+                    updateCalendarStateWithEntries(entries)
                 }
             } catch (e: Exception) {
-                // Пропускаем некорректные записи
-                println("Ошибка обработки записи календаря: ${e.message}")
+                _error.value = "Ошибка при загрузке записей: ${e.localizedMessage}"
+            } finally {
+                _isLoading.value = false
             }
         }
-
-        return result
     }
 
-    // Обновляет информацию о цикле из API-ответа
-    private fun updateCycleInfoFromResponse(cycleInfo: CycleInfoResponse) {
-        val lastPeriodStart = try {
-            cycleInfo.last_period_start?.let { LocalDate.parse(it) }
-        } catch (e: Exception) { null }
-
-        val newSettings = uiState.settings.copy(
-            averageCycleLength = cycleInfo.average_cycle_length,
-            averagePeriodLength = cycleInfo.average_period_length,
-            lastPeriodStart = lastPeriodStart
-        )
-
-        uiState = uiState.copy(settings = newSettings)
-    }
-
-    private suspend fun handleRateLimitExceeded() {
-        if (retryCount < maxRetryCount) {
-            retryCount++
-
-            // Экспоненциальная отсрочка: 2^попытка * 1000 мс (1с, 2с, 4с, 8с, 16с)
-            val delayTime = (2.0.pow(retryCount.toDouble()) * 1000).toLong()
-
-            uiState = uiState.copy(
-                error = "Слишком много запросов. Повторная попытка через ${delayTime/1000} сек..."
-            )
-
-            delay(delayTime)
-            loadCalendarData() // Повторная попытка после задержки
-        } else {
-            uiState = uiState.copy(
-                isLoading = false,
-                error = "Превышен лимит запросов. Попробуйте позже."
-            )
-        }
-    }
-
-    fun selectDate(date: LocalDate) {
-        uiState = uiState.copy(selectedDate = date)
-    }
-
-    fun changeMonth(direction: Int) {
-        val newMonth = uiState.currentMonth.plusMonths(direction.toLong())
-        uiState = uiState.copy(currentMonth = newMonth)
-    }
-
-    fun addEvent(
-        date: LocalDate,
-        type: CalendarEventType,
-        mood: MoodType? = null,
-        symptoms: List<SymptomType> = emptyList(),
-        notes: String = "",
-        flowIntensity: Int? = null
-    ) {
+    /**
+     * Загрузка данных о цикле
+     */
+    private fun loadCycleData() {
         viewModelScope.launch {
-            val event = CalendarEvent(
-                date = date,
-                type = type,
-                mood = mood,
-                symptoms = symptoms,
-                notes = notes,
-                flowIntensity = flowIntensity
-            )
-
-            // Добавляем событие локально
-            val currentEvents = uiState.events.toMutableMap()
-            val dateEvents = currentEvents[date]?.toMutableList() ?: mutableListOf()
-            dateEvents.add(event)
-            currentEvents[date] = dateEvents
-
-            uiState = uiState.copy(events = currentEvents)
-
-            // Если это начало менструации, обновляем настройки и прогнозы
-            if (type == CalendarEventType.MENSTRUATION) {
-                updateLastPeriodDate(date)
+            _isLoading.value = true
+            try {
+                // Получение данных о цикле из репозитория
+                val cycleData = repository.getCycleData()
+                updateCalendarStateWithCycleData(cycleData)
+            } catch (e: Exception) {
+                _error.value = "Ошибка при загрузке данных цикла: ${e.localizedMessage}"
+            } finally {
+                _isLoading.value = false
             }
-
-            // Пересчитываем прогнозы и статистику
-            generatePredictions()
-            calculateStatistics()
-
-            // Сохраняем на сервер с дебаунсингом
-            debounceSaveEvent(event)
         }
     }
 
-    // Дебаунсинг для сохранения событий
-    private fun debounceSaveEvent(event: CalendarEvent) {
-        debounceJob?.cancel()
-        debounceJob = viewModelScope.launch {
-            delay(300) // Дебаунс 300 мс
-            saveEventToServer(event)
+    /**
+     * Выбор даты пользователем
+     */
+    fun selectDate(date: LocalDate) {
+        _selectedDate.value = date
+
+        // Если выбрана дата другого месяца, обновляем просматриваемый месяц
+        if (date.month != viewingMonth.month || date.year != viewingMonth.year) {
+            viewingMonth = date.withDayOfMonth(1)
+            updateMonthData()
         }
     }
 
-    fun removeEvent(date: LocalDate, eventType: CalendarEventType) {
-        val currentEvents = uiState.events.toMutableMap()
-        val dateEvents = currentEvents[date]?.toMutableList()
-        dateEvents?.removeAll { it.type == eventType }
-
-        if (dateEvents.isNullOrEmpty()) {
-            currentEvents.remove(date)
-        } else {
-            currentEvents[date] = dateEvents
-        }
-
-        uiState = uiState.copy(events = currentEvents)
-
-        // Пересчитываем прогнозы
-        generatePredictions()
-        calculateStatistics()
-    }
-
-    fun showEventDialog() {
-        uiState = uiState.copy(showEventDialog = true)
-    }
-
-    fun hideEventDialog() {
-        uiState = uiState.copy(showEventDialog = false)
-    }
-
-    fun showSettingsDialog() {
-        uiState = uiState.copy(showSettingsDialog = true)
-    }
-
-    fun hideSettingsDialog() {
-        uiState = uiState.copy(showSettingsDialog = false)
-    }
-
-    fun updateCycleSettings(settings: CycleSettings) {
-        uiState = uiState.copy(settings = settings)
-        generatePredictions()
-        // TODO: Сохранить настройки на сервер с дебаунсингом
-        debounceSaveSettings(settings)
-    }
-
-    private fun debounceSaveSettings(settings: CycleSettings) {
-        debounceJob?.cancel()
-        debounceJob = viewModelScope.launch {
-            delay(300) // Дебаунс 300 мс
-            saveCycleSettings(settings)
-        }
-    }
-
-    private fun updateLastPeriodDate(date: LocalDate) {
-        val updatedSettings = uiState.settings.copy(lastPeriodStart = date)
-        uiState = uiState.copy(settings = updatedSettings)
-    }
-
-    private fun loadCycleSettings() {
-        // TODO: Загрузить настройки с сервера
-        // Пока используем настройки по умолчанию
-    }
-
-    private fun generatePredictions() {
-        val settings = uiState.settings
-        val lastPeriodStart = settings.lastPeriodStart ?: return
-
-        // Прогнозируем следующую менструацию
-        val nextPeriodStart = lastPeriodStart.plusDays(settings.averageCycleLength.toLong())
-        val nextPeriodEnd = nextPeriodStart.plusDays(settings.averagePeriodLength.toLong() - 1)
-
-        // Прогнозируем овуляцию (примерно за 14 дней до следующих месячных)
-        val nextOvulation = nextPeriodStart.minusDays(14)
-
-        // Окно фертильности (5 дней до овуляции + день овуляции)
-        val fertileWindowStart = nextOvulation.minusDays(4)
-        val fertileWindowEnd = nextOvulation.plusDays(1)
-
-        val prediction = CyclePrediction(
-            nextPeriodStart = nextPeriodStart,
-            nextPeriodEnd = nextPeriodEnd,
-            nextOvulation = nextOvulation,
-            fertileWindowStart = fertileWindowStart,
-            fertileWindowEnd = fertileWindowEnd
+    /**
+     * Обновление данных для текущего месяца
+     */
+    private fun updateMonthData() {
+        val currentState = _calendarUiState.value ?: CalendarUiState()
+        _calendarUiState.value = currentState.copy(
+            viewingMonth = viewingMonth
         )
-
-        uiState = uiState.copy(predictions = prediction)
-
-        // Добавляем прогнозные события в календарь
-        addPredictedEvents(prediction)
     }
 
-    private fun addPredictedEvents(prediction: CyclePrediction) {
-        val currentEvents = uiState.events.toMutableMap()
+    /**
+     * Обновление состояния UI с записями календаря
+     */
+    private fun updateCalendarStateWithEntries(entries: List<CalendarEntry>) {
+        val updatedState = _calendarUiState.value?.copy(
+            entries = entries,
+            selectedDateEntries = entries.filter {
+                it.entryDate.isEqual(selectedDate.value)
+            }
+        ) ?: CalendarUiState(entries = entries)
+        _calendarUiState.value = updatedState
+    }
 
-        // Удаляем старые прогнозы
-        currentEvents.forEach { (date, events) ->
-            currentEvents[date] = events.filter { it.isActual }
-        }
+    /**
+     * Обновление состояния UI с данными о цикле
+     */
+    private fun updateCalendarStateWithCycleData(cycleData: CycleData?) {
+        if (cycleData == null) return
 
-        // Добавляем новые прогнозы
-        val predictedEvents = mutableListOf<Pair<LocalDate, CalendarEvent>>()
+        val updatedState = _calendarUiState.value?.copy(
+            cycleStartDate = cycleData.lastPeriodStartDate,
+            cycleData = cycleData,
+            avgCycleLength = cycleData.averageCycleLength,
+            avgPeriodLength = cycleData.averagePeriodLength,
+            cycleRegularityScore = cycleData.regularityScore
+        ) ?: CalendarUiState()
+        _calendarUiState.value = updatedState
+    }
 
-        // Прогноз месячных
-        var date = prediction.nextPeriodStart
-        while (!date.isAfter(prediction.nextPeriodEnd)) {
-            predictedEvents.add(
-                date to CalendarEvent(
-                    date = date,
-                    type = CalendarEventType.PREDICTED_MENSTRUATION,
-                    isActual = false
+    /**
+     * Удаление инсайта
+     */
+    fun dismissInsight(id: Long) {
+        viewModelScope.launch {
+            try {
+                // Здесь должен быть вызов метода репозитория для удаления инсайта
+                // repository.dismissInsight(id)
+
+                // Обновляем список инсайтов, удаляя указанный
+                _calendarUiState.value = _calendarUiState.value?.copy(
+                    insights = _calendarUiState.value?.insights?.filter { it.id != id } ?: emptyList()
                 )
-            )
-            date = date.plusDays(1)
-        }
-
-        // Прогноз овуляции
-        predictedEvents.add(
-            prediction.nextOvulation to CalendarEvent(
-                date = prediction.nextOvulation,
-                type = CalendarEventType.PREDICTED_OVULATION,
-                isActual = false
-            )
-        )
-
-        // Добавляем прогнозы в календарь
-        predictedEvents.forEach { (eventDate, event) ->
-            val dateEvents = currentEvents[eventDate]?.toMutableList() ?: mutableListOf()
-            dateEvents.add(event)
-            currentEvents[eventDate] = dateEvents
-        }
-
-        uiState = uiState.copy(events = currentEvents)
-    }
-
-    private fun calculateStatistics() {
-        val menstruationEvents = uiState.events.values.flatten()
-            .filter { it.type == CalendarEventType.MENSTRUATION && it.isActual }
-            .sortedBy { it.date }
-
-        if (menstruationEvents.size < 2) return
-
-        // Вычисляем длины циклов
-        val cycleLengths = mutableListOf<Int>()
-        for (i in 1 until menstruationEvents.size) {
-            val cycleLength = ChronoUnit.DAYS.between(
-                menstruationEvents[i-1].date,
-                menstruationEvents[i].date
-            ).toInt()
-            cycleLengths.add(cycleLength)
-        }
-
-        if (cycleLengths.isEmpty()) return
-
-        val averageLength = cycleLengths.average().toFloat()
-        val variation = cycleLengths.map { abs(it - averageLength) }.average().toFloat()
-
-        // Собираем частые симптомы
-        val allSymptoms = uiState.events.values.flatten()
-            .flatMap { it.symptoms }
-        val symptomFrequency = allSymptoms.groupingBy { it }.eachCount()
-        val commonSymptoms = symptomFrequency.toList()
-            .sortedByDescending { it.second }
-            .take(5)
-            .map { it.first }
-
-        val statistics = CycleStatistics(
-            averageCycleLength = averageLength,
-            cycleVariation = variation,
-            lastCycles = cycleLengths.takeLast(6),
-            periodLengthAverage = uiState.settings.averagePeriodLength.toFloat(),
-            commonSymptoms = commonSymptoms,
-            moodPatterns = emptyMap() // TODO: Вычислить паттерны настроения
-        )
-
-        uiState = uiState.copy(statistics = statistics)
-
-        // Обновляем настройки на основе статистики
-        if (cycleLengths.size >= 3) {
-            val newSettings = uiState.settings.copy(
-                averageCycleLength = averageLength.roundToInt()
-            )
-            uiState = uiState.copy(settings = newSettings)
-        }
-    }
-
-    private suspend fun saveEventToServer(event: CalendarEvent) {
-        try {
-            // Преобразуем CalendarEvent в CalendarEntryCreate для API
-            val entryCreate = CalendarEntryCreate(
-                date = event.date.toString(),
-                type = event.type.name,
-                mood = event.mood?.name,
-                symptoms = event.symptoms.map { it.name },
-                notes = event.notes.ifEmpty { null },
-                flow_intensity = event.flowIntensity
-            )
-
-            // Отправляем данные на сервер
-            val response = repository.createCalendarEntry(entryCreate)
-
-            if (response.isSuccessful) {
-                // Обновляем локальное событие с ID с сервера, если такой вернулся
-                response.body()?.let { serverEvent ->
-                    val currentEvents = uiState.events.toMutableMap()
-                    val dateEvents = currentEvents[event.date]?.toMutableList() ?: return@let
-
-                    // Находим и заменяем событие, добавляя ему ID с сервера
-                    val index = dateEvents.indexOfFirst {
-                        it.type == event.type && it.date == event.date
-                    }
-
-                    if (index != -1) {
-                        dateEvents[index] = serverEvent
-                        currentEvents[event.date] = dateEvents
-                        uiState = uiState.copy(
-                            events = currentEvents,
-                            error = null
-                        )
-                    }
-                }
-            } else {
-                // Обработка ошибки API
-                uiState = uiState.copy(error = "Ошибка сохранения на сервере: ${response.code()}")
+            } catch (e: Exception) {
+                _error.value = "Ошибка при удалении инсайта: ${e.localizedMessage}"
             }
-        } catch (e: Exception) {
-            uiState = uiState.copy(error = "Ошибка сохранения: ${e.message}")
         }
     }
 
-    private suspend fun saveCycleSettings(settings: CycleSettings) {
-        try {
-            // TODO: Реализовать сохранение настроек на сервер через API
-        } catch (e: Exception) {
-            uiState = uiState.copy(error = "Ошибка сохранения настроек: ${e.message}")
+    /**
+     * Очистка сообщения об ошибке
+     */
+    fun clearErrorMessage() {
+        _error.value = null
+    }
+
+    /**
+     * Добавление новой записи календаря
+     */
+    fun addCalendarEntry(entry: CalendarEntry) {
+        viewModelScope.launch {
+            _isLoading.value = true
+            try {
+                repository.addCalendarEntry(entry)
+                // Обновляем данные после добавления
+                loadCalendarEntries()
+                _error.value = null
+            } catch (e: Exception) {
+                _error.value = "Ошибка при добавлении записи: ${e.localizedMessage}"
+            } finally {
+                _isLoading.value = false
+            }
         }
     }
 
-    // Очистка ошибки
-    fun clearError() {
-        uiState = uiState.copy(error = null)
+    /**
+     * Обновление существующей записи
+     */
+    fun updateCalendarEntry(entry: CalendarEntry) {
+        viewModelScope.launch {
+            _isLoading.value = true
+            try {
+                repository.updateCalendarEntry(entry)
+                // Обновляем данные после изменения
+                loadCalendarEntries()
+                _error.value = null
+            } catch (e: Exception) {
+                _error.value = "Ошибка при обновлении записи: ${e.localizedMessage}"
+            } finally {
+                _isLoading.value = false
+            }
+        }
     }
 
-    // Принудительное обновление данных
-    fun forceRefresh() {
-        uiState = uiState.copy(lastRefreshed = 0)
-        retryCount = 0 // Сбрасываем счетчик попыток
-        loadCalendarData()
-    }
-
-    override fun onCleared() {
-        super.onCleared()
-        loadJob?.cancel()
-        debounceJob?.cancel()
+    /**
+     * Удаление записи календаря
+     */
+    fun deleteCalendarEntry(entryId: Long) {
+        viewModelScope.launch {
+            _isLoading.value = true
+            try {
+                repository.deleteCalendarEntry(entryId)
+                // Обновляем данные после удаления
+                loadCalendarEntries()
+                _error.value = null
+            } catch (e: Exception) {
+                _error.value = "Ошибка при удалении записи: ${e.localizedMessage}"
+            } finally {
+                _isLoading.value = false
+            }
+        }
     }
 }
+
+/**
+ * Класс, представляющий состояние UI календаря
+ */
+data class CalendarUiState(
+    val entries: List<CalendarEntry> = emptyList(),
+    val selectedDateEntries: List<CalendarEntry> = emptyList(),
+    val cycleStartDate: LocalDate? = null,
+    val cycleData: CycleData? = null,
+    val specialDays: Map<LocalDate, DayType> = emptyMap(),
+    val avgCycleLength: Int? = null,
+    val avgPeriodLength: Int? = null,
+    val cycleRegularityScore: Int? = null,
+    val insights: List<HealthInsight> = emptyList(),
+    val errorMessage: String? = null,
+    val viewingMonth: LocalDate = LocalDate.now().withDayOfMonth(1)
+)
+
+/**
+ * Типы дней в календаре
+ */
+enum class DayType {
+    PERIOD,          // День менструации
+    OVULATION,       // День овуляции
+    FERTILE,         // Фертильный день
+    PREDICTED_PERIOD, // Прогноз дня менструации
+    NORMAL           // Обычный день
+}
diff --git a/app/src/main/java/com/example/womansafe/ui/viewmodel/EnhancedCalendarViewModel.kt b/app/src/main/java/com/example/womansafe/ui/viewmodel/EnhancedCalendarViewModel.kt
new file mode 100644
index 0000000..3d9bced
--- /dev/null
+++ b/app/src/main/java/com/example/womansafe/ui/viewmodel/EnhancedCalendarViewModel.kt
@@ -0,0 +1,348 @@
+package com.example.womansafe.ui.viewmodel
+
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.setValue
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import com.example.womansafe.data.model.calendar.*
+import com.example.womansafe.data.repository.CalendarRepository
+import kotlinx.coroutines.launch
+import java.time.LocalDate
+import java.time.format.DateTimeFormatter
+import retrofit2.Response
+
+/**
+ * Состояние UI для экрана календаря
+ */
+data class EnhancedCalendarUiState(
+    val isLoading: Boolean = false,
+    val error: String? = null,
+    val currentMonth: LocalDate = LocalDate.now(),
+    val selectedDate: LocalDate = LocalDate.now(),
+    val events: Map<LocalDate, List<CalendarEvent>> = emptyMap(),
+    val selectedEvent: CalendarEvent? = null,
+    val cycleData: CycleData? = null,
+    val predictions: CyclePrediction? = null,
+    val statistics: CycleStatistics? = null,
+    val insights: List<HealthInsight> = emptyList(),
+    val showEventDialog: Boolean = false,
+    val showInsightsDialog: Boolean = false,
+    val showSettingsDialog: Boolean = false,
+    val editingEvent: CalendarEvent? = null
+)
+
+class EnhancedCalendarViewModel(
+    private val repository: CalendarRepository
+) : ViewModel() {
+
+    var uiState by mutableStateOf(EnhancedCalendarUiState())
+        private set
+
+    private val userId: String = "userId" // TODO: заменить на реальный userId
+
+    init {
+        loadInitialData()
+    }
+
+    /**
+     * Загрузка всех необходимых данных при запуске
+     */
+    fun loadInitialData() {
+        loadCalendarData(LocalDate.now())
+        loadCycleData()
+        loadHealthInsights()
+    }
+
+    /**
+     * Загрузка данных календаря для выбранного месяца
+     */
+    fun loadCalendarData(selectedDate: LocalDate) {
+        viewModelScope.launch {
+            uiState = uiState.copy(isLoading = true, error = null)
+            try {
+                val entries = repository.getCalendarEntries()
+
+                // Преобразуем CalendarEntry в CalendarEvent
+                val events = entries.map { convertToCalendarEvent(it) }
+
+                // Группируем события по дате
+                val groupedEvents = events.groupBy { it.date }
+
+                uiState = uiState.copy(
+                    events = groupedEvents,
+                    selectedDate = selectedDate,
+                    currentMonth = selectedDate.withDayOfMonth(1),
+                    isLoading = false
+                )
+            } catch (e: Exception) {
+                uiState = uiState.copy(
+                    error = "Ошибка: ${e.message}",
+                    isLoading = false
+                )
+            }
+        }
+    }
+
+    /**
+     * Конвертирует CalendarEntry в CalendarEvent для совместимости в UI
+     */
+    private fun convertToCalendarEvent(entry: CalendarEntry): CalendarEvent {
+        return CalendarEvent(
+            id = entry.id.toString(),
+            userId = entry.userId,
+            date = entry.entryDate,
+            type = entry.entryType.name.lowercase(),
+            flowIntensity = entry.flowIntensity?.name?.lowercase(),
+            mood = entry.mood?.name?.lowercase(),
+            energyLevel = entry.energyLevel,
+            sleepHours = entry.sleepHours,
+            symptoms = entry.symptoms?.map { it.name.lowercase() },
+            medications = entry.medications,
+            notes = entry.notes,
+            isDismissed = false
+        )
+    }
+
+    /**
+     * Загрузка данных о цикле
+     */
+    private fun loadCycleData() {
+        viewModelScope.launch {
+            try {
+                val cycleData = repository.getCycleData()
+                uiState = uiState.copy(cycleData = cycleData)
+            } catch (e: Exception) {
+                // Ошибка загрузки данных цикла
+            }
+        }
+    }
+
+    /**
+     * Загрузка статистики цикла
+     */
+    private fun loadCycleStatistics() {
+        viewModelScope.launch {
+            try {
+                val response = repository.getCycleStatistics(userId)
+                if (response.isSuccessful) {
+                    val statistics = response.body()
+                    uiState = uiState.copy(statistics = statistics)
+                }
+            } catch (e: Exception) {
+                // Ошибка загрузки статистики
+            }
+        }
+    }
+
+    /**
+     * Загрузка прогнозов цикла
+     */
+    private fun loadCyclePredictions() {
+        viewModelScope.launch {
+            try {
+                val response = repository.getCyclePredictions(userId)
+                if (response.isSuccessful) {
+                    val predictions = response.body()
+                    uiState = uiState.copy(predictions = predictions)
+                } else {
+                    val cachedPredictions = repository.getCachedPredictions(userId)
+                    uiState = uiState.copy(predictions = cachedPredictions)
+                }
+            } catch (e: Exception) {
+                val cachedPredictions = repository.getCachedPredictions(userId)
+                uiState = uiState.copy(predictions = cachedPredictions)
+            }
+        }
+    }
+
+    /**
+     * Загрузка инсайтов о здоровье
+     */
+    private fun loadHealthInsights() {
+        viewModelScope.launch {
+            try {
+                val response = repository.getHealthInsights()
+                if (response.isSuccessful) {
+                    val insights = response.body() ?: emptyList()
+                    uiState = uiState.copy(insights = insights)
+                }
+            } catch (e: Exception) {
+                // Ошибка загрузки инсайтов
+            }
+        }
+    }
+
+    /**
+     * Выбор даты
+     */
+    fun selectDate(date: LocalDate) {
+        uiState = uiState.copy(selectedDate = date)
+    }
+
+    /**
+     * Изменение отображаемого месяца
+     */
+    fun changeMonth(offset: Int) {
+        val newCurrentMonth = uiState.currentMonth.plusMonths(offset.toLong())
+        loadCalendarData(newCurrentMonth)
+    }
+
+    /**
+     * Выбор события для просмотра деталей
+     */
+    fun selectEvent(event: CalendarEvent) {
+        uiState = uiState.copy(selectedEvent = event)
+    }
+
+    /**
+     * Очистка выбранного события
+     */
+    fun clearSelectedEvent() {
+        uiState = uiState.copy(selectedEvent = null)
+    }
+
+    /**
+     * Показать диалог добавления/редактирования события
+     */
+    fun showEventDialog(event: CalendarEvent? = null) {
+        uiState = uiState.copy(
+            showEventDialog = true,
+            editingEvent = event
+        )
+    }
+
+    /**
+     * Скрыть диалог добавления/редактирования события
+     */
+    fun hideEventDialog() {
+        uiState = uiState.copy(
+            showEventDialog = false,
+            editingEvent = null
+        )
+    }
+
+    /**
+     * Показать диалог инсайтов
+     */
+    fun showInsightsDialog() {
+        uiState = uiState.copy(showInsightsDialog = true)
+    }
+
+    /**
+     * Скрыть диалог инсайтов
+     */
+    fun hideInsightsDialog() {
+        uiState = uiState.copy(showInsightsDialog = false)
+    }
+
+    /**
+     * Показать диалог настроек
+     */
+    fun showSettingsDialog() {
+        uiState = uiState.copy(showSettingsDialog = true)
+    }
+
+    /**
+     * Скрыть диалог настроек
+     */
+    fun hideSettingsDialog() {
+        uiState = uiState.copy(showSettingsDialog = false)
+    }
+
+    /**
+     * Добавление нового события
+     */
+    fun addCalendarEntry(entry: CalendarEntry) {
+        viewModelScope.launch {
+            uiState = uiState.copy(isLoading = true)
+            try {
+                val result = repository.addCalendarEntry(entry)
+                if (result.isSuccess) {
+                    loadCalendarData(entry.entryDate)
+                } else {
+                    uiState = uiState.copy(
+                        error = "Ошибка при добавлении события",
+                        isLoading = false
+                    )
+                }
+            } catch (e: Exception) {
+                uiState = uiState.copy(
+                    error = "Ошибка: ${e.message}",
+                    isLoading = false
+                )
+            }
+        }
+    }
+
+    /**
+     * Обновление существующего события
+     */
+    fun updateCalendarEntry(entry: CalendarEntry) {
+        viewModelScope.launch {
+            uiState = uiState.copy(isLoading = true)
+            try {
+                val result = repository.updateCalendarEntry(entry)
+                if (result.isSuccess) {
+                    loadCalendarData(entry.entryDate)
+                } else {
+                    uiState = uiState.copy(
+                        error = "Ошибка при обновлении события",
+                        isLoading = false
+                    )
+                }
+            } catch (e: Exception) {
+                uiState = uiState.copy(
+                    error = "Ошибка: ${e.message}",
+                    isLoading = false
+                )
+            }
+        }
+    }
+
+    /**
+     * Удаление события
+     */
+    fun deleteCalendarEntry(entryId: Long) {
+        viewModelScope.launch {
+            uiState = uiState.copy(isLoading = true)
+            try {
+                val result = repository.deleteCalendarEntry(entryId)
+                if (result.isSuccess) {
+                    loadCalendarData(uiState.selectedDate)
+                } else {
+                    uiState = uiState.copy(
+                        error = "Ошибка при удалении события",
+                        isLoading = false
+                    )
+                }
+            } catch (e: Exception) {
+                uiState = uiState.copy(
+                    error = "Ошибка: ${e.message}",
+                    isLoading = false
+                )
+            }
+        }
+    }
+
+    /**
+     * Отметка инсайта как прочитанного/отклоненного
+     */
+    fun dismissInsight(insightId: Long) {
+        viewModelScope.launch {
+            try {
+                repository.dismissInsight(insightId)
+                loadHealthInsights()
+            } catch (e: Exception) {
+                // Обработка ошибки без блокировки интерфейса
+            }
+        }
+    }
+
+    /**
+     * Очистка сообщения об ошибке
+     */
+    fun clearError() {
+        uiState = uiState.copy(error = null)
+    }
+}
diff --git a/app/src/main/java/com/example/womansafe/util/ContactsHelper.kt b/app/src/main/java/com/example/womansafe/util/ContactsHelper.kt
new file mode 100644
index 0000000..ccc6654
--- /dev/null
+++ b/app/src/main/java/com/example/womansafe/util/ContactsHelper.kt
@@ -0,0 +1,107 @@
+package com.example.womansafe.util
+
+import android.content.Context
+import android.database.Cursor
+import android.net.Uri
+import android.provider.ContactsContract
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+/**
+ * Класс для работы с контактами устройства
+ */
+class ContactsHelper(private val context: Context) {
+
+    /**
+     * Класс модели контакта
+     */
+    data class Contact(
+        val id: String,
+        val name: String,
+        val phoneNumber: String,
+        val photoUri: Uri? = null
+    )
+
+    /**
+     * Получение списка контактов устройства
+     */
+    suspend fun getContacts(): List<Contact> = withContext(Dispatchers.IO) {
+        val contacts = mutableListOf<Contact>()
+
+        val projection = arrayOf(
+            ContactsContract.CommonDataKinds.Phone.CONTACT_ID,
+            ContactsContract.Contacts.DISPLAY_NAME,
+            ContactsContract.CommonDataKinds.Phone.NUMBER,
+            ContactsContract.Contacts.PHOTO_URI
+        )
+
+        val cursor: Cursor? = context.contentResolver.query(
+            ContactsContract.CommonDataKinds.Phone.CONTENT_URI,
+            projection,
+            null,
+            null,
+            ContactsContract.Contacts.DISPLAY_NAME + " ASC"
+        )
+
+        cursor?.use {
+            val idColumn = it.getColumnIndex(ContactsContract.CommonDataKinds.Phone.CONTACT_ID)
+            val nameColumn = it.getColumnIndex(ContactsContract.Contacts.DISPLAY_NAME)
+            val numberColumn = it.getColumnIndex(ContactsContract.CommonDataKinds.Phone.NUMBER)
+            val photoColumn = it.getColumnIndex(ContactsContract.Contacts.PHOTO_URI)
+
+            while (it.moveToNext()) {
+                val id = it.getString(idColumn)
+                val name = it.getString(nameColumn) ?: "Неизвестно"
+                val number = it.getString(numberColumn) ?: "Нет номера"
+                val photoUri = it.getString(photoColumn)?.let { uri -> Uri.parse(uri) }
+
+                contacts.add(Contact(id, name, number, photoUri))
+            }
+        }
+
+        return@withContext contacts.distinctBy { it.id }
+    }
+
+    /**
+     * Получение контакта по ID
+     */
+    suspend fun getContactById(contactId: String): Contact? = withContext(Dispatchers.IO) {
+        val projection = arrayOf(
+            ContactsContract.CommonDataKinds.Phone.CONTACT_ID,
+            ContactsContract.Contacts.DISPLAY_NAME,
+            ContactsContract.CommonDataKinds.Phone.NUMBER,
+            ContactsContract.Contacts.PHOTO_URI
+        )
+
+        val selection = "${ContactsContract.CommonDataKinds.Phone.CONTACT_ID} = ?"
+        val selectionArgs = arrayOf(contactId)
+
+        val cursor: Cursor? = context.contentResolver.query(
+            ContactsContract.CommonDataKinds.Phone.CONTENT_URI,
+            projection,
+            selection,
+            selectionArgs,
+            null
+        )
+
+        var contact: Contact? = null
+
+        cursor?.use {
+            if (it.moveToFirst()) {
+                val idColumn = it.getColumnIndex(ContactsContract.CommonDataKinds.Phone.CONTACT_ID)
+                val nameColumn = it.getColumnIndex(ContactsContract.Contacts.DISPLAY_NAME)
+                val numberColumn = it.getColumnIndex(ContactsContract.CommonDataKinds.Phone.NUMBER)
+                val photoColumn = it.getColumnIndex(ContactsContract.Contacts.PHOTO_URI)
+
+                val id = it.getString(idColumn)
+                val name = it.getString(nameColumn) ?: "Неизвестно"
+                val number = it.getString(numberColumn) ?: "Нет номера"
+                val photoUri = it.getString(photoColumn)?.let { uri -> Uri.parse(uri) }
+
+                contact = Contact(id, name, number, photoUri)
+            }
+        }
+
+        return@withContext contact
+    }
+}
diff --git a/app/src/main/java/com/example/womansafe/util/PermissionManager.kt b/app/src/main/java/com/example/womansafe/util/PermissionManager.kt
new file mode 100644
index 0000000..e28b5a0
--- /dev/null
+++ b/app/src/main/java/com/example/womansafe/util/PermissionManager.kt
@@ -0,0 +1,124 @@
+package com.example.womansafe.util
+
+import android.Manifest
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.net.Uri
+import android.provider.Settings
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.runtime.*
+import androidx.compose.ui.platform.LocalContext
+import androidx.core.content.ContextCompat
+
+/**
+ * Класс для управления разрешениями в приложении
+ */
+class PermissionManager(private val context: Context) {
+
+    private val preferenceManager = PreferenceManager.getInstance(context)
+
+    // Проверка разрешения
+    fun isPermissionGranted(permission: String): Boolean {
+        return ContextCompat.checkSelfPermission(
+            context,
+            permission
+        ) == PackageManager.PERMISSION_GRANTED
+    }
+
+    // Сохранение статуса разрешения
+    fun savePermissionStatus(permission: String, granted: Boolean) {
+        preferenceManager.savePermissionGranted(permission, granted)
+    }
+
+    // Получение сохраненного статуса разрешения
+    fun getSavedPermissionStatus(permission: String): Boolean {
+        return preferenceManager.isPermissionGranted(permission)
+    }
+
+    // Получение списка необходимых разрешений
+    fun getRequiredPermissions(): List<String> {
+        return listOf(
+            Manifest.permission.ACCESS_FINE_LOCATION,
+            Manifest.permission.ACCESS_COARSE_LOCATION,
+            Manifest.permission.CAMERA,
+            Manifest.permission.READ_CONTACTS
+        )
+    }
+
+    // Получение непредоставленных разрешений
+    fun getMissingPermissions(): List<String> {
+        return getRequiredPermissions().filter { !isPermissionGranted(it) }
+    }
+
+    // Открытие настроек приложения для управления разрешениями
+    fun openAppSettings() {
+        val intent = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS)
+        val uri = Uri.fromParts("package", context.packageName, null)
+        intent.data = uri
+        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+        context.startActivity(intent)
+    }
+
+    companion object {
+        // Разрешения
+        const val PERMISSION_LOCATION = Manifest.permission.ACCESS_FINE_LOCATION
+        const val PERMISSION_CAMERA = Manifest.permission.CAMERA
+        const val PERMISSION_CONTACTS = Manifest.permission.READ_CONTACTS
+
+        // Синглтон для доступа к PermissionManager
+        @Volatile private var INSTANCE: PermissionManager? = null
+
+        fun getInstance(context: Context): PermissionManager {
+            return INSTANCE ?: synchronized(this) {
+                INSTANCE ?: PermissionManager(context).also { INSTANCE = it }
+            }
+        }
+    }
+}
+
+/**
+ * Composable для запроса разрешений
+ */
+@Composable
+fun RequestPermissions(
+    permissions: List<String>,
+    onAllPermissionsGranted: () -> Unit = {},
+    onPermissionDenied: (List<String>) -> Unit = {}
+) {
+    val context = LocalContext.current
+    val permissionManager = remember { PermissionManager.getInstance(context) }
+
+    // Проверка всех разрешений
+    val allPermissionsGranted = permissions.all {
+        permissionManager.isPermissionGranted(it)
+    }
+
+    // Запрашиваем разрешения, если они не предоставлены
+    val launcher = rememberLauncherForActivityResult(
+        ActivityResultContracts.RequestMultiplePermissions()
+    ) { permissionsMap ->
+        // Сохраняем статусы разрешений
+        permissionsMap.forEach { (permission, granted) ->
+            permissionManager.savePermissionStatus(permission, granted)
+        }
+
+        // Проверяем, все ли разрешения предоставлены
+        val deniedPermissions = permissionsMap.filterValues { !it }.keys.toList()
+        if (deniedPermissions.isEmpty()) {
+            onAllPermissionsGranted()
+        } else {
+            onPermissionDenied(deniedPermissions)
+        }
+    }
+
+    // Запрашиваем необходимые разрешения при первом запуске composable
+    LaunchedEffect(permissions) {
+        if (!allPermissionsGranted) {
+            launcher.launch(permissions.toTypedArray())
+        } else {
+            onAllPermissionsGranted()
+        }
+    }
+}
diff --git a/app/src/main/java/com/example/womansafe/util/PreferenceManager.kt b/app/src/main/java/com/example/womansafe/util/PreferenceManager.kt
new file mode 100644
index 0000000..423b702
--- /dev/null
+++ b/app/src/main/java/com/example/womansafe/util/PreferenceManager.kt
@@ -0,0 +1,68 @@
+package com.example.womansafe.util
+
+import android.content.Context
+import android.content.SharedPreferences
+import androidx.security.crypto.EncryptedSharedPreferences
+import androidx.security.crypto.MasterKey
+
+/**
+ * Класс для управления безопасным хранением данных пользователя
+ */
+class PreferenceManager(context: Context) {
+
+    private val masterKey = MasterKey.Builder(context)
+        .setKeyScheme(MasterKey.KeyScheme.AES256_GCM)
+        .build()
+
+    private val sharedPreferences: SharedPreferences = EncryptedSharedPreferences.create(
+        context,
+        PREFERENCE_NAME,
+        masterKey,
+        EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
+        EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM
+    )
+
+    // Сохранение токена
+    fun saveAuthToken(token: String?) {
+        sharedPreferences.edit().putString(KEY_AUTH_TOKEN, token).apply()
+    }
+
+    // Получение токена
+    fun getAuthToken(): String? {
+        return sharedPreferences.getString(KEY_AUTH_TOKEN, null)
+    }
+
+    // Сохранение разрешений
+    fun savePermissionGranted(permission: String, granted: Boolean) {
+        sharedPreferences.edit().putBoolean(permission, granted).apply()
+    }
+
+    // Получение статуса разрешения
+    fun isPermissionGranted(permission: String): Boolean {
+        return sharedPreferences.getBoolean(permission, false)
+    }
+
+    // Очистка данных при выходе
+    fun clearAuthData() {
+        sharedPreferences.edit().remove(KEY_AUTH_TOKEN).apply()
+    }
+
+    companion object {
+        private const val PREFERENCE_NAME = "woman_safe_prefs"
+        private const val KEY_AUTH_TOKEN = "auth_token"
+
+        // Ключи для отслеживания разрешений
+        const val PERMISSION_LOCATION = "permission_location"
+        const val PERMISSION_CAMERA = "permission_camera"
+        const val PERMISSION_CONTACTS = "permission_contacts"
+
+        // Синглтон для доступа к PreferenceManager
+        @Volatile private var INSTANCE: PreferenceManager? = null
+
+        fun getInstance(context: Context): PreferenceManager {
+            return INSTANCE ?: synchronized(this) {
+                INSTANCE ?: PreferenceManager(context.applicationContext).also { INSTANCE = it }
+            }
+        }
+    }
+}
diff --git a/app/src/main/java/com/example/womansafe/util/TouchEventFix.kt b/app/src/main/java/com/example/womansafe/util/TouchEventFix.kt
new file mode 100644
index 0000000..c52601c
--- /dev/null
+++ b/app/src/main/java/com/example/womansafe/util/TouchEventFix.kt
@@ -0,0 +1,25 @@
+package com.example.womansafe.util
+
+import androidx.compose.foundation.gestures.awaitEachGesture
+import androidx.compose.foundation.gestures.awaitFirstDown
+import androidx.compose.foundation.gestures.waitForUpOrCancellation
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.composed
+import androidx.compose.ui.input.pointer.pointerInput
+
+/**
+ * Модификатор, который исправляет проблему с ACTION_HOVER_EXIT в Jetpack Compose
+ */
+fun Modifier.fixTouchEvents(): Modifier = composed {
+    val interactionSource = remember { MutableInteractionSource() }
+
+    this.pointerInput(interactionSource) {
+        awaitEachGesture {
+            // Просто ждем первое нажатие и отпускание, чтобы гарантировать правильную очистку событий
+            awaitFirstDown(requireUnconsumed = false)
+            waitForUpOrCancellation()
+        }
+    }
+}
diff --git a/app/src/main/java/com/example/womansafe/utils/DateUtils.kt b/app/src/main/java/com/example/womansafe/utils/DateUtils.kt
new file mode 100644
index 0000000..b512924
--- /dev/null
+++ b/app/src/main/java/com/example/womansafe/utils/DateUtils.kt
@@ -0,0 +1,59 @@
+package com.example.womansafe.utils
+
+import java.time.LocalDate
+import java.time.format.DateTimeFormatter
+import java.time.temporal.ChronoUnit
+import kotlin.math.absoluteValue
+
+/**
+ * Вспомогательный класс для работы с датами
+ */
+object DateUtils {
+
+    /**
+     * Форматтер для отображения дат в удобном формате
+     */
+    val READABLE_DATE_FORMATTER: DateTimeFormatter = DateTimeFormatter.ofPattern("dd.MM.yyyy")
+
+    /**
+     * Форматтер для отображения месяца и года
+     */
+    val MONTH_YEAR_FORMATTER: DateTimeFormatter = DateTimeFormatter.ofPattern("MMMM yyyy")
+
+    /**
+     * Проверяет, находится ли дата в указанном диапазоне (включая начало и конец)
+     */
+    fun isDateInRange(date: LocalDate, start: LocalDate?, end: LocalDate?): Boolean {
+        if (start == null || end == null) return false
+        return (date.isEqual(start) || date.isAfter(start)) &&
+               (date.isEqual(end) || date.isBefore(end))
+    }
+
+    /**
+     * Вычисляет количество дней между двумя датами
+     */
+    fun daysBetween(start: LocalDate, end: LocalDate): Long {
+        return ChronoUnit.DAYS.between(start, end).absoluteValue
+    }
+
+    /**
+     * Проверяет, является ли дата сегодняшней
+     */
+    fun isToday(date: LocalDate): Boolean {
+        return date.isEqual(LocalDate.now())
+    }
+
+    /**
+     * Форматирует дату в читаемый формат
+     */
+    fun formatReadableDate(date: LocalDate?): String {
+        return date?.format(READABLE_DATE_FORMATTER) ?: "Нет данных"
+    }
+
+    /**
+     * Форматирует месяц и год
+     */
+    fun formatMonthYear(date: LocalDate): String {
+        return date.format(MONTH_YEAR_FORMATTER)
+    }
+}
diff --git a/build.gradle.kts b/build.gradle.kts
index 952b930..922f551 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -2,5 +2,4 @@
 plugins {
     alias(libs.plugins.android.application) apply false
     alias(libs.plugins.kotlin.android) apply false
-    alias(libs.plugins.kotlin.compose) apply false
 }
\ No newline at end of file
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 616ab0f..220682e 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -1,13 +1,13 @@
 [versions]
 agp = "8.13.0"
-kotlin = "2.0.21"
+kotlin = "1.9.20"
 coreKtx = "1.10.1"
 junit = "4.13.2"
 junitVersion = "1.1.5"
 espressoCore = "3.5.1"
 lifecycleRuntimeKtx = "2.6.1"
 activityCompose = "1.8.0"
-composeBom = "2024.09.00"
+composeBom = "2023.08.00"
 
 [libraries]
 androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "coreKtx" }
@@ -28,5 +28,3 @@ androidx-compose-material3 = { group = "androidx.compose.material3", name = "mat
 [plugins]
 android-application = { id = "com.android.application", version.ref = "agp" }
 kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
-kotlin-compose = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }
-