CRONOS.

// Supabase BOM
implementation(platform("io.github.jan-tennert.supabase:bom:1.4.7"))
implementation("io.github.jan-tennert.supabase:postgrest-kt")
implementation("io.github.jan-tennert.supabase:gotrue-kt")
implementation("io.github.jan-tennert.supabase:realtime-kt")

// Ktor HTTP Client
implementation("io.ktor:ktor-client-android:2.3.7")
implementation("io.ktor:ktor-client-content-negotiation:2.3.7")
implementation("io.ktor:ktor-serialization-kotlinx-json:2.3.7")

// Vico Charts
implementation("com.papanicolas.vico:compose-m3:1.13.1")

// Coil + GIF
implementation("io.coil-kt:coil-compose:2.5.0")
implementation("io.coil-kt:coil-gif:2.5.0")

// ZXing (без транзитивных зависимостей)
implementation("com.google.zxing:core:3.5.2") { isTransitive = false }

// Hilt
implementation("com.google.dagger:hilt-android:2.51")
ksp("com.google.dagger:hilt-compiler:2.51")

com.cronos.app/
├── data/
│   ├── model/           # Profile, PortfolioItem, EventApplication, AnticheatUser
│   └── repository/      # ProfileRepository, AiRepository, AppStateRepository, EventRepository
├── di/
│   └── AppModule.kt     # Hilt-модуль: Supabase-клиент, Ktor HttpClient, репозитории
├── ui/
│   ├── components/      # CityDropdown, переиспользуемые Composable-компоненты
│   ├── navigation/      # CronosNavigation.kt — граф навигации NavHost
│   ├── screens/
│   │   ├── auth/        # LoginScreen, LoginViewModel
│   │   ├── onboarding/  # Participant/Organizer/ObserverOnboardingScreen
│   │   ├── dashboard/   # DashboardScreen (4 роли в одном файле)
│   │   ├── profile/     # ProfileScreen, ProfileViewModel
│   │   ├── events/      # EventsScreen, CreateEventScreen
│   │   ├── leaderboard/ # LeaderboardScreen
│   │   ├── messenger/   # MessengerScreen (ChatList + ChatDetail)
│   │   ├── stats/       # StatsScreen
│   │   ├── ai/          # AiHubScreen, AiHubViewModel
│   │   ├── inspector/   # InspectorScreen, InspectorViewModel
│   │   ├── organizer/   # OrganizerProfileScreen
│   │   ├── qr/          # QrScannerScreen
│   │   ├── rating/      # RatingScreen
│   │   └── admin/       # AdminProfileScreen, AdminMessengerScreen, AnticheatScreen+VM
│   └── theme/           # Color.kt, Theme.kt, Typography.kt
└── MainActivity.kt

@HiltViewModel
class InspectorViewModel @Inject constructor(
    private val aiRepository: AiRepository
) : ViewModel() {

    private val _uiState = MutableStateFlow(InspectorUiState())
    val uiState: StateFlow<InspectorUiState> = _uiState.asStateFlow()

    fun scoreCandidate(participant: Participant) {
        viewModelScope.launch {
            _uiState.update { it.copy(isLoading = true) }
            val result = aiRepository.scoreCandidate(participant)
            _uiState.update { it.copy(isLoading = false, scoreResult = result) }
        }
    }
}

data class InspectorUiState(
    val candidates: List<Participant> = emptyList(),
    val isLoading: Boolean = false,
    val scoreResult: String? = null,
    val compareResult: String? = null,
    val reserveRefreshSeconds: Long = 0L
)

@Provides @Singleton
fun provideSupabaseClient(): SupabaseClient = createSupabaseClient(
    supabaseUrl = "https://<project>.supabase.co",
    supabaseKey = "<anon-key>"
) {
    install(GoTrue)
    install(Postgrest)
    install(Realtime)
    defaultSerializer = KotlinXSerializer(Json {
        ignoreUnknownKeys = true
        encodeDefaults = true
    })
}

