package io.polydevs.Nets.graph.dialogs.departments

import android.content.Context
import android.util.Log
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.ImageView
import androidx.recyclerview.widget.RecyclerView
import com.google.android.material.checkbox.MaterialCheckBox
import io.polydevs.Nets.R
import io.polydevs.Nets.databinding.GraphDialogItemBinding
import io.polydevs.Nets.databinding.GraphDialogSubgroupItemBinding
import io.polydevs.Nets.models.DepartmentsRowModel
import io.polydevs.Nets.models.DepartmentsRowType
import io.polydevs.Nets.models.NetType
import io.polydevs.Nets.setMarginsInDp

class DepartmentsRecyclerViewAdapter(
    val context: Context,
    val elements: List<DepartmentsRowModel>
) : RecyclerView.Adapter<RecyclerView.ViewHolder>() {

    inner class DepartmentsDropdownViewHolder(val binding: GraphDialogItemBinding) :
        RecyclerView.ViewHolder(binding.root)

    inner class DepartmentsViewHolder(val binding: GraphDialogSubgroupItemBinding) :
        RecyclerView.ViewHolder(binding.root)

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): RecyclerView.ViewHolder {
        return when (viewType) {
            1 -> DepartmentsDropdownViewHolder(
                GraphDialogItemBinding.inflate(
                    LayoutInflater.from(
                        parent.context
                    ),
                    parent, false
                )
            )
            else -> DepartmentsViewHolder(
                GraphDialogSubgroupItemBinding.inflate(
                    LayoutInflater.from(
                        parent.context
                    ),
                    parent, false
                )
            )
        }
    }

    override fun onBindViewHolder(holder: RecyclerView.ViewHolder, position: Int) {

        val item = elements[position]

        when (holder.itemViewType) {
            0 -> {
                // Select All
                with(holder as DepartmentsViewHolder) {
                    this.binding.apply {
                        val params: ViewGroup.MarginLayoutParams =
                            holder.binding.graphDialogSubgroupCheckbox.layoutParams as ViewGroup.MarginLayoutParams
                        params.setMarginsInDp(context, 0f, 0f, 0f, 16f)
                        graphDialogSubgroupCheckbox.apply {
                            layoutParams = params
                            text = "Выбрать все"
                            isChecked = item.isChecked
                            setOnClickListener {
                                checkAndUncheckAll((it as MaterialCheckBox).isChecked)
                            }
                        }
                    }
                }
            }
            1 -> {
                // Network
                with(holder as DepartmentsDropdownViewHolder) {
                    this.binding.apply {
                        lateinit var params: ViewGroup.MarginLayoutParams
                        if (item.isVisible == View.VISIBLE) {
                            params = RecyclerView.LayoutParams(
                                ViewGroup.LayoutParams.MATCH_PARENT,
                                ViewGroup.LayoutParams.WRAP_CONTENT
                            )
                            params.setMarginsInDp(context, 32f, 0f, 0f, 16f)
                        } else {
                            params = RecyclerView.LayoutParams(0, 0)
                            params.setMargins(0, 0, 0, 0)
                        }
                        graphDialogItemConstraintLayout.apply {
                            layoutParams = params
                            graphDialogItemConstraintLayout.visibility = item.isVisible
                        }

                        graphDialogItemNameTextView.apply {
                            text = if (item.network == NetType.Moscow) {
                                "Московские кабельные сети"
                            } else {
                                "Восточные электрические сети"
                            }
                            setOnClickListener {
                                dropdownAreaStateChanged(
                                    graphDialogItemDropdownImageView,
                                    item.network!!
                                )
                            }
                        }

                        graphDialogItemDropdownImageView.setOnClickListener {
                            dropdownAreaStateChanged(it, item.network!!)
                        }

                        graphDialogItemMaterialCheckbox.apply {
                            isChecked = item.isChecked
                            setOnClickListener {
                                checkAndUncheckAreas(
                                    item.network,
                                    (it as MaterialCheckBox).isChecked
                                )
                                isAllSelected()
                            }
                        }
                    }
                }
            }
            else -> {
                // Area
                with(holder as DepartmentsViewHolder) {
                    this.binding.apply {
                        lateinit var params: ViewGroup.MarginLayoutParams
                        if (item.isVisible == View.VISIBLE) {
                            params = RecyclerView.LayoutParams(
                                ViewGroup.LayoutParams.MATCH_PARENT,
                                ViewGroup.LayoutParams.WRAP_CONTENT
                            )
                            params.setMarginsInDp(context, 64f, 0f, 0f, 16f)
                        } else {
                            params = RecyclerView.LayoutParams(0, 0)
                            params.setMargins(0, 0, 0, 0)
                        }
                        graphDialogSubgroupCheckbox.apply {
                            layoutParams = params
                            visibility = item.isVisible
                            isChecked = item.isChecked
                            text = item.area
                            isClickable = true
                            setOnClickListener {
                                isAllSelected()
                            }
                        }
                    }
                }
            }
        }
    }

    override fun getItemCount() = elements.size

    override fun getItemViewType(position: Int): Int {
        return elements[position].rowType.ordinal
    }

    private fun isAllSelected() {
        val moscowAreas = elements.filter { it.rowType == DepartmentsRowType.AreaHeader && it.network == NetType.Moscow }.size
        Log.d("areas", "Moscow all $moscowAreas")
        val checkedMoscowAreas = elements.filter { it.rowType == DepartmentsRowType.AreaHeader && it.network == NetType.Moscow && it.isChecked }.size
        Log.d("areas", "Moscow checked $checkedMoscowAreas")

        val eastAreas = elements.filter { it.rowType == DepartmentsRowType.AreaHeader && it.network == NetType.East }.size
        Log.d("areas", "East all $eastAreas")
        val checkedEastAreas = elements.filter { it.rowType == DepartmentsRowType.AreaHeader && it.network == NetType.East && it.isChecked }.size
        Log.d("areas", "East checked $moscowAreas")

        if (moscowAreas == checkedMoscowAreas) {
            elements.filter { it.rowType == DepartmentsRowType.NetworkHeader && it.network == NetType.Moscow }.forEach {
                it.isChecked = true
                notifyItemChanged(elements.indexOf(it))
            }
        } else {
            elements.filter { it.rowType == DepartmentsRowType.NetworkHeader && it.network == NetType.Moscow }.forEach {
                it.isChecked = false
                notifyItemChanged(elements.indexOf(it))
            }
        }

        if (eastAreas == checkedEastAreas) {
            elements.filter { it.rowType == DepartmentsRowType.NetworkHeader && it.network == NetType.East }.forEach {
                it.isChecked = true
                notifyItemChanged(elements.indexOf(it))
            }
        } else {
            elements.filter { it.rowType == DepartmentsRowType.NetworkHeader && it.network == NetType.East }.forEach {
                it.isChecked = false
                notifyItemChanged(elements.indexOf(it))
            }
        }

        if (elements.filter { it.rowType == DepartmentsRowType.NetworkHeader }.all { it.isChecked }) {
            elements.filter { it.rowType == DepartmentsRowType.TopHeader }.forEach {
                it.isChecked = true
                notifyItemChanged(elements.indexOf(it))
            }
        } else {
            elements.filter { it.rowType == DepartmentsRowType.TopHeader }.forEach {
                it.isChecked = false
                notifyItemChanged(elements.indexOf(it))
            }
        }
        notifyDataSetChanged()
    }

    private fun dropdownAreaStateChanged(view: View, netType: NetType) {
        if (view.tag == "Closed") {
            view.tag = "Opened"
            (view as ImageView).setImageResource(R.drawable.dropdown_opened)
            showAreas(netType)
        } else {
            view.tag = "Closed"
            (view as ImageView).setImageResource(R.drawable.dropdown_closed)
            hideAreas(netType)
        }
    }

    private fun checkAndUncheckAreas(netType: NetType?, isChecked: Boolean) {
        val areas = mutableListOf<Int>()
        if (netType != null) {
            elements.filter { it.rowType == DepartmentsRowType.AreaHeader && it.network == netType }
                .forEach {
                    it.isChecked = isChecked
                    areas.add(elements.indexOf(it))
                }
        } else {
            elements.filter { it.rowType == DepartmentsRowType.AreaHeader }.forEach {
                it.isChecked = isChecked
                areas.add(elements.indexOf(it))
            }
        }
        areas.forEach {
            notifyItemChanged(it)
        }
        notifyDataSetChanged()
    }

    private fun checkAndUncheckAll(isChecked: Boolean) {
        elements.forEach {
            it.isChecked = isChecked
            notifyItemChanged(elements.indexOf(it))
        }
        notifyDataSetChanged()
    }

    private fun hideAreas(netType: NetType) {
        val areas = mutableListOf<Int>()
        elements.filter { it.rowType == DepartmentsRowType.AreaHeader && it.network == netType }
            .forEach {
                it.isVisible = View.GONE
                areas.add(elements.indexOf(it))
            }
        areas.forEach {
            notifyItemChanged(it)
        }
        notifyDataSetChanged()
    }

    private fun showAreas(netType: NetType) {
        val areas = mutableListOf<Int>()
        elements.filter { it.rowType == DepartmentsRowType.AreaHeader && it.network == netType }
            .forEach {
                it.isVisible = View.VISIBLE
                areas.add(elements.indexOf(it))
            }
        areas.forEach {
            notifyItemChanged(it)
        }
        notifyDataSetChanged()
    }
}