#Kotlin Learning Resources

// Kotlin Koans - Official Interactive Exercises
// Visit: https://play.kotlinlang.org/koans/

fun main() {
    println("Start your Kotlin learning journey!")
}

data class DevelopmentTool(
    val name: String,
    val type: String,
    val platform: String,
    val features: List<String>
)

val recommendedIDEs = listOf(
    DevelopmentTool(
        name = "IntelliJ IDEA",
        type = "IDE",
        platform = "Cross-platform",
        features = listOf("Smart code completion", "Debugger", "Version control", "Plugin ecosystem")
    ),
    DevelopmentTool(
        name = "Android Studio",
        type = "IDE",
        platform = "Cross-platform",
        features = listOf("Android development", "Emulator", "Layout editor", "Performance analysis")
    ),
    DevelopmentTool(
        name = "Visual Studio Code",
        type = "Editor",
        platform = "Cross-platform",
        features = listOf("Lightweight", "Rich extensions", "Git integration", "Debug support")
    )
)

class KotlinCommunity {
    val platforms = mapOf(
        "Reddit" to "r/Kotlin",
        "Stack Overflow" to "kotlin tag",
        "GitHub" to "JetBrains/kotlin",
        "Twitter" to "@kotlin",
        "Discord" to "Kotlin Discord Server"
    )
    
    fun joinCommunity(platform: String) {
        println("Join Kotlin $platform community and interact with other developers!")
    }
}

// 1. Console Calculator
class Calculator {
    fun add(a: Double, b: Double) = a + b
    fun subtract(a: Double, b: Double) = a - b
    fun multiply(a: Double, b: Double) = a * b
    fun divide(a: Double, b: Double) = if (b != 0.0) a / b else throw IllegalArgumentException("Divisor cannot be zero")
}

// 2. Todo List Manager
data class TodoItem(
    val id: Int,
    val title: String,
    val completed: Boolean = false,
    val createdAt: Long = System.currentTimeMillis()
)

class TodoManager {
    private val todos = mutableListOf<TodoItem>()
    
    fun addTodo(title: String) {
        val id = todos.size + 1
        todos.add(TodoItem(id, title))
    }
    
    fun completeTodo(id: Int) {
        todos.find { it.id == id }?.let { todo ->
            val index = todos.indexOf(todo)
            todos[index] = todo.copy(completed = true)
        }
    }
    
    fun getAllTodos() = todos.toList()
}

// 3. HTTP Client
import kotlinx.coroutines.*
import kotlinx.serialization.json.*

class HttpClient {
    suspend fun get(url: String): String = withContext(Dispatchers.IO) {
        // Implement using Ktor or OkHttp
        "HTTP response data"
    }
}

// 4. Database Operations
data class User(val id: Int, val name: String, val email: String)

interface UserRepository {
    suspend fun findById(id: Int): User?
    suspend fun save(user: User): User
    suspend fun findAll(): List<User>
}

// 5. Android Note-taking App
class NoteViewModel : ViewModel() {
    private val _notes = MutableLiveData<List<Note>>()
    val notes: LiveData<List<Note>> = _notes
    
    fun addNote(title: String, content: String) {
        viewModelScope.launch {
            val note = Note(title = title, content = content)
            repository.insert(note)
            loadNotes()
        }
    }
}

// 6. Android Weather App
class WeatherRepository {
    suspend fun getCurrentWeather(city: String): Weather {
        return weatherApi.getCurrentWeather(city)
    }
}

val beginnerPath = listOf(
    "Week 1" to listOf("Kotlin basic syntax", "Variables and functions", "Control flow"),
    "Week 2" to listOf("Object-oriented programming", "Classes and objects", "Inheritance"),
    "Week 3" to listOf("Collections and generics", "Exception handling", "File operations"),
    "Week 4" to listOf("Coroutines basics", "Standard library", "Practice project"),
    "Week 5-6" to listOf("Android basics", "Comprehensive project")
)

val javaDevPath = listOf(
    "Week 1" to listOf("Kotlin vs Java", "Null safety", "Extension functions", "Coroutines"),
    "Week 2" to listOf("Functional programming", "DSL", "Metaprogramming"),
    "Week 3" to listOf("Kotlin Multiplatform", "Advanced features", "Best practices")
)