Bronze   →  0   – 199  баллов   // начальный уровень
Silver   →  200 – 499  баллов   // активный участник
Gold     →  500 – 999  баллов   // опытный участник
Reserve  →  1000+      баллов   // кадровый резерв

@Composable
fun CronosNavigation() {
    val navController = rememberNavController()
    NavHost(navController, startDestination = "login") {
        composable("login")                  { LoginScreen(navController) }
        composable("role_selection")         { RoleSelectionScreen(navController) }
        composable("participant_onboarding") { ParticipantOnboardingScreen(navController) }
        composable("organizer_onboarding")   { OrganizerOnboardingScreen(navController) }
        composable("observer_onboarding")    { ObserverOnboardingScreen(navController) }
        composable("dashboard")              { DashboardScreen(navController) }
        composable("profile")                { ProfileScreen(navController) }
        composable("events")                 { EventsScreen(navController) }
        composable("leaderboard")            { LeaderboardScreen(navController) }
        composable("messenger")              { MessengerScreen(navController) }
        composable("stats")                  { StatsScreen(navController) }
        composable("ai_hub")                 { AiHubScreen(navController) }
        composable("rating")                 { RatingScreen(navController) }
        composable("inspector")              { InspectorScreen(navController) }
        composable("create_event")           { CreateEventScreen(navController) }
        composable("qr_scanner")             { QrScannerScreen(navController) }
        composable("organizer_profile")      { OrganizerProfileScreen(navController) }
        composable("admin_profile")          { AdminProfileScreen(navController) }
        composable("admin_messenger")        { AdminMessengerScreen(navController) }
        composable("anticheat")              { AnticheatScreen(navController) }
    }
}

// DashboardScreen.kt
when (profile.role) {
    "participant" -> ParticipantDashboard(navController, profile)
    "organizer"   -> OrganizerDashboard(navController, profile)
    "observer"    -> ObserverDashboard(navController, profile)
    "admin"       -> AdminDashboard(navController)
}

// AdminDashboard — собственный Scaffold + BottomNavBar
val adminTabs = listOf(
    AdminTab("home",      Icons.Default.Home,   "Главная"),
    AdminTab("messenger", Icons.Default.Shield, "Чат"),
    AdminTab("profile",   Icons.Default.Person, "Профиль")
)

endpoint     : https://proxy.gen-api.ru/v1/chat/completions
model        : qwen-3-5
max_tokens   : 1500
temperature  : 0.7
content-type : application/json
auth         : Bearer <API_KEY>

@Serializable
data class ChatRequest(
    val model: String,
    val messages: List<Message>,
    val max_tokens: Int = 1500,
    val temperature: Float = 0.7f
)

suspend fun scoreCandidate(participant: Participant): String {
    val response = client.post(ENDPOINT) {
        header("Authorization", "Bearer $API_KEY")
        contentType(ContentType.Application.Json)
        setBody(ChatRequest(model = MODEL, messages = listOf(
            Message(role = "user", content = buildPrompt(participant))
        )))
    }
    return extractContent(response.bodyAsText()).stripMarkdown()
}

// Удаление markdown из ответа AI
fun String.stripMarkdown() = this
    .replace(Regex("\\*\\*(.+?)\\*\\*"), "$1")
    .replace(Regex("#+\\s"), "")
    .replace(Regex("\\*(.+?)\\*"), "$1")
    .trim()

// 1. OpenAI standard string
choices[0].message.content  →  String

// 2. OpenAI content-array
choices[0].message.content  →  [{type: "text", text: "..."}]

// 3. Qwen thinking mode
choices[0].message.reasoning_content  →  String

// 4. GenAPI native format
output    →  String
response  →  String

