class MyPagedListAdapter: PagedListAdapter<Model, RecyclerView.ViewHolder>(DIFF_CALLBACK) {

    companion object {
        private val DIFF_CALLBACK = object : DiffUtil.ItemCallback<Model>() {
            override fun areItemsTheSame(oldItem: Model, newItem: Model): Boolean {
                return oldItem.id == newItem.id
            }

            override fun areContentsTheSame(oldItem: Model, newItem: Model): Boolean {
                return oldItem == newItem
            }
        }

        const val TYPE_PROGRESS = R.layout.layout_home_loading
        const val TYPE_ITEM = ViewHolder.layoutRes
    }

    lateinit var listener:ListListener
    var NetworkState: NetworkState? = null
        set(value) {
            if (value == NetworkState.LOADING) {
                notifyDataSetChanged()
                notifyItemInserted(itemCount - 1)
            } else if (field == NetworkState.LOADING) {
                notifyDataSetChanged()
                notifyItemRemoved(itemCount - 1)
            }
            field = value
        }

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): RecyclerView.ViewHolder {
        val inflater = LayoutInflater.from(parent.context)
        val view = inflater.inflate(viewType, parent, false)
        return when (viewType) {
            TYPE_PROGRESS -> LoadingViewHolder(view)
            else -> ViewHolder(view)
        }
    }

    override fun onBindViewHolder(holder: RecyclerView.ViewHolder, position: Int) {
        when (holder) {
            is ViewHolder -> {
                getItem(position)?.let { holder.bind(it, listener) }
            }
            is LoadingViewHolder -> { holder.bind(NetworkState)}
        }
    }

    override fun getItemViewType(position: Int): Int {
        if (NetworkState == NetworkState.LOADING && position == itemCount -1){
            return TYPE_PROGRESS
        } else {
            return TYPE_ITEM
        }
    }

    override fun getItemCount(): Int {
        val contentCount = super.getItemCount()
        if (NetworkState == NetworkState.LOADING) return contentCount +1
        return contentCount
    }

    class LoadingViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {

        fun bind(networkState: NetworkState?) {
            if (networkState != null && networkState.status == NetworkState.Status.RUNNING) {
                itemView.visibility = View.VISIBLE
            } else {
                itemView.visibility = View.GONE
            }
        }
    }

    open class ViewHolder(itemView:View):RecyclerView.ViewHolder(itemView){

        companion object {
            const val layoutRes = R.layout.layout_pagedlist
        }

        open fun bind(model:Model, listener: ListListener){
            with(itemView){
                Picasso.with(itemView.context)
                        .load(MyTransformation.imageLargePreview(model.imageCover))
                        .into(imageView)
                textViewName.text = model.name
                textViewService.text = String.format("%s - %s, %s", model.categoryName, model.cityName, model.countryIso)
                textViewBudget.text = model.budgetName
                ratingBar.rating = model.rating
                textViewRaterCount.setText(model.raterCount.toString())
                textViewRaterCount.visibility = if (model.raterCount > 0) View.VISIBLE else View.GONE
                textViewFirstToReview.visibility = if (model.raterCount > 0) View.GONE else View.VISIBLE
            }

            itemView.imageViewImage.setOnClickListener {
                listener?.onClickListener()
            }
        }
    }
}

interface ListListener {

    fun onClickListener()

    fun onClickSort()