package app.rickandmorty.strictmode

import android.content.Context
import android.os.Build
import android.os.StrictMode
import android.os.StrictMode.ThreadPolicy
import android.os.StrictMode.VmPolicy
import android.os.strictmode.UntaggedSocketViolation
import androidx.startup.Initializer
import java.util.concurrent.Executors

internal class StrictModeInitializer : Initializer<Unit> {
    // TODO inject default dispatcher
    private val penaltyListenerExecutor by lazy(LazyThreadSafetyMode.NONE) {
        Executors.newSingleThreadExecutor()
    }

    override fun create(context: Context) {
        val threadPolicy = ThreadPolicy.Builder()
            .detectAll()
            .apply {
                if (Build.VERSION.SDK_INT < 28) {
                    penaltyLog()
                } else {
                    penaltyListener(penaltyListenerExecutor) {
                        // TODO log violations
                    }
                }
            }
            .build()
        StrictMode.setThreadPolicy(threadPolicy)

        val vmPolicy = VmPolicy.Builder()
            .detectAll()
            .apply {
                if (Build.VERSION.SDK_INT < 28) {
                    penaltyLog()
                } else {
                    penaltyListener(penaltyListenerExecutor) { violation ->
                        when (violation) {
                            is UntaggedSocketViolation -> {
                                // Firebase and OkHttp don't tag sockets
                                return@penaltyListener
                            }
                        }

                        // TODO log violations
                    }
                }
            }
            .build()
        StrictMode.setVmPolicy(vmPolicy)
    }

    override fun dependencies(): List<Class<out Initializer<*>>> = emptyList()
}

package app.rickandmorty.jankstats

import android.app.Activity
import androidx.metrics.performance.JankStats
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.android.components.ActivityComponent

@Module
@InstallIn(ActivityComponent::class)
internal object JankStatsModule {
    @Provides
    fun providesJankStats(activity: Activity): JankStats {
        val frameListener = JankStats.OnFrameListener { frameData ->
            if (frameData.isJank) {
                // TODO log jank
            }
        }
        return JankStats.createAndTrack(activity.window, frameListener)
    }
}

package app.rickandmorty.strictmode

import android.content.Context
import android.os.Build
import android.os.StrictMode
import android.os.StrictMode.ThreadPolicy
import android.os.StrictMode.VmPolicy
import android.os.strictmode.UntaggedSocketViolation
import androidx.startup.Initializer
import java.util.concurrent.Executors

internal class StrictModeInitializer : Initializer<Unit> {
    // TODO inject default dispatcher
    private val penaltyListenerExecutor by lazy(LazyThreadSafetyMode.NONE) {
        Executors.newSingleThreadExecutor()
    }

    override fun create(context: Context) {
        val threadPolicy = ThreadPolicy.Builder()
            .detectAll()
            .apply {
                if (Build.VERSION.SDK_INT < 28) {
                    penaltyLog()
                } else {
                    penaltyListener(penaltyListenerExecutor) {
                        // TODO log violations
                    }
                }
            }
            .build()
        StrictMode.setThreadPolicy(threadPolicy)

        val vmPolicy = VmPolicy.Builder()
            .detectAll()
            .apply {
                if (Build.VERSION.SDK_INT < 28) {
                    penaltyLog()
                } else {
                    penaltyListener(penaltyListenerExecutor) { violation ->
                        when (violation) {
                            is UntaggedSocketViolation -> {
                                // Firebase and OkHttp don't tag sockets
                                return@penaltyListener
                            }
                        }

                        // TODO log violations
                    }
                }
            }
            .build()
        StrictMode.setVmPolicy(vmPolicy)
    }

    override fun dependencies(): List<Class<out Initializer<*>>> = emptyList()
}

package app.rickandmorty.feature.characters.list

import androidx.activity.compose.ReportDrawnWhen
import androidx.compose.foundation.layout.consumeWindowInsets
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.material3.CenterAlignedTopAppBar
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.ListItem
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.unit.dp
import androidx.hilt.navigation.compose.hiltViewModel
import androidx.paging.compose.LazyPagingItems
import androidx.paging.compose.collectAsLazyPagingItems
import androidx.paging.compose.itemKey
import app.rickandmorty.core.designsystem.icon.RamIcons
import app.rickandmorty.core.ui.resources.R as UiR
import app.rickandmorty.data.model.Character
import app.rickandmorty.feature.characters.R
import coil3.compose.AsyncImage

@Composable
internal fun CharacterListScreen(
    onNavigateToSettings: () -> Unit,
    viewModel: CharacterListViewModel = hiltViewModel(),
) {
    val characters = viewModel.characters.collectAsLazyPagingItems()

    ReportDrawnWhen {
        characters.itemCount > 0 ||
            characters.loadState.refresh.endOfPaginationReached
    }

    CharacterListScreen(
        characters = characters,
        onNavigateToSettings = onNavigateToSettings,
    )
}

