package `in`.zelish.zelish.dish_like

import `in`.zelish.zelish.LandingScreenAcitivity
import `in`.zelish.zelish.R
import `in`.zelish.zelish.db.AppDatabase
import `in`.zelish.zelish.newer_home.adapter.CollectionAdapter
import `in`.zelish.zelish.rest.RestClient
import `in`.zelish.zelish.rest.SimpleResponse
import `in`.zelish.zelish.rest.model.DishData
import `in`.zelish.zelish.utils.*
import android.content.Context
import android.content.Intent
import android.os.AsyncTask
import android.os.Bundle
import android.util.Log
import android.view.View
import androidx.appcompat.app.AppCompatActivity
import androidx.recyclerview.widget.GridLayoutManager
import androidx.recyclerview.widget.RecyclerView
import com.google.gson.JsonObject
import kotlinx.android.synthetic.main.activity_liked_dishes.*
import org.jetbrains.anko.doAsync
import org.jetbrains.anko.uiThread
import retrofit2.Call
import retrofit2.Callback
import retrofit2.Response
import rx.android.schedulers.AndroidSchedulers
import rx.schedulers.Schedulers
import java.lang.ref.WeakReference

class DishLikeActivity : AppCompatActivity() {

    val TAG = javaClass.simpleName
    lateinit var rv_liked_dishes: RecyclerView
    var adapter: CollectionAdapter? = null
    var likedList: ArrayList<DishData>? = ArrayList();
    var context: Context? = null
    var offset = 0; val limit = 10;
    var isLoading = false;
    var userId = ""

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_liked_dishes)
        context = this@DishLikeActivity
        userId = PreferenceHandler.getUserId(this)
        AnalyticsProvider.updateAnaylytcsBooleans("My_Fav_Recipes", true);

        btn_back.setOnClickListener({
            onBackPressed()
        })

        rv_liked_dishes = findViewById(R.id.rv_liked_dishes)
        val spaceValue = Helper.dpToPx(8)
        rv_liked_dishes.addItemDecoration(SpacesItemDecoration(spaceValue, spaceValue, spaceValue, Helper.dpToPx(10)))
        val manager = GridLayoutManager(this, 2)
        rv_liked_dishes.setLayoutManager(manager)

        adapter = CollectionAdapter(this)
        adapter?.setTwoGridView(true)
        adapter?.setFinish(true)
        adapter?.setFrom("Liked Dishes")
        rv_liked_dishes.adapter = adapter

        /*rv_liked_dishes.addOnScrollListener(object : RecyclerView.OnScrollListener() {
            override fun onScrolled(recyclerView: RecyclerView, dx: Int, dy: Int) {
                super.onScrolled(recyclerView, dx, dy)
                val layoutManager = rv_liked_dishes.getLayoutManager() as GridLayoutManager
                val pos = layoutManager.findLastCompletelyVisibleItemPosition()
                val numItems = adapter!!.itemCount
                if (pos >= numItems - 1) {

                    Log.e("DishLikeActivity", "onScrolled offset=$offset, isLoading=$isLoading")
                    if (!isLoading) {
                        offset += likedList!!.size;
                        DishDetailsActivityV2.fetchDB(this@DishLikeActivity, offset, 10).execute()
                        isLoading = true;
                    }

                }
            }
        })*/

        if(intent.hasExtra("addToFav")){
            val dishId = intent.getStringExtra("addToFav")
            updateToServer(dishId!!, userId, false)
        }else {
            getAllLikedRecipes()
        }

    }//onCreate

    override fun onResume() {
        super.onResume()

        /*DialogShower.showProgressDialog(this)
        likedList?.clear()
        adapter?.clearSuggetions()
        adapter?.notifyDataSetChanged()

        offset = 0;
        val limit = 10;*/
        /*if(likedList!=null && !likedList!!.isEmpty()){
            limit = likedList!!.size
        }*/

        Log.e("DishLikeActivity", "onResume offset=$offset, isLoading=$isLoading")
        //DishDetailsActivityV2.fetchDB(this, offset, limit).execute()
        //isLoading=true;
    }

    fun updateToServer(dishId: String, userId: String, isLiked: Boolean) {
        DialogShower.showProgressDialog(this)

        val `object` = JsonObject()
        `object`.addProperty("dishId", dishId)
        `object`.addProperty("userId", userId)
        `object`.addProperty("liked", isLiked)

        RestClient().apiService.likeRecipe(`object`)
            .enqueue(object : Callback<SimpleResponse?> {
                override fun onResponse(call: Call<SimpleResponse?>, response: Response<SimpleResponse?>) {
                    Log.e(TAG, "updateToServer response"+ response?.body()?.data)
                    DialogShower.showToast(this@DishLikeActivity, response?.body()?.data)
                    getAllLikedRecipes()
                }

                override fun onFailure(call: Call<SimpleResponse?>, t: Throwable) {
                    t.printStackTrace()
                    DialogShower.dismissProgressDialog()
                }
            })

    }

    fun getAllLikedRecipes(){
        DialogShower.showProgressDialog(this)

        RestClient().apiService.getAllLikedRecipes(userId)
            .subscribeOn(Schedulers.newThread())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe({
                if(it!=null && it.data!=null) {
                    Log.e(TAG, "getAllLikedRecipes response")
                    val allDishes = it.data

                    if (allDishes!=null && !allDishes.isEmpty()) {
                        Log.e(TAG, "allDishes=${allDishes?.size}, ${allDishes.toString()}")

                        doAsync {

                            var dishDataList = java.util.ArrayList<DishData>()
                            for (dlt in allDishes) {
                                val dishData = DishData(dlt)
                                dishData.isLiked = true
                                dishDataList.add(dishData)
                            }

                            uiThread {
                                Log.e(
                                    TAG,
                                    "getAllLikedRecipes dishDataList.size=" + dishDataList.size
                                )

                                likedList?.addAll(dishDataList)
                                showData()
                                DialogShower.dismissProgressDialog()
                            }
                        }
                    }else{
                        showEmpty()
                    }

                }else{
                    showEmpty()
                }
            })
            {
                Log.e(TAG, "getAllLikedRecipes() response ERROR")
                DialogShower.dismissProgressDialog()
                DialogShower.showToast(this, getString(R.string.user_already_exists))
            }

    }

    companion object {
        class fetchDB internal constructor(context: DishLikeActivity, offset: Int, limit: Int) : AsyncTask<Int, String, ArrayList<DishData>>() {

            private var resp: String? = null
            private val activityReference: WeakReference<DishLikeActivity> = WeakReference(context)
            var offset = offset;
            var limit = limit;

            override fun doInBackground(vararg params: Int?): ArrayList<DishData>? {
                Log.e("DishLikeActivity", "doInBackground offset=$offset, limit=$limit")

                val allDishes: ArrayList<DishLikeTable> = AppDatabase.getDatabase(activityReference.get()).dishLikeDao().getDishes(offset, limit) as ArrayList<DishLikeTable>
                var dishDataList = java.util.ArrayList<DishData>()

                if(allDishes!=null && !allDishes.isEmpty()) {
                    Log.e("DishLikeActivity", "allDishes=${allDishes?.size}, ${allDishes.toString()}")

                    for (dlt in allDishes) {
                        val dishData = DishData(dlt)
                        dishDataList.add(dishData)
                    }
                }

                return dishDataList
            }


            override fun onPostExecute(result: ArrayList<DishData>) {

                val activity = activityReference.get()
                if (activity == null || activity.isFinishing) return

                Log.e("DishLikeActivity", "onPostExecute result=${result?.size}")
                activity.likedList?.addAll(result)
                activity.showData()
            }

        }
    }

    fun showData() {

        DialogShower.dismissProgressDialog()
        if (likedList == null || likedList!!.isEmpty()) {
            showEmpty()
            return
        }else{
            isLoading = false;
            adapter?.updateSuggetions(likedList!!)
            adapter?.notifyDataSetChanged()
        }
    }

    fun showEmpty() {
        DialogShower.dismissProgressDialog()
        tv_empty.visibility = View.VISIBLE
    }

    override fun onBackPressed() {
        if(intent.hasExtra("addToFav")){
            val intent = Intent(this@DishLikeActivity, LandingScreenAcitivity::class.java)
            intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_CLEAR_TASK)
            startActivity(intent)
        }else{
            super.onBackPressed()
        }
    }

}