package mx.trackermap.TrackerMap.android.details.reports

import android.os.Bundle
import android.util.Log
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.PopupMenu
import android.widget.TableRow
import android.widget.TextView
import androidx.fragment.app.Fragment
import mx.trackermap.TrackerMap.android.R
import mx.trackermap.TrackerMap.android.databinding.UnitDetailsReportsBinding
import mx.trackermap.TrackerMap.android.details.UnitDetailsAdapter
import mx.trackermap.TrackerMap.client.models.Event
import mx.trackermap.TrackerMap.client.models.Position
import mx.trackermap.TrackerMap.client.models.Stop
import org.koin.androidx.viewmodel.ext.android.viewModel

class UnitReportsFragment : Fragment() {

    private var _binding: UnitDetailsReportsBinding? = null
    private val binding get() = _binding!!

    private val unitReportsViewModel: UnitReportsViewModel by viewModel()

    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View {
        _binding = UnitDetailsReportsBinding.inflate(inflater, container, false)
        return binding.root
    }

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

        unitReportsViewModel.deviceId.value =
            arguments?.getInt(UnitDetailsAdapter.DEVICE_ID_ARG) ?: 0
        setupEvents()
        setupObservers()
    }

    override fun onDestroyView() {
        super.onDestroyView()
        _binding = null
    }

    private fun setupEvents() {
        binding.reportType.setOnPositionChangedListener { position ->
            unitReportsViewModel.reportType.value = when (position) {
                0 -> UnitReportsViewModel.ReportType.POSITIONS
                1 -> UnitReportsViewModel.ReportType.EVENTS
                else -> UnitReportsViewModel.ReportType.STOPS
            }
        }
        binding.periodButton.setOnClickListener {
            showPeriodPopUp(it)
        }
        unitReportsViewModel.reportPeriod.value = UnitReportsViewModel.ReportPeriod.DAY
        unitReportsViewModel.reportType.value = UnitReportsViewModel.ReportType.POSITIONS
    }

    private fun setupObservers() {
        unitReportsViewModel.report.observe(this) { report ->
            Log.d("UnitReportsFragment", "Report available: $report")

            when (report) {
                is UnitReportsViewModel.Report.PositionsReport -> display(report.positions)
                is UnitReportsViewModel.Report.EventsReport -> display(report.events)
                is UnitReportsViewModel.Report.StopsReport -> display(report.stops)
            }
        }

        unitReportsViewModel.reportPeriod.observe(this) { period ->
            Log.d("UnitReportsFragment", "Period changed: $period")
            if (period == null) {
                return@observe
            }

            binding.periodButton.text = context?.getString(
                when (period) {
                    UnitReportsViewModel.ReportPeriod.DAY -> R.string.day_period
                    UnitReportsViewModel.ReportPeriod.WEEK -> R.string.week_period
                    UnitReportsViewModel.ReportPeriod.MONTH -> R.string.month_period
                }
            )
        }
    }

    private fun showPeriodPopUp(view: View) {
        val popOver = PopupMenu(context, view)
        popOver.menuInflater.inflate(R.menu.report_period_options, popOver.menu)
        popOver.setOnMenuItemClickListener { item ->
            unitReportsViewModel.reportPeriod.value = when (item.itemId) {
                R.id.dayOption -> UnitReportsViewModel.ReportPeriod.DAY
                R.id.weekOption -> UnitReportsViewModel.ReportPeriod.WEEK
                else -> UnitReportsViewModel.ReportPeriod.MONTH
            }
            true
        }
        popOver.show()
    }

    private fun display(positions: Array<Position>) {
        Log.d("UnitReportsFragment", "Displaying positions: $positions")

        binding.eventsScroll.visibility = View.GONE
        binding.reportMap.visibility = View.VISIBLE
    }

    private fun display(events: Array<Event>) {
        Log.d("UnitReportsFragment", "Displaying events: $events")

        binding.eventsScroll.visibility = View.VISIBLE
        binding.reportMap.visibility = View.GONE
        binding.eventsTable.removeViews(1, Math.max(0, binding.eventsTable.childCount - 1))

        val context = context!!
        events.forEach { event ->
            val row = TableRow(context)
            val eventText = TextView(context)
            val datetimeText = TextView(context)

            row.addView(eventText)
            row.addView(datetimeText)
            binding.eventsTable.addView(row)

            eventText.text = event.type
            datetimeText.text = event.eventTime
        }
    }

    private fun display(stops: Array<Stop>) {
        Log.d("UnitReportsFragment", "Displaying stops: $stops")

        binding.eventsScroll.visibility = View.GONE
        binding.reportMap.visibility = View.VISIBLE
    }
}