DocumentFragment

package com.pupukkaltim.signer.view.fragment

import android.app.AlertDialog
import android.app.DatePickerDialog
import android.content.Intent
import android.os.Bundle
import android.util.Log
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.*
import androidx.core.view.isNotEmpty
import androidx.fragment.app.Fragment
import androidx.lifecycle.Observer
import androidx.lifecycle.ViewModelProvider
import androidx.recyclerview.widget.LinearLayoutManager
import androidx.transition.TransitionInflater
import com.google.android.material.textfield.TextInputEditText
import com.pupukkaltim.signer.R
import com.pupukkaltim.signer.adapter.DocumentAdapter
import com.pupukkaltim.signer.helper.EventObserver
import com.pupukkaltim.signer.model.Document
import com.pupukkaltim.signer.view.activity.DetailDocumentActivity
import com.pupukkaltim.signer.viewmodel.DocumentViewModel
import kotlinx.android.synthetic.main.fragment_document.*
import java.text.SimpleDateFormat
import java.util.*

class DocumentFragment : Fragment() {
    private lateinit var adapter: DocumentAdapter
    private lateinit var documentViewModel: DocumentViewModel

    private lateinit var sortByFinal : String
    private lateinit var sortValueFinal : String

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val inflater = TransitionInflater.from(requireContext())
        enterTransition = inflater.inflateTransition(R.transition.fade_in)
        exitTransition = inflater.inflateTransition(R.transition.fade_out)
    }

    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
        return inflater.inflate(R.layout.fragment_document, container, false)
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)

        adapter = DocumentAdapter()
        showRecyclerView()

        documentViewModel = ViewModelProvider(this, ViewModelProvider.NewInstanceFactory()).get(DocumentViewModel::class.java)
        documentViewModel.init(this@DocumentFragment.requireContext())

        //load data di sini
        documentViewModel.setListDocuments("", "2000-01-01", "2100-01-01", "0", "1000000000000", "updated_at", "true")

        documentViewModel.listDocuments.observe(viewLifecycleOwner, Observer { document ->
            if(document != null){
                adapter.setDocuments(document)
                shimmerFrameLayout.visibility = View.GONE
            }
        })

        documentViewModel.errorMessage.observe(viewLifecycleOwner, EventObserver { errorMessage ->
//            Toast.makeText(activity, errorMessage, Toast.LENGTH_SHORT).show()
            if (errorMessage.isNullOrEmpty()){
                tv_no_data.visibility = View.GONE
            } else {
                tv_no_data.visibility = View.VISIBLE
                tv_no_data.text = errorMessage
            }
        })

        if(documentViewModel.errorMessage.hasObservers()) {
            documentViewModel.errorMessage.removeObservers(this)
        }
    }

    override fun onResume() {
        super.onResume()
        search()

        //tombol filter sort
        sort()

        //tombol filter Filter
        filter()

        //tombol reset filter
        reset()
    }

    private fun search() {
        fab_search.setOnClickListener(View.OnClickListener {
            fab_menu.close(true)
            val fabAlert = AlertDialog.Builder(activity)
            val mView = layoutInflater.inflate(R.layout.dialog_fab_search, null)
            fabAlert.setCancelable(false)
            val edtSearch: TextInputEditText = mView.findViewById(R.id.edt_search)
            val btnCancel = mView.findViewById<Button>(R.id.btn_cancel)
            val btnSearch = mView.findViewById<Button>(R.id.btn_search)
            fabAlert.setView(mView)
            val alertShow = fabAlert.show()
            btnSearch.setOnClickListener {
                Log.e("test", "editTextdariDocument : ${edtSearch.text}")
                //load data di sini
                if (edtSearch.text!!.isNotEmpty()) {
                    documentViewModel.setListSearchDocuments(edtSearch.text.toString(),"2000-01-01", "2100-01-01", "0", "1000000000000", "updated_at", "true")

                    documentViewModel.listDocuments.observe(viewLifecycleOwner, Observer { document ->
                        if(document != null){
                            adapter.setDocuments(document)
                        }
                    })

                    documentViewModel.errorMessage.observe(viewLifecycleOwner, EventObserver { errorMessage ->
//                        Toast.makeText(activity, errorMessage, Toast.LENGTH_SHORT).show()
                        if (errorMessage.isNullOrEmpty()){
                            tv_no_data.visibility = View.GONE
                        } else {
                            tv_no_data.visibility = View.VISIBLE
                            tv_no_data.text = errorMessage
                        }
                    })

                    if(documentViewModel.errorMessage.hasObservers()) {
                        documentViewModel.errorMessage.removeObservers(this)
                    }
                }
                alertShow.dismiss()
            }
            btnCancel.setOnClickListener { alertShow.dismiss() }
        })
    }

    private fun sort() {
        fab_sort.setOnClickListener(View.OnClickListener {
            fab_menu.close(true)
            val fabAlert = AlertDialog.Builder(activity)
            val mView = layoutInflater.inflate(R.layout.dialog_fab_sort, null)
            fabAlert.setCancelable(false)
            val spnSortBy = mView.findViewById<Spinner>(R.id.spnsortby)
            val spnSort = mView.findViewById<Spinner>(R.id.spnsort)
            val btnCancel = mView.findViewById<Button>(R.id.btn_cancel)
            val btnSort = mView.findViewById<Button>(R.id.btn_sort)
            val sortBy = arrayOf("Nilai", "Tanggal Dokumen")
            val sortByValue = arrayOf("amount", "created_at")
            val sortValue = arrayOf("Ascending", "Descending")
            val sortValueVal = arrayOf("false", "true")

            fabAlert.setView(mView)
            val alertShow = fabAlert.show()

            val arrayAdapterSortBy = ArrayAdapter(this@DocumentFragment.requireContext(), android.R.layout.simple_spinner_item, sortBy)
            arrayAdapterSortBy.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item)
            spnSortBy.adapter = arrayAdapterSortBy

            spnSortBy.onItemSelectedListener = object : AdapterView.OnItemSelectedListener {
                override fun onItemSelected(parent: AdapterView<*>?, view: View?, position: Int, id: Long) {
                    sortByFinal = sortByValue[position]
                    Log.e("test", "SortByFinal : $sortByFinal")
                }

                override fun onNothingSelected(parent: AdapterView<*>?) { }
            }

            val arrayAdapterSortValue = ArrayAdapter(this@DocumentFragment.requireContext(), android.R.layout.simple_spinner_item, sortValue)
            arrayAdapterSortValue.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item)
            spnSort.adapter = arrayAdapterSortValue

            spnSort.onItemSelectedListener = object : AdapterView.OnItemSelectedListener {
                override fun onItemSelected(parent: AdapterView<*>?, view: View?, position: Int, id: Long) {
                    sortValueFinal = sortValueVal[position]
                    Log.e("test", "SortValueFinal : $sortValueFinal")
                }

                override fun onNothingSelected(parent: AdapterView<*>?) {}

            }

            btnSort.setOnClickListener {
                if (spnSort!!.isNotEmpty() && spnSortBy!!.isNotEmpty()) {
                    documentViewModel.setListDocuments("","2000-01-01", "2100-01-01", "0", "1000000000000", sortByFinal, sortValueFinal)

                    documentViewModel.listDocuments.observe(viewLifecycleOwner, Observer { document ->
                        if(document != null){
                            adapter.setDocuments(document)
                        }
                    })

                    documentViewModel.errorMessage.observe(viewLifecycleOwner, Observer {
                        it.getContentIfNotHandled()?.let { it ->
                            Toast.makeText(activity, it, Toast.LENGTH_LONG).show()
                        }
                    })
                }

                alertShow.dismiss()
            }
            btnCancel.setOnClickListener {
                alertShow.dismiss() }
        })
    }

    private fun filter() {
        fab_filter.setOnClickListener(View.OnClickListener {
            fab_menu.close(true)
            val fabAlert = AlertDialog.Builder(activity)
            val mView = layoutInflater.inflate(R.layout.dialog_fab_filter, null)
            fabAlert.setCancelable(false)
            val btnCancel = mView.findViewById<Button>(R.id.btn_cancel)
            val btnFilter = mView.findViewById<Button>(R.id.btn_filter)
            val startDate: ImageButton = mView.findViewById(R.id.btn_start_date)
            val tvStartDate: TextView = mView.findViewById(R.id.tv_start_date)
            val endDate: ImageButton = mView.findViewById(R.id.btn_end_date)
            val tvEndDate: TextView = mView.findViewById(R.id.tv_end_date)
            val edtStartValue: TextInputEditText = mView.findViewById(R.id.start_value)
            val edtEndValue: TextInputEditText = mView.findViewById(R.id.end_value)

            val startCalender = Calendar.getInstance()
            val endCalender = Calendar.getInstance()

            val myFormatStart = "yyyy-MM-dd"
            val myFormatEnd = "yyyy-MM-dd"
            val sdfStart = SimpleDateFormat(myFormatStart, Locale.UK)
            val sdfEnd = SimpleDateFormat(myFormatEnd, Locale.UK)

            val startDateSetListener = DatePickerDialog.OnDateSetListener { view, year, monthOfYear, dayOfMonth ->
                startCalender.set(Calendar.YEAR, year)
                startCalender.set(Calendar.MONTH, monthOfYear)
                startCalender.set(Calendar.DAY_OF_MONTH, dayOfMonth)

                tvStartDate.text = sdfStart.format(startCalender.time)
            }

            startDate.setOnClickListener {
                DatePickerDialog(this@DocumentFragment.requireContext(), startDateSetListener,
                    startCalender.get(Calendar.YEAR),
                    startCalender.get(Calendar.MONTH),
                    startCalender.get(Calendar.DAY_OF_MONTH)).show()
            }

            val endDateSetListener = DatePickerDialog.OnDateSetListener { view, year, monthOfYear, dayOfMonth ->
                endCalender.set(Calendar.YEAR, year)
                endCalender.set(Calendar.MONTH, monthOfYear)
                endCalender.set(Calendar.DAY_OF_MONTH, dayOfMonth)

                tvEndDate.text = sdfEnd.format(endCalender.time)
            }

            endDate.setOnClickListener {
                DatePickerDialog(this@DocumentFragment.requireContext(), endDateSetListener,
                    endCalender.get(Calendar.YEAR),
                    endCalender.get(Calendar.MONTH),
                    endCalender.get(Calendar.DAY_OF_MONTH)).show()
            }

            fabAlert.setView(mView)
            val alertShow = fabAlert.show()
            btnFilter.setOnClickListener {
                val tanggalAwal = sdfStart.format(startCalender.time)
                val tanggalAkhir = sdfEnd.format(endCalender.time)
                Log.e("test", "tanggal awal: $tanggalAwal")
                Log.e("test", "tanggal akhir: $tanggalAkhir")

                if (edtStartValue.text!!.isNotEmpty() && edtEndValue.text!!.isNotEmpty()) {
                    documentViewModel.setListDocuments("", "2000-01-01", "2100-01-01", edtStartValue.text.toString(), edtEndValue.text.toString(), "updated_at", "true")

                    documentViewModel.listDocuments.observe(viewLifecycleOwner, Observer { document ->
                        if(document != null){
                            adapter.setDocuments(document)
                        }
                    })

                    documentViewModel.errorMessage.observe(viewLifecycleOwner, Observer {
                        it.getContentIfNotHandled()?.let { it ->
                            Toast.makeText(activity, it, Toast.LENGTH_LONG).show()
                        }
                    })
                } else if (edtStartValue.text!!.isEmpty() && edtEndValue.text!!.isNotEmpty()) {
                    documentViewModel.setListDocuments("", "2000-01-01", "2100-01-01", "0", edtEndValue.text.toString(), "updated_at", "true")

                    documentViewModel.listDocuments.observe(viewLifecycleOwner, Observer { document ->
                        if(document != null){
                            adapter.setDocuments(document)
                        }
                    })

                    documentViewModel.errorMessage.observe(viewLifecycleOwner, Observer {
                        it.getContentIfNotHandled()?.let { it ->
                            Toast.makeText(activity, it, Toast.LENGTH_LONG).show()
                        }
                    })
                } else if (edtStartValue.text!!.isNotEmpty() && edtEndValue.text!!.isEmpty()) {
                    documentViewModel.setListDocuments("", "2000-01-01", "2100-01-01", edtStartValue.text.toString(), "1000000000000", "updated_at", "true")

                    documentViewModel.listDocuments.observe(viewLifecycleOwner, Observer { document ->
                        if(document != null){
                            adapter.setDocuments(document)
                        }
                    })

                    documentViewModel.errorMessage.observe(viewLifecycleOwner, Observer {
                        it.getContentIfNotHandled()?.let { it ->
                            Toast.makeText(activity, it, Toast.LENGTH_LONG).show()
                        }
                    })
                } else if (tanggalAwal.isNotEmpty() && tanggalAkhir.isNotEmpty()) {
                    documentViewModel.setListDocuments("", tanggalAwal, tanggalAkhir, "0", "1000000000000", "updated_at", "true")

                    documentViewModel.listDocuments.observe(viewLifecycleOwner, Observer { document ->
                        if(document != null){
                            adapter.setDocuments(document)
                        }
                    })

                    documentViewModel.errorMessage.observe(viewLifecycleOwner, Observer {
                        it.getContentIfNotHandled()?.let { it ->
                            Toast.makeText(activity, it, Toast.LENGTH_LONG).show()
                        }
                    })
                } else if (tanggalAwal.isNotEmpty() && tanggalAkhir.isNotEmpty() && edtStartValue.text!!.isNotEmpty() && edtEndValue.text!!.isNotEmpty()) {
                    documentViewModel.setListDocuments("", tanggalAwal, tanggalAkhir, edtStartValue.text.toString(), edtEndValue.text.toString(), "updated_at", "true")

                    documentViewModel.listDocuments.observe(viewLifecycleOwner, Observer { document ->
                        if(document != null){
                            adapter.setDocuments(document)
                        }
                    })

                    documentViewModel.errorMessage.observe(viewLifecycleOwner, Observer {
                        it.getContentIfNotHandled()?.let { it ->
                            Toast.makeText(activity, it, Toast.LENGTH_LONG).show()
                        }
                    })
                }

                alertShow.dismiss()
            }
            btnCancel.setOnClickListener {
                alertShow.dismiss()
            }
        })
    }

    private fun reset() {
        fab_reset.setOnClickListener {
            documentViewModel.setListDocuments("", "2000-01-01", "2100-01-01", "0", "1000000000000", "updated_at", "true")

            documentViewModel.listDocuments.observe(viewLifecycleOwner, Observer { document ->
                if(document != null){
                    adapter.setDocuments(document)
                }
            })

            documentViewModel.errorMessage.observe(viewLifecycleOwner, Observer {
                it.getContentIfNotHandled()?.let { it ->
                    Toast.makeText(activity, it, Toast.LENGTH_LONG).show()
                }
            })
        }
    }

    private fun showRecyclerView() {
        rv_document.layoutManager = LinearLayoutManager(context)
        rv_document.adapter = adapter

        adapter.notifyDataSetChanged()

        adapter.setOnItemClickCallback(object : DocumentAdapter.OnItemClickCallback {
            override fun onItemClicked(data: Document) {
                val intent = Intent(context, DetailDocumentActivity::class.java)
                intent.putExtra(DetailDocumentActivity.EXTRA_DOCUMENT, data)
                startActivity(intent)
            }
        })
    }
}