val recommendedPlugins = listOf(
    "Kotlin" to "Official Kotlin support",
    "Rainbow Brackets" to "Colorful brackets",
    "String Manipulation" to "String operations",
    "Key Promoter X" to "Shortcut hints",
    "GitToolBox" to "Git enhancement",
    "SonarLint" to "Code quality checking",
    "Kotlin Fill Class" to "Auto-generate constructors",
    "Detekt" to "Kotlin static code analysis",
    "Android ButterKnife Zelezny" to "Android view injection",
    "Kotlin Multiplatform Mobile" to "KMM support"
)

// IntelliJ IDEA Shortcut Recommendations
val kotlinShortcuts = mapOf(
    "Ctrl + Shift + K" to "Delete current line",
    "Ctrl + D" to "Duplicate current line",
    "Alt + Enter" to "Show intention actions",
    "Ctrl + Alt + L" to "Format code",
    "Ctrl + Shift + F10" to "Run current file",
    "Ctrl + Shift + T" to "Create test",
    "F2" to "Next error",
    "Shift + F6" to "Rename"
)

// build.gradle.kts
plugins {
    kotlin("jvm") version "1.9.20"
    kotlin("plugin.serialization") version "1.9.20"
}

dependencies {
    implementation("org.jetbrains.kotlin:kotlin-stdlib")
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3")
    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.6.0")
    
    testImplementation("org.jetbrains.kotlin:kotlin-test")
    testImplementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:1.7.3")
}

// Android Official Resources
val androidResources = mapOf(
    "Official Documentation" to "https://developer.android.com/kotlin",
    "Kotlin First" to "https://developer.android.com/kotlin/first",
    "Jetpack Compose" to "https://developer.android.com/jetpack/compose",
    "Android KTX" to "https://developer.android.com/kotlin/ktx"
)

// Recommended Android Libraries
val androidLibraries = listOf(
    "Retrofit" to "Network requests",
    "Room" to "Database",
    "Jetpack Compose" to "UI framework",
    "Hilt" to "Dependency injection",
    "Coroutines" to "Asynchronous programming"
)

// KMP Resources
val kmpResources = listOf(
    "Official Documentation" to "https://kotlinlang.org/docs/multiplatform.html",
    "KMP Examples" to "https://github.com/JetBrains/kotlin-multiplatform-dev-docs",
    "Compose Multiplatform" to "https://www.jetbrains.com/lp/compose-multiplatform/"
)

data class PracticePlatform(
    val name: String,
    val url: String,
    val difficulty: String,
    val features: List<String>
)

val practicePlatforms = listOf(
    PracticePlatform(
        name = "LeetCode",
        url = "https://leetcode.com/",
        difficulty = "Medium-Hard",
        features = listOf("Algorithm problems", "Interview prep", "Contests")
    ),
    PracticePlatform(
        name = "HackerRank",
        url = "https://www.hackerrank.com/",
        difficulty = "Easy-Medium",
        features = listOf("Programming exercises", "Skill certification", "Recruitment platform")
    ),
    PracticePlatform(
        name = "Codewars",
        url = "https://www.codewars.com/",
        difficulty = "Easy-Hard",
        features = listOf("Kata challenges", "Community ratings", "Multi-language support")
    )
)

// 30-Day Kotlin Challenge
val kotlinChallenge = mapOf(
    "Days 1-7" to "Basic syntax mastery",
    "Days 8-14" to "Object-oriented programming",
    "Days 15-21" to "Functional programming and coroutines",
    "Days 22-28" to "Real project development",
    "Days 29-30" to "Code optimization and best practices"
)

class TechNewsTracker {
    val sources = listOf(
        "Kotlin Weekly" to "https://kotlinweekly.net/",
        "Android Weekly" to "https://androidweekly.net/",
        "JetBrains Blog" to "https://blog.jetbrains.com/",
        "Kotlin Reddit" to "https://reddit.com/r/Kotlin"
    )
    
    fun subscribeToAll() {
        sources.forEach { (name, url) ->
            println("Subscribe to $name: $url")
        }
    }
}

// Recommended Open Source Projects
val openSourceProjects = listOf(
    "kotlinx.coroutines" to "Coroutines library",
    "kotlinx.serialization" to "Serialization library", 
    "Ktor" to "Web framework",
    "Exposed" to "Database framework",
    "Compose" to "UI framework"
)

val certificationCourses = listOf(
    "Coursera Kotlin Specialization",
    "Udacity Android Kotlin Nanodegree",
    "Pluralsight Kotlin Learning Path",
    "LinkedIn Learning Kotlin Courses"
)

data class LearningTip(
    val title: String,
    val description: String,
    val practiceIdea: String
)

