@Composable
fun <T : Any> LazyPagingListRowWithHeader(
    paginatedItemList: LazyPagingItems<T>,
    content: @Composable (index: Int, item: T) -> Unit,
    headerContent: @Composable () -> Unit,
    modifier: Modifier = Modifier,
    horizontalPadding: Dp = 0.dp,
) {
    when (val refreshState = paginatedItemList.loadState.refresh) {
        is LoadState.Loading -> {
            Column(
                modifier = Modifier.fillMaxSize(),
                verticalArrangement = Arrangement.Center,
                horizontalAlignment = Alignment.CenterHorizontally
            ) {
                CircularProgressIndicator()
            }
        }
        is LoadState.Error -> {
            Timber.d(refreshState.error.localizedMessage)
        }
        is LoadState.NotLoading -> {
            LazyRow(
                modifier
                    .padding(top = horizontalPadding, bottom = horizontalPadding)
                    .wrapContentSize()
            ) {
                item {
                    Column(Modifier.padding(end = 12.dp).clickable { paginatedItemList.refresh() }) {
                        headerContent()
                    }
                }

                this.itemsIndexed(paginatedItemList) { index, item ->
                    Surface(modifier
                        .wrapContentSize()
                        .padding(end = 12.dp)) {
                        if (item != null) {
                            content(index, item)
                        }
                    }
                }
            }
        }
    }

    when (val appendState = paginatedItemList.loadState.append) {
        is LoadState.Loading -> {
            CircularProgressIndicator(
                modifier = Modifier
                    .fillMaxWidth()
                    .wrapContentWidth(Alignment.CenterHorizontally)
            )
        }

        is LoadState.Error -> {
            Timber.d(appendState.error.localizedMessage)
        }
    }
}