fun startStreaming() {
    streamingJob = viewModelScope.launch {
        var index = _uiState.value.streamIndex
        while (isActive && _uiState.value.aiEnabled) {
            if (index < allUsers.size) {
                _uiState.update { state ->
                    state.copy(
                        visibleUsers = state.visibleUsers + allUsers[index],
                        streamIndex = index + 1,
                        isLive = true
                    )
                }
                index++
                if (index % 10 == 0) delay(2000L) else delay(800L)
            } else {
                _uiState.update { it.copy(isLive = false) }
                break
            }
        }
    }
}

fun toggleAi(enabled: Boolean) {
    if (!enabled) {
        streamingJob?.cancel()
        _uiState.update { it.copy(aiEnabled = false, isLive = false) }
    } else {
        _uiState.update { it.copy(aiEnabled = true) }
        startStreaming()
    }
}

fun login(email: String, password: String) {
    viewModelScope.launch {
        // Локальный admin-bypass
        if (email == "admin@gmail.com" && password == "admin123") {
            appStateRepository.setAdminMode(true)
            navigate("dashboard")
            return@launch
        }
        // Supabase Auth
        supabase.gotrue.signInWith(Email) {
            this.email = email
            this.password = password
        }
        val userId = supabase.gotrue.currentUserOrNull()?.id ?: return@launch
        val profile = profileRepository.getProfile(userId)
        if (profile == null) {
            navigate("role_selection")   // первый вход — онбординг
        } else {
            navigate("dashboard")        // профиль есть — сразу дашборд
        }
    }
}

@Serializable
data class Profile(
    val id: String,
    val displayName: String,
    val username: String?,
    val city: String?,
    val role: String,                    // participant | organizer | observer | admin
    val avatarUrl: String?,
    val birthDate: String?,              // YYYY-MM-DD
    val direction: String?,              // IT | Спорт | Культура | Наука | Бизнес
    val interests: List<String>?,
    val verificationStatus: String,      // approved | pending | rejected
    val rating: Int = 0,
    val eventsCount: Int = 0,
    val level: String = "Bronze"         // Bronze | Silver | Gold | Reserve
)

data class Participant(
    val id: String,
    val name: String,
    val username: String,
    val city: String,
    val direction: String,
    val eventsCount: Int,
    val rating: Int,
    val level: String,
    val age: Int,
    val achievements: List<Pair<String, Int>>,  // название → очки
    val forecast: String                           // прогноз развития
)

data class AnticheatUser(
    val id: String,
    val name: String,
    val username: String,
    val pointsPerDay: Float,     // аномалия если > 80
    val eventsIn24h: Int,        // аномалия если > 5
    val duplicateIp: Boolean,
    val rapidLevelUp: Boolean,
    val rating: Int,
    val status: BanStatus,       // CLEAN | SUSPICIOUS | BANNED
    val banReason: String?
)

enum class BanStatus { CLEAN, SUSPICIOUS, BANNED }

data class PortfolioItem(
    val title: String,
    val description: String,
    val year: Int,
    val url: String?,
    val tags: List<String>
)

CREATE TABLE profiles (
    id                  UUID PRIMARY KEY REFERENCES auth.users(id),
    display_name        TEXT NOT NULL,
    username            TEXT UNIQUE,
    city                TEXT,
    role                TEXT NOT NULL CHECK (role IN ('participant','organizer','observer','admin')),
    avatar_url          TEXT,
    birth_date          DATE,
    direction           TEXT,
    interests           TEXT[],
    verification_status TEXT DEFAULT 'pending' CHECK (verification_status IN ('approved','pending','rejected')),
    rating              INTEGER DEFAULT 0,
    events_count        INTEGER DEFAULT 0,
    level               TEXT DEFAULT 'Bronze',
    created_at          TIMESTAMPTZ DEFAULT NOW(),
    updated_at          TIMESTAMPTZ DEFAULT NOW()
);