val learningTips = listOf(
    LearningTip(
        title = "Learn by Doing",
        description = "Practice immediately after learning theory",
        practiceIdea = "Write a small program to verify each concept you learn"
    ),
    LearningTip(
        title = "Read Source Code",
        description = "Read source code of excellent open source projects",
        practiceIdea = "Analyze implementations of Kotlin standard library and famous projects"
    ),
    LearningTip(
        title = "Participate in Community",
        description = "Actively participate in technical community discussions",
        practiceIdea = "Answer questions on Stack Overflow, publish technical blogs"
    ),
    LearningTip(
        title = "Build Projects",
        description = "Build complete application projects from scratch",
        practiceIdea = "Develop and publish an application you're personally interested in"
    ),
    LearningTip(
        title = "Code Review",
        description = "Regularly review and optimize your code",
        practiceIdea = "Select one project for code refactoring each week"
    ),
    LearningTip(
        title = "Study Source Code",
        description = "Research design patterns and architecture of famous libraries",
        practiceIdea = "Analyze implementations of Retrofit, OkHttp, Coroutines and other libraries"
    )
)

// Kotlin Programming Best Practices
val kotlinBestPractices = listOf(
    "Prefer immutable collections" to "listOf(), setOf(), mapOf()",
    "Use data classes" to "Simplify POJO class definitions",
    "Use null safety properly" to "Avoid unnecessary null checks",
    "Prefer expressions" to "Use when expression instead of if-else",
    "Use extension functions" to "Enhance functionality of existing classes",
    "Use coroutines properly" to "Handle async operations and I/O intensive tasks"
)

val commonMistakes = listOf(
    "Learning only syntax without projects" to "Combine theory with practice",
    "Ignoring Java interoperability" to "The relationship between Kotlin and Java is important",
    "Not using coroutines" to "Coroutines are Kotlin's killer feature",
    "Not caring about performance" to "Understand Kotlin's performance characteristics",
    "Not reading official documentation" to "Official documentation is the most authoritative learning resource"
)

data class LearningWeek(
    val week: Int,
    val topics: List<String>,
    val projects: List<String>,
    val goals: String
)

val threeMonthPlan = listOf(
    // Month 1: Basics
    LearningWeek(1, listOf("Kotlin syntax", "Variables and functions"), listOf("Hello World", "Calculator"), "Master basic syntax"),
    LearningWeek(2, listOf("OOP", "Classes and inheritance"), listOf("Student management system"), "Understand OOP concepts"),
    LearningWeek(3, listOf("Collection operations", "Generics"), listOf("Library management system"), "Proficient in collections"),
    LearningWeek(4, listOf("Exception handling", "File operations"), listOf("Text editor"), "Master error handling"),
    
    // Month 2: Advanced
    LearningWeek(5, listOf("Coroutines basics", "Async programming"), listOf("Web crawler"), "Understand async programming"),
    LearningWeek(6, listOf("Functional programming", "Higher-order functions"), listOf("Data processing tool"), "Master functional programming"),
    LearningWeek(7, listOf("DSL building", "Metaprogramming"), listOf("Config file parser"), "Learn DSL building"),
    LearningWeek(8, listOf("Writing tests", "Debugging techniques"), listOf("Unit testing framework"), "Improve code quality"),
    
    // Month 3: Practice
    LearningWeek(9, listOf("Android basics", "Activity lifecycle"), listOf("Simple Android app"), "Get started with mobile dev"),
    LearningWeek(10, listOf("UI development", "Jetpack Compose"), listOf("Todo app"), "Master UI development"),
    LearningWeek(11, listOf("Network requests", "Data storage"), listOf("Weather app"), "Integrate third-party services"),
    LearningWeek(12, listOf("Project optimization", "Release preparation"), listOf("Complete app project"), "Complete project development")
)

when (problemType) {
    "Syntax issues" -> "Check official documentation or Stack Overflow"
    "Concept understanding" -> "Read related books or watch video tutorials"
    "Project practice" -> "Check GitHub example projects or consult community"
    "Career development" -> "Attend tech conferences or join professional communities"
    else -> "Comprehensively use various resources for learning"
}

fun main() {
    println("🚀 Start your Kotlin learning journey!")
    println("📚 Remember: Keep learning, keep practicing, actively share!")
    println("🎯 Goal: Become an excellent Kotlin developer!")
}

// Performance Optimization Tips
class PerformanceTips {
    // 1. Use inline functions to reduce function call overhead
    inline fun <T> measureTime(block: () -> T): Pair<T, Long> {
        val start = System.currentTimeMillis()
        val result = block()
        val time = System.currentTimeMillis() - start
        return result to time
    }
    
