Adapter

import android.content.Context
import android.graphics.Typeface
import android.text.style.StyleSpan
import android.util.Log
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.Filter
import android.widget.Filterable
import androidx.recyclerview.widget.RecyclerView
import com.google.android.gms.maps.model.LatLng
import com.google.android.gms.tasks.Tasks
import com.google.android.libraries.places.api.model.AutocompleteSessionToken
import com.google.android.libraries.places.api.net.FindAutocompletePredictionsRequest
import com.google.android.libraries.places.api.net.PlacesClient
import com.joyn.joynprototype.R
import kotlinx.android.synthetic.main.list_item_place_map_autocomplete.view.*
import java.util.concurrent.ExecutionException
import java.util.concurrent.TimeUnit
import java.util.concurrent.TimeoutException

class PlacesAutoCompleteAdapter(
    private var context: Context,
    private var placesClient: PlacesClient,
    private var latLang: LatLng?
) :
    RecyclerView.Adapter<PlacesAutoCompleteAdapter.PredictionHolder>(), Filterable {

    var mResultList: List<PlacesAutoComplete> = ArrayList()

    override fun getFilter(): Filter {
        return object : Filter() {
            override fun performFiltering(constraint: CharSequence?): FilterResults {
                val result = FilterResults()
                Log.d("Filter", "Perform ${constraint.toString()}")
                // Skip the autocomplete query if no constraints are given.
                if (constraint != null) {

                    mResultList = getPrediction(constraint)
                    result.values = mResultList
                    result.count = mResultList.size
                    Log.d("Filter", "Filter $constraint dan ${mResultList.size}")
                }
                return result
            }

            override fun publishResults(constraint: CharSequence?, results: FilterResults?) {
                if (results != null && results.count > 0) {
                    notifyDataSetChanged()
                } else {

                }
            }
        }
    }

    private fun getPrediction(constraint: CharSequence): List<PlacesAutoComplete> {

        Log.d("getPrediction", "latlang $latLang")
        val resultList = ArrayList<PlacesAutoComplete>()
        val token = AutocompleteSessionToken.newInstance()
        val request = FindAutocompletePredictionsRequest.builder()
            .setOrigin(latLang)
            .setCountry("ID")
            .setSessionToken(token)
            .setQuery(constraint.toString())
            .build()

        var autoCompletePrediction = placesClient.findAutocompletePredictions(request)

        try {
            Tasks.await(autoCompletePrediction, 60, TimeUnit.SECONDS)
        } catch (e: ExecutionException) {
            e.printStackTrace()
        } catch (e: InterruptedException) {
            e.printStackTrace()
        } catch (e: TimeoutException) {
            e.printStackTrace()
        }

        if (autoCompletePrediction.isSuccessful) {
            var findAutoCompletePredictionResponse = autoCompletePrediction.getResult()
            if (findAutoCompletePredictionResponse != null) {
                for (prediction in findAutoCompletePredictionResponse.autocompletePredictions) {
                    Log.d(
                        "Prediction",
                        " ${prediction.getSecondaryText(StyleSpan(Typeface.NORMAL)).toString()} distance = ${prediction.distanceMeters.toString()}"
                    )
                    resultList.add(
                        PlacesAutoComplete(
                            prediction.placeId,
                            prediction.getPrimaryText(StyleSpan(Typeface.NORMAL)),
                            prediction.getFullText(StyleSpan(Typeface.BOLD))
                        )
                    )
                }
                return resultList
            }
        }
        return resultList
    }

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): PredictionHolder {
        val view = LayoutInflater.from(context)
            .inflate(R.layout.list_item_place_map_autocomplete, parent, false)
        return PredictionHolder(view)
    }

    override fun getItemCount(): Int {
        return mResultList.size
    }

    override fun onBindViewHolder(holder: PredictionHolder, position: Int) {
        holder.bind(mResultList[position])
    }

    class PredictionHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
        fun bind(item: PlacesAutoComplete) {
            with(itemView) {
                place_address.text = item.address
                place_area.text = item.area
            }
        }
    }

    data class PlacesAutoComplete(
        var placeId: CharSequence? = null,
        var area: CharSequence? = null,
        var address: CharSequence? = null
    )

}