//Define data type
class NormalItem(val i: Int, val text: String = "") : YashaItem

//Create DataSource and add data
val dataSource = YashaDataSource()
val items = mutableListOf<YashaItem>()
for (i in 0 until 10) {
    items.add(NormalItem(i))
}
dataSource.addItems(items)

//Render Item
recyclerView.linear(dataSource){
    // Use reflection to construct ViewBinding
    renderBindingItem<NormalItem, ViewHolderNormalBinding> {
        onBind {
            itemBinding.tvNormalContent.text = "position: $position, data: $data"
        }
    }
    // or
    // Do not use reflection to construct ViewBinding
    renderBindingItem<NormalItem, ViewHolderNormalBinding>() {
        viewBinding(ViewHolderNormalBinding::inflate)
        onBind {
            itemBinding.tvNormalContent.text = "position: $position, data: $data"
        }
    }
}

// Inherit YashaDataSource and rewrite the **loadInitial** and **loadAfter** methods
class CustomDataSource(coroutineScope: CoroutineScope) : YashaDataSource(coroutineScope) {
    var page = 0

    // Called when initial loading, located in the IO thread
    override suspend fun loadInitial(): List<YashaItem>? {
        page = 0
    
        val items = mutableListOf<YashaItem>()
        for (i in 0 until 10) {
            items.add(NormalItem(i))
        }

        // Return null to trigger loading failure
        // Return to empty list to trigger no more
        return items
    }

    // Called when the page is loaded, located in the IO thread
    override suspend fun loadAfter(): List<YashaItem>? {
        page++

        //Simulated loading failed
        if (page % 5 == 0) {
            // Return null to trigger loading failure
            return null  
        }

        val items = mutableListOf<YashaItem>()
        for (i in 0 until 10) {
            items.add(NormalItem(i))
        }

        // Return to empty list to trigger no more
        return items
    }
}

//Define data type A
class AItem(val i: Int) : YashaItem

//Define data type B
class BItem(val i:Int) : YashaItem

//Add different types of data
val dataSource = YashaDataSource()
val items = mutableListOf<YashaItem>()
for (i in 0 until 5) {
    items.add(AItem(i))
}
for (i in 5 until 10){
    items.add(BItem(i))
}
dataSource.addItems(items)

//Render Item
recyclerView.linear(dataSource){
    //Render AItem
    renderBindingItem<AItem, AItemBinding> {
        onBind {
            //render
            ...
        }
    }
    //Render BItem
    renderBindingItem<BItem, BItemBinding> {
        onBind {
            //render
            ...
        }
    }
}

//Headers
fun addHeader(t: T, position: Int = -1, delay: Boolean = false)
fun addHeaders(list: List<T>, position: Int = -1, delay: Boolean = false) 
fun removeHeader(t: T, delay: Boolean = false) 
fun setHeader(old: T, new: T, delay: Boolean = false)
fun getHeader(position: Int): T
fun clearHeader(delay: Boolean = false)

//Footers
fun addFooter(t: T, position: Int = -1, delay: Boolean = false)
fun addFooters(list: List<T>, position: Int = -1, delay: Boolean = false) 
fun removeFooter(t: T, delay: Boolean = false) 
fun setFooter(old: T, new: T, delay: Boolean = false)
fun getFooter(position: Int): T
fun clearFooter(delay: Boolean = false)

//When defining the data type, override the Diff method
class NormalItem(val i: Int, val text: String = "") : YashaItem {

    override fun areItemsTheSame(other: Differ): Boolean {
        if (other !is NormalItem) return false
        return other.i == i
    }

    override fun areContentsTheSame(other: Differ): Boolean {
        if (other !is NormalItem) return false
        return other.text == text
    }

    //Set the payload
    override fun getChangePayload(other: Differ): Any? {
        if (other !is NormalItem) return null
        return other.text 
    }
}

//dataSource updates the new Item data
val oldItem = NormalItem(1, "1")
val newItem = NormalItem(2, "2")
dataSource.setItem(oldItem, newItem)

// Register onBindPayload when rendering
recyclerView.linear(dataSource){
    renderBindingItem<NormalItem, ViewHolderNormalBinding> {
        onBind {
            itemBinding.tvNormalContent.text = "position: $position, data: $data"
        }
        onBindPayload {
            //Take out the payload for partial refresh
            val payload = it[0]
            if (payload != null) {
                itemBinding.tvNormalContent.text = payload.toString()
            }
        }
    }
}

//Use the default loading state
val dataSource = YashaDataSource(enableDefaultState = true)

//or
//Custom loading status
class CustomStateItem(val state: Int) : YashaItem
class CustomDataSource : YashaDataSource(enableDefaultState = false) {

    override fun onStateChanged(newState: Int) {
        setState(CustomStateItem(newState))
    }
}

//Render custom state
recyclerView.linear(dataSource){
    ...
    renderBindingItem<CustomStateItem, CustomStateItemBinding> {
        onBind {
            when (data.state) {
                FetchingState.FETCHING -> {
                    //loading
                }
                FetchingState.FETCHING_ERROR -> {
                    //loading failed
                }
                FetchingState.DONE_FETCHING -> {
                   //loading complete
                }
                else -> {
                    //other
                }
            }
        }
    }
}