// TODO implement loading/error states
@Composable
private fun CharacterListScreen(
    characters: LazyPagingItems<Character>,
    onNavigateToSettings: () -> Unit,
) {
    Scaffold(
        topBar = {
            CharacterListScreenAppBar(

package app.rickandmorty.strictmode

import android.content.Context
import android.os.Build
import android.os.StrictMode
import android.os.StrictMode.ThreadPolicy
import android.os.StrictMode.VmPolicy
import android.os.strictmode.UntaggedSocketViolation
import androidx.startup.Initializer
import java.util.concurrent.Executors

internal class StrictModeInitializer : Initializer<Unit> {
    // TODO inject default dispatcher
    private val penaltyListenerExecutor by lazy(LazyThreadSafetyMode.NONE) {
        Executors.newSingleThreadExecutor()
    }

    override fun create(context: Context) {
        val threadPolicy = ThreadPolicy.Builder()
            .detectAll()
            .apply {
                if (Build.VERSION.SDK_INT < 28) {
                    penaltyLog()
                } else {
                    penaltyListener(penaltyListenerExecutor) {
                        // TODO log violations
                    }
                }
            }
            .build()
        StrictMode.setThreadPolicy(threadPolicy)

        val vmPolicy = VmPolicy.Builder()
            .detectAll()
            .apply {
                if (Build.VERSION.SDK_INT < 28) {
                    penaltyLog()
                } else {
                    penaltyListener(penaltyListenerExecutor) { violation ->
                        when (violation) {
                            is UntaggedSocketViolation -> {
                                // Firebase and OkHttp don't tag sockets
                                return@penaltyListener
                            }
                        }

                        // TODO log violations
                    }
                }
            }
            .build()
        StrictMode.setVmPolicy(vmPolicy)
    }

    override fun dependencies(): List<Class<out Initializer<*>>> = emptyList()
}

    )
}

// Todo localize errors
@OptIn(ExperimentalMaterial3Api::class)
@Composable
private fun CharacterListScreen(
    characters: LazyPagingItems<Character>,
    onNavigateToSettings: () -> Unit,
) {
    val snackbarHostState = remember { SnackbarHostState() }

    val loadState = characters.loadState

    loadState.refresh.errorOrNull?.let { error ->
        LaunchedEffect(snackbarHostState, error) {
            snackbarHostState.showSnackbar("Error")
        }
    }
    loadState.append.errorOrNull?.let { error ->
        LaunchedEffect(snackbarHostState, error) {
            snackbarHostState.showSnackbar("Error")
        }
    }

    val scrollBehavior = TopAppBarDefaults.enterAlwaysScrollBehavior()

    HazeScaffold(
        topBar = {
            CharacterListScreenAppBar(
                onNavigateToSettings = onNavigateToSettings,
                scrollBehavior = scrollBehavior,
            )
        },
        snackbarHost = { SnackbarHost(hostState = snackbarHostState) },
        blurTopBar = true,
    ) { contentPadding ->
        PullToRefresh(
            isRefreshing = loadState.refresh.isLoading,
            onRefresh = characters::refresh,
            indicatorPadding = contentPadding,
        ) {
            when {
                loadState.refresh.isLoading && characters.isEmpty -> {
                    Loader(
                        modifier = Modifier
                            .fillMaxWidth()
                            .wrapContentSize()
                            .padding(contentPadding),
                    )
                }

                loadState.refresh.isError && characters.isEmpty -> {
                    Error(
                        text = "Error",
                        onRetry = characters::retry,
                        modifier = Modifier
                            .fillMaxSize()
                            .padding(contentPadding),
                    )
                }

                loadState.refresh.isNotLoading && characters.isEmpty -> {
                    // Todo empty state
                }

                else -> {
                    val listState = rememberLazyListState()

                    TrackScrollJank(
                        scrollableState = listState,
                        stateName = "characterList:screen",
                    )

                    LazyColumn(
                        modifier = Modifier
                            .nestedScroll(scrollBehavior.nestedScrollConnection)
                            .fillMaxSize()
                            .consumeWindowInsets(contentPadding),
                        state = listState,
                        contentPadding = contentPadding,
                    ) {
                        items(
                            count = characters.itemCount,
                            key = characters.itemKey { it.id },
                            contentType = characters.itemContentType { "character" },
                        ) { index ->
                            val item = characters[index]!!
                            CharacterItem(item)
                        }

                        appendLoadState(items = characters)
                    }
                }
            }
        }
    }
}

@Composable
private fun CharacterItem(character: Character) {
    ListItem(
        headlineContent = {
            Text(text = character.name)
        },
        leadingContent = {
            AsyncImage(
                model = character.imageUrl,
                contentDescription = null,
                modifier = Modifier.size(48.dp),
            )
        },
    )
}

@OptIn(ExperimentalMaterial3Api::class)
@Composable
private fun CharacterListScreenAppBar(
    onNavigateToSettings: () -> Unit,
    scrollBehavior: TopAppBarScrollBehavior,
) {
    CenterAlignedTopAppBar(
        title = {