// settings.gradle.kts
repositories {
    google()
    mavenCentral()
}

// build.gradle.kts
dependencies {
    implementation("io.github.hasanyalmanbas:mail-tm-client:1.0.6")
}

import tm.mail.api.createMailTmClient
import tm.mail.api.ApiClient
import tm.mail.api.mailTmEngine

suspend fun demo() {
    // Simple way - use convenience function
    val client = createMailTmClient()

    // Or create manually with platform engine
    val manualClient = ApiClient(mailTmEngine())

    // Create account and authenticate in one step
    val authenticatedClient = ApiClient.createAccountAndAuthenticate(
        engine = mailTmEngine(),
        address = "user@example.com",
        password = "secure-password"
    )

    // Or authenticate with existing account
    val existingClient = ApiClient.authenticateExisting(
        engine = mailTmEngine(),
        address = "user@example.com",
        password = "secure-password"
    )

    // Get all messages
    val messages = authenticatedClient.getAllMessages()
    println("You have ${messages.size} messages")
}

val client = ApiClient(mailTmEngine())

// Get a random available domain and create account
val randomAccount = client.createRandomAccount("my-password")
println("Created account: ${randomAccount.address}")

// Authenticate and start using
val token = client.createToken(randomAccount.address, "my-password")
client.setToken(token.token)

// Get unread messages only
val unreadMessages = client.getUnreadMessages()

// Get specific message details
val messageDetail = client.getMessageById("msg-id")

// Mark message as read
client.markMessageAsSeen("msg-id")

// Mark all messages as read
client.markAllMessagesAsSeen()

// Delete all messages
client.deleteAllMessages()

// Get message source
val source = client.getMessageSource("msg-id")

try {
    val account = client.createAccount("test@example.com", "password")
} catch (e: MailTmException.AccountAlreadyExists) {
    println("Account already exists: ${e.message}")
    // Access original API response
    println("API Error: ${e.originalResponse?.error}")
} catch (e: MailTmException.InvalidDomain) {
    println("Invalid domain: ${e.message}")
} catch (e: MailTmException.RateLimited) {
    println("Rate limited, try again later")
} catch (e: MailTmException.NetworkError) {
    println("Network error: ${e.message}")
    // Access underlying cause
    e.cause?.printStackTrace()
}

// Advanced client configuration
val client = ApiClient.builder()
    .baseUrl("https://api.mail.tm")
    .enableLogging(true)
    .requestTimeout(45_000L)
    .maxRetries(5)
    .build(engine)

// With custom configuration object
val config = ApiClientConfig(
    enableLogging = true,
    requestTimeoutMillis = 60_000L,
    maxRetries = 3
)
val client = ApiClient.create(engine, config)

// Check rate limits after API calls
client.getMessages()
val rateInfo = client.getLastRateLimitInfo()
rateInfo?.let { info ->
    println("Remaining requests: ${info.remaining}/${info.limit}")
    println("Reset time: ${info.reset}")
}

// Setup SSE for real-time message notifications
val account = client.getMe()
val sseConfig = client.createSSEConfig(account.id)

// Use sseConfig.mercureUrl to connect to Server-Sent Events
// Platform-specific EventSource implementation required

val message = client.getMessageById("message-id")

// Security verification information
message.verifications?.let { verifications ->
    println("TLS: ${verifications.tls?.version}")
    println("SPF Passed: ${verifications.spf}")
    println("DKIM Passed: ${verifications.dkim}")
}

// JSON-LD context information
println("Context: ${message.context}")
println("Type: ${message.jsonLdType}")

catch (e: MailTmException) {
    println("Error: ${e.message}")
    e.originalResponse?.let { response ->
        println("API Error: ${response.error}")
        println("Violations: ${response.violations}")
    }
}

@Test
fun testCreateAccount() = runBlocking {
    val mockEngine = MockEngine { request ->
        respond(
            content = ByteReadChannel("""{"id":"123","address":"test@example.com"}"""),
            status = HttpStatusCode.OK,
            headers = headersOf(HttpHeaders.ContentType, "application/json")
        )
    }

    val client = ApiClient.create(mockEngine)
    val account = client.createAccount("test@example.com", "password")

    assertEquals("123", account.id)
    assertEquals("test@example.com", account.address)
}