class ProfileRepository @Inject constructor(
    private val supabase: SupabaseClient
) {
    suspend fun getProfile(userId: String): Profile? =
        supabase.postgrest["profiles"]
            .select { filter { eq("id", userId) } }
            .decodeSingleOrNull<Profile>()

    suspend fun upsertProfile(profile: Profile) =
        supabase.postgrest["profiles"].upsert(profile)

    suspend fun updateRating(userId: String, delta: Int) =
        supabase.postgrest["profiles"]
            .update({ set("rating", "rating + $delta") }) {
                filter { eq("id", userId) }
            }
}

-- Пользователь видит только свой профиль
CREATE POLICY "profiles_select" ON profiles
    FOR SELECT USING (auth.uid() = id);

-- Пользователь редактирует только свой профиль
CREATE POLICY "profiles_update" ON profiles
    FOR UPDATE USING (auth.uid() = id);

fun exportPdf(context: Context, content: String, fileName: String) {
    val document = PdfDocument()
    val pageInfo = PdfDocument.PageInfo.Builder(595, 842, 1).create()
    var page = document.startPage(pageInfo)
    val paint = Paint().apply { textSize = 12f; color = Color.BLACK }
    var y = 40f
    val lineHeight = 18f
    val maxWidth = 515f

    content.split("\n").forEach { line ->
        val words = line.split(" ")
        var currentLine = ""
        words.forEach { word ->
            val test = if (currentLine.isEmpty()) word else "$currentLine $word"
            if (paint.measureText(test) > maxWidth) {
                page.canvas.drawText(currentLine, 40f, y, paint)
                y += lineHeight
                if (y > 800f) {  // новая страница
                    document.finishPage(page)
                    page = document.startPage(pageInfo)
                    y = 40f
                }
                currentLine = word
            } else currentLine = test
        }
        if (currentLine.isNotEmpty()) {
            page.canvas.drawText(currentLine, 40f, y, paint)
            y += lineHeight
        }
    }
    document.finishPage(page)

    // MediaStore API (Android 10+)
    val values = ContentValues().apply {
        put(MediaStore.Downloads.DISPLAY_NAME, "$fileName.pdf")
        put(MediaStore.Downloads.MIME_TYPE, "application/pdf")
    }
    val uri = context.contentResolver.insert(
        MediaStore.Downloads.EXTERNAL_CONTENT_URI, values
    )
    uri?.let { context.contentResolver.openOutputStream(it)?.use { stream ->
        document.writeTo(stream)
    }}
    document.close()
}

<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.CAMERA" />
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
<uses-permission
    android:name="android.permission.WRITE_EXTERNAL_STORAGE"
    android:maxSdkVersion="28" />

// Основные цвета
val Black       = Color(0xFF000000)
val Surface     = Color(0xFF0A0A0A)
val SurfaceVar  = Color(0xFF111111)
val Primary     = Color(0xFF00E5FF)   // акцент — голубой
val OnPrimary   = Color(0xFF000000)

// Уровни участников
val BronzeColor  = Color(0xFFCD7F32)
val SilverColor  = Color(0xFFC0C0C0)
val GoldColor    = Color(0xFFFFD700)
val ReserveColor = Color(0xFF00E5FF)

Box(
    modifier = Modifier
        .fillMaxWidth()
        .height(280.dp)
        .background(
            Brush.verticalGradient(
                colors = listOf(
                    MaterialTheme.colorScheme.primary.copy(alpha = 0.3f),
                    MaterialTheme.colorScheme.surface
                )
            )
        )
) {
    // Аватар с белой рамкой
    Box(
        modifier = Modifier
            .size(88.dp)
            .border(3.dp, Color.White, CircleShape)
            .clip(CircleShape)
            .background(MaterialTheme.colorScheme.surfaceVariant)
    )
    // Бейдж уровня с цветом
    val levelColor = when (profile.level) {
        "Gold"    -> GoldColor
        "Reserve" -> ReserveColor
        "Silver"  -> SilverColor
        else      -> BronzeColor
    }
}