    // 2. Use sequences for processing large datasets
    fun processLargeDataset(data: List<String>): List<String> {
        return data.asSequence()
            .filter { it.isNotEmpty() }
            .map { it.uppercase() }
            .take(1000)
            .toList()
    }
    
    // 3. Use primitive arrays to reduce boxing overhead
    fun sumArray(numbers: IntArray): Long {
        var sum = 0L
        for (number in numbers) {
            sum += number
        }
        return sum
    }
}

// Debugging utility function
fun <T> T.debug(tag: String = "DEBUG"): T {
    println("[$tag] $this")
    return this
}

// Usage example
fun calculateSum(numbers: List<Int>): Int {
    return numbers
        .debug("INPUT")
        .filter { it > 0 }
        .debug("FILTERED")
        .sum()
        .debug("RESULT")
}

// Conditional assertions
fun processUser(user: User) {
    require(user.age >= 18) { "User must be at least 18 years old" }
    check(user.email.contains("@")) { "Invalid email format" }
    
    // Business logic
}

// Testing with MockK
class UserServiceTest {
    
    @Test
    fun `should create user when valid data provided`() = runTest {
        // Given
        val userRepository = mockk<UserRepository>()
        val userService = UserService(userRepository)
        val userData = CreateUserRequest("John", "john@example.com")
        
        every { userRepository.save(any()) } returns User(1, "John", "john@example.com")
        
        // When
        val result = userService.createUser(userData)
        
        // Then
        assertEquals("John", result.name)
        assertEquals("john@example.com", result.email)
        verify { userRepository.save(any()) }
    }
    
    @Test
    fun `should throw exception when email is invalid`() {
        // Given
        val userRepository = mockk<UserRepository>()
        val userService = UserService(userRepository)
        val userData = CreateUserRequest("John", "invalid-email")
        
        // When & Then
        assertThrows<IllegalArgumentException> {
            userService.createUser(userData)
        }
    }
}

// HTML DSL Example
class HtmlBuilder {
    private val content = StringBuilder()
    
    fun html(block: HtmlBuilder.() -> Unit): String {
        this.block()
        return content.toString()
    }
    
    fun head(block: HeadBuilder.() -> Unit) {
        content.append("<head>")
        HeadBuilder(content).block()
        content.append("</head>")
    }
    
    fun body(block: BodyBuilder.() -> Unit) {
        content.append("<body>")
        BodyBuilder(content).block()
        content.append("</body>")
    }
}

// Usage example
val htmlContent = HtmlBuilder().html {
    head {
        title("My Page")
    }
    body {
        h1("Welcome to Kotlin!")
        p("This is a DSL example.")
    }
}

// build.gradle.kts Best Practices
object Versions {
    const val kotlin = "1.9.20"
    const val coroutines = "1.7.3"
    const val ktor = "2.3.5"
    const val serialization = "1.6.0"
    const val junit = "5.10.0"
}

dependencies {
    // Kotlin Standard Library
    implementation("org.jetbrains.kotlin:kotlin-stdlib:${Versions.kotlin}")
    
    // Coroutines
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:${Versions.coroutines}")
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:${Versions.coroutines}")
    
    // Serialization
    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:${Versions.serialization}")
    
    // Network Library
    implementation("io.ktor:ktor-client-core:${Versions.ktor}")
    implementation("io.ktor:ktor-client-cio:${Versions.ktor}")
    
    // Testing
    testImplementation("org.junit.jupiter:junit-jupiter:${Versions.junit}")
    testImplementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:${Versions.coroutines}")
}

// Kotlin Learning Roadmap
val kotlinLearningRoadmap = mapOf(
    "Beginner" to listOf(
        "Kotlin basic syntax" to "Variables, functions, classes",
        "Collection operations" to "List, Set, Map usage",
        "Exception handling" to "try-catch, custom exceptions",
        "File I/O" to "File read/write operations"
    ),
    "Intermediate Developer" to listOf(
        "Coroutine programming" to "async/await, coroutine scopes",
        "Functional programming" to "Higher-order functions, Lambda",
        "Generic programming" to "Generic classes, generic functions",
        "DSL design" to "Internal DSL building"
    ),
    "Expert Level" to listOf(
        "Metaprogramming" to "Reflection, annotation processing",
        "Compiler plugins" to "Kotlin compiler extensions",
        "Performance optimization" to "Memory management, performance tuning",
        "Multiplatform" to "Cross-platform development"
    )
)