/**
 * Class summarizing user interest data
 */
data class UserData(
    val bookmarkedNewsResources: Set<String>,
    val viewedNewsResources: Set<String>,
    val followedTopics: Set<String>,
    val themeBrand: ThemeBrand,
    val darkThemeConfig: DarkThemeConfig,
    val useDynamicColor: Boolean,
    val shouldHideOnboarding: Boolean,
)

data class AmpLinkInfo(
	val ampLink: String, 
    val destinationUrl: String? = null,
)

package com.squareup.moshi.kotlin.codegen.ksp

private class JsonClassSymbolProcessor(
  environment: SymbolProcessorEnvironment,
) : SymbolProcessor {


  override fun process(resolver: Resolver): List<KSAnnotated> {
    val generatedAnnotation = generatedOption?.let {
      AnnotationSpec.builder(ClassName.bestGuess(it))
        .addMember("value = [%S]", JsonClassSymbolProcessor::class.java.canonicalName)
        .addMember("comments = %S", "https://github.com/square/moshi")
        .build()
    }
}    

internal class OfflineFirstTopicsRepository @Inject constructor(
    private val topicDao: TopicDao,
    private val network: NiaNetworkDataSource,
) : TopicsRepository {

internal class OfflineFirstNewsRepository @Inject constructor(
    private val niaPreferencesDataSource: NiaPreferencesDataSource,
    private val newsResourceDao: NewsResourceDao,
    private val topicDao: TopicDao,
    private val network: NiaNetworkDataSource,
    private val notifier: Notifier,
) : NewsRepository {

internal class OfflineFirstTopicsManager @Inject constructor(
    private val topicDao: TopicDao,
    private val network: NiaNetworkDataSource,
) : TopicsRepository {

internal class OfflineFirstNewsManager @Inject constructor(
    private val niaPreferencesDataSource: NiaPreferencesDataSource,
    private val newsResourceDao: NewsResourceDao,
    private val topicDao: TopicDao,
    private val network: NiaNetworkDataSource,
    private val notifier: Notifier,
) : NewsRepository {

  ForbiddenClassName:
    active: true
    forbiddenName: [".*Manager"]

class ForbiddenNameDetector : Detector(), SourceCodeScanner {

    override fun getApplicableUastTypes(): List<Class<out UElement>> {
        return listOf(UClass::class.java)
    }

    override fun createUastHandler(context: JavaContext): UElementHandler? {
        if (isKotlin(context.psiFile?.language)) return null

        return object : UElementHandler() {
            override fun visitClass(node: UClass) {
                val matches = forbidden.filter { it.pattern.matches(node.name) }

                for (match in matches) {
                    context.report(
                        ISSUE,
                        context.getLocation(node),
                        "Name ${node.name} is forbidden for ${match.reason}"
                    )
                }
            }
        }
    }

Executors.newSingleThreadExecutor().asCoroutineDispatcher()

// User.kt

data class User(
	val firstName: String,
    val lastName: String,
    val id: Long
)

// Gold.kt

data class Gold(
	val amount: Int,
)

// FauxPas.kt

data class FauxPas(
	val context: String,
    val action: String
)

/** A spec or type which can be annotated. */
public interface Annotatable {
	public val annotations: List<AnnotationSpec>
}

@Composable
private fun SearchTextField(
    searchQuery: String,
    onSearchQueryChanged: (String) -> Unit,
    onSearchTriggered: (String) -> Unit,
) {
    val focusRequester = remember { FocusRequester() }
    val keyboardController = LocalSoftwareKeyboardController.current

    TextField(
        modifier = Modifier
            .fillMaxWidth()
            .padding(16.dp)
            .focusRequester(focusRequester)
            .onKeyEvent {
                if (it.key == Key.Enter) {
                    onSearchExplicitlyTriggered()
                    true
                } else {
                    false
                }
            }
            .testTag("searchTextField"),
        shape = RoundedCornerShape(32.dp),
        value = searchQuery,
        keyboardOptions = KeyboardOptions(
            imeAction = ImeAction.Search,
        ),
        keyboardActions = KeyboardActions(
            onSearch = {
                onSearchTriggered()
            },
        ),
        maxLines = 1,
        singleLine = true,
    )
    LaunchedEffect(Unit) {
        focusRequester.requestFocus()
    }
}

class PaymentProcessor(private val creditCardServer: CreditCardServer) {

    fun processPayment(creditCard: CreditCard, money: Money) {
        if (!creditCardServer.isAvailable()) {
            throw NotAvailableException()
        }

        val transaction = creditCardServer.beginTransaction().transaction
        val payment = creditCardServer.pay(transaction, creditCard, 500)

        if (payment.isOverMaxBalance()) {
            throw OverMaxBalanceException()
        }
    }
}

class HappyBirthdayViewModel(
    private val userRepository: UserRepository
    private val clock: Clock
) {
    init {
        val birthday = userRepository.user.getField("brthiday")
        if (birthday == clock.today()) {
            _viewState = _viewState.copy(party = true)
        }
    }
}

fun testCreditCardIsCharged() {
    val paymentProcessor = PaymentProcessor(mockCreditCardServer)
    whenever(mockCreditCardServer.isServerAvailable()).thenReturn(true)
    whenever(mockCreditCardServer.beginTransaction()).thenReturn(mockTransactionManager)
    whenever(mockTransactionManager.getTransaction()).thenReturn(transaction)
    whenever(mockCreditCardServer.pay(transaction, creditCard, 500)).thenReturn(mockPayment)
    whenever(mockPayment.isOverMaxBalance()).thenReturn(false)
    
    paymentProcessor.processPayment(creditCard, Money.dollars(500))
    
    verify(mockCreditCardServer).pay(transaction, creditCard, 500)
}

fun testCreditCardIsCharged() {
	paymentProcessor = PaymentProcessor(fakeCreditCardServer)
	paymentProcessor.processPayment(creditCard, Money.dollars(500))
	assertEquals(500, fakeCreditCardServer.getMostRecentCharge(creditCard))
}