Untitled

package com.eruit.fragment

import android.app.DatePickerDialog
import android.content.Context
import android.os.Bundle
import android.os.Handler
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.view.inputmethod.EditorInfo
import androidx.core.view.OnApplyWindowInsetsListener
import androidx.core.view.ViewCompat
import androidx.core.view.WindowCompat
import androidx.core.view.WindowInsetsCompat
import androidx.core.widget.doAfterTextChanged
import androidx.core.widget.doOnTextChanged
import androidx.fragment.app.Fragment
import androidx.fragment.app.viewModels
import androidx.lifecycle.ViewModelProvider
import androidx.navigation.fragment.findNavController
import com.eruit.R
import com.eruit.adapter.ViewPagerAdapter
import com.eruit.api.common.CommonRequest
import com.eruit.api.request.OrderSummaryRequest
import com.eruit.api.utils.Resource
import com.eruit.databinding.FragmentOrderSummaryBinding
import com.eruit.fragment.OrderListFragment.Companion.isComfromFilter
import com.eruit.model.OrderSummaryData
import com.eruit.utils.Constant
import com.eruit.utils.PreferenceUtils
import com.eruit.utils.Utils
import com.eruit.utils.eventcalendar.utils.AppUtils
import com.eruit.viewmodel.OrderBookingViewModel
import com.eruit.viewmodel.OrderSummaryViewModel
import com.eruit.viewmodel.OrderViewModel
import dagger.hilt.android.AndroidEntryPoint
import org.json.JSONArray
import org.json.JSONObject
import timber.log.Timber
import java.text.DecimalFormat
import java.text.NumberFormat
import java.util.Calendar

@AndroidEntryPoint
class OrderSummaryFragment : Fragment(), View.OnFocusChangeListener {
    private lateinit var binding: FragmentOrderSummaryBinding
    private lateinit var mContext: Context
    private lateinit var adapter: ViewPagerAdapter
    private val firstFragment = Summary1Fragment()
    private val secondFragment = Summary2Fragment()
    private val thirdFragment = Summary3Fragment()
    private var orderBookingViewModel: OrderBookingViewModel? = null
    private val viewModel: OrderViewModel by viewModels()
    private var orderSummary: OrderSummaryViewModel? = null
    private var picker: DatePickerDialog? = null
    var isComeFromEvents = false

    var onef: NumberFormat = DecimalFormat("0")
    var twof: NumberFormat = DecimalFormat("0.0")
    var lastChange = ""
    var isCallSaveSummary = false

    companion object {
        var orderId: String? = null
        var mEdit = false
        var orderSummaryObj: JSONObject = JSONObject()
    }

    override fun onCreateView(
        inflater: LayoutInflater, container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View {
        binding = FragmentOrderSummaryBinding.inflate(inflater, container, false)
        mContext = requireContext()
        orderSummary = ViewModelProvider(requireActivity())[OrderSummaryViewModel::class.java]
        orderBookingViewModel =
            ViewModelProvider(requireActivity())[OrderBookingViewModel::class.java]
        orderId = arguments?.getString(Constant.SHARED.OrderId).toString()
        isComeFromEvents = arguments?.getBoolean(Constant.SHARED.IsFromEvents, false)!!
        if (orderId.toString().isNotEmpty()) {
            orderSummary?.data?.value?.order = orderId?.toInt()
            viewModel.startOrderSummary(OrderSummaryRequest(orderId?.toInt()))
        }
        binding.imgBack.setOnClickListener {
            findNavController().navigateUp()
        }
        binding.btnApply.setOnClickListener {
            println("LAST CHANGE$lastChange")
            if (lastChange.isEmpty()) {
                saveSummaryApi()
            } else {
                isCallSaveSummary = true
                calOrderSummaryApi(lastChange)
            }
        }
        binding.btnClear.setOnClickListener {
            findNavController().navigateUp()
        }
        binding.editNumPortion.doAfterTextChanged {
            if (binding.editNumPortion.text?.isNotEmpty() == true) {
                Summary1Fragment.mEdit = true
                lastChange = Constant.SHARED.NUM_PORTIONS
            }
        }

        binding.editPossiblePortions.doAfterTextChanged {
            if (binding.editPossiblePortions.text?.isNotEmpty() == true) {
                Summary1Fragment.mEdit = true
                lastChange = Constant.SHARED.POSSIBLE_PORTIONS
            }
        }

        binding.editAddition1.doAfterTextChanged {
            if (binding.editAddition1.text?.isNotEmpty() == true) {
                Summary1Fragment.mEdit = true
                lastChange = Constant.SHARED.ADDITION_1
            }
        }

        binding.editCost1.doAfterTextChanged {
            if (binding.editCost1.text?.isNotEmpty() == true) {
                Summary1Fragment.mEdit = true
                lastChange = Constant.SHARED.COST_1
            }
        }
        binding.editAddition1.setOnEditorActionListener { _, actionId, _ ->
            if (actionId == EditorInfo.IME_ACTION_DONE) {
                if (binding.editAddition1.text?.isNotEmpty() == true) {
                    orderSummary?.data?.value?.addition_1 =
                        binding.editAddition1.text.toString().toDouble()
                    calOrderSummaryApi(lastChange)
                }
            }
            false
        }


        binding.editMinPortions.doAfterTextChanged {
            if (binding.editMinPortions.text?.isNotEmpty() == true) {
                Summary1Fragment.mEdit = true
                lastChange = Constant.SHARED.MIN_PORTIONS
            }
        }

        binding.editPractical.doAfterTextChanged {
            if (binding.editPractical.text?.isNotEmpty() == true) {
                Summary1Fragment.mEdit = true
                lastChange = Constant.SHARED.PRACTICAL
            }
        }

        binding.editDiscount2.doAfterTextChanged {
            if (binding.editDiscount2.text?.isNotEmpty() == true) {
                Summary1Fragment.mEdit = true
                lastChange = Constant.SHARED.DISCOUNT_2
            }
        }

        binding.editNan.doAfterTextChanged {
            if (binding.editNan.text?.isNotEmpty() == true) {
                Summary1Fragment.mEdit = true
                lastChange = "discount_percent"
            }
        }

        binding.editNumPortion.onFocusChangeListener = this
        binding.editPossiblePortions.onFocusChangeListener = this
        binding.editAddition1.onFocusChangeListener = this
        binding.editCost1.onFocusChangeListener = this
        binding.editMinPortions.onFocusChangeListener = this
        binding.editPractical.onFocusChangeListener = this
        binding.editDiscount2.onFocusChangeListener = this
        binding.editNan.onFocusChangeListener = this
        binding.editText1.doOnTextChanged { text, _, _, _ ->
            orderSummary?.data?.value?.text_1 = text.toString()
        }
        binding.rdoInclude.isChecked = orderSummary?.data?.value?.Include_Vat == true



        binding.rdoInclude.setOnCheckedChangeListener { _, isChecked ->
            orderSummary?.data?.value?.Include_Vat = isChecked
            if (isChecked) {
                binding.rdoInclude.text = "המחירים כוללים מע”מ"
            } else {
                binding.rdoInclude.text = "המחירים אינם כוללים מע”מ"
            }
            calOrderSummaryApi(Constant.SHARED.IS_INCLUDE_VAT)
        }

        binding.editDateFinish.setOnClickListener {
            val cldr = Calendar.getInstance()
            val day = cldr[Calendar.DAY_OF_MONTH]
            val month = cldr[Calendar.MONTH]
            val year = cldr[Calendar.YEAR]
            picker = DatePickerDialog(
                mContext,
                { _, yearOf, monthOfYear, dayOfMonth ->
                    val mt = if (monthOfYear + 1 < 10) "0${monthOfYear + 1}" //if month less than 10 then ad 0 before month
                    else java.lang.String.valueOf(monthOfYear + 1)
                    val dy: String =
                        if (dayOfMonth < 10) "0$dayOfMonth" else java.lang.String.valueOf(dayOfMonth) //local variable
                    binding.editDateFinish.text = "$dy-$mt-$yearOf"
                    orderSummary?.data?.value?.date_finish = "$yearOf-$mt-$dy"
                    binding.lblDateFinish.visibility = View.VISIBLE
                    binding.lblDateFinish.setPadding(0, 5, 0, 0)
                    clearFocus()
                },
                year,
                month,
                day
            )
            picker?.show()
        }

        binding.editNan.textDirection = View.TEXT_DIRECTION_RTL
        setupObserver()
        return binding.root
    }

    private fun isKeyboardOpen() {
        val window = requireActivity().window
        WindowCompat.setDecorFitsSystemWindows(window, false)
        val callBack = OnApplyWindowInsetsListener { _, insets ->
            val isKeyboardVisible = insets.isVisible(WindowInsetsCompat.Type.ime())
            if (isKeyboardVisible) {
                binding.linBottomEnglish.visibility = View.INVISIBLE
            } else {
                binding.linBottomEnglish.visibility = View.VISIBLE
            }
            insets
        }

        ViewCompat.setOnApplyWindowInsetsListener(binding.root, callBack)
    }

    private fun setupObserver() {
        viewModel.orderSummary.observe(viewLifecycleOwner) {
            when (it.status) {
                Resource.Status.SUCCESS -> {
                    if (it.responseCode in 200..299) {
                        if (it.data?.RequestResponse == true) {
                            println("GET ORDER SUMMERY ${it.data}")
                            Timber.tag("Response").e(it.data.Data.toString())
                            val orders: OrderSummaryData? = it.data.Data
                            if (orders != null) {
                                binding.editAddCommon.setText(
                                    (onef.format(orders.add_common) ?: "").toString()
                                )
                                binding.editNumPortion.setText(
                                    (onef.format(orders.num_portions) ?: "").toString()
                                )
                                binding.editPossiblePortions.setText(
                                    (onef.format(orders.possible_portions) ?: 0).toString()
                                )
                                binding.editAddition1.setText(
                                    (onef.format(orders.addition_1) ?: 0).toString()
                                )
                                binding.editMan2.setText(orders.man_2 ?: "")
                                binding.editLastUser.setText(orders.last_user ?: "")
                                binding.editText1.setText(orders.text_1 ?: "")
                                if (orders.date_finish?.isNotEmpty() == true) {
                                    binding.lblDateFinish.visibility = View.VISIBLE
                                    binding.lblDateFinish.setPadding(0, 5, 0, 0)
                                    binding.editDateFinish.text = AppUtils().changeDateFormat(
                                        Constant.yyyy_MM_dd, Constant.dd_MM_yyyy, orders.date_finish
                                            .toString()
                                    )
                                } else {
                                    binding.lblDateFinish.visibility = View.INVISIBLE
                                    binding.editDateFinish.text = ""
                                }
                                binding.editCost1.setText(
                                    (onef.format(orders.cost_1) ?: "").toString()
                                )
                                binding.editMinPortions.setText(
                                    (onef.format(orders.min_portions) ?: "").toString()
                                )
                                binding.editPractical.setText(
                                    (onef.format(orders.practical) ?: "").toString()
                                )
                                binding.editDutyHist.setText(
                                    (onef.format(orders.duty_hist) ?: "").toString()
                                )
                                binding.editLastUpdate.setText(
                                    AppUtils().changeDateFormat(
                                        "yyyy-MM-dd",
                                        "dd-MM-yyyy",
                                        orders.last_update ?: "null"
                                    )
                                )
                                binding.editDiscount2.setText(
                                    (onef.parse(orders.discount_2.toString()) ?: "").toString()
                                )

                                binding.editNan.setText(
                                    (onef.parse(orders.discount_percent.toString()) ?: "0").toString()
                                )
                                binding.editTSum.setText(((orders.t_sum?.toString()?.let { it1 -> onef.parse(it1) }) ?: "").toString())
                                binding.editTMamSum.setText((orders.t_mam_sum?.toString()?.let { it1 -> onef.parse(it1) } ?: "").toString())
                                binding.editSumTotal.setText((orders.sum_total?.toString()?.let { it1 -> onef.parse(it1) } ?: "").toString())
                                binding.rdoInclude.isChecked = orders.Include_Vat ?: false
                                if (binding.rdoInclude.isChecked) {
                                    binding.rdoInclude.text = "המחירים כוללים מע”מ"
                                } else {
                                    binding.rdoInclude.text = "המחירים אינם כוללים מע”מ"
                                }

                                orderSummary?.selected(
                                    OrderSummaryData(
                                        orders.add_common,
                                        orders.num_portions,
                                        orders.possible_portions,
                                        orders.addition_1,
                                        orders.date_finish ?: "",
                                        orders.cost_1,
                                        orders.min_portions,
                                        orders.Include_Vat,
                                        orders.discount_2,
                                        orders.sum_total,
                                        orders.t_mam_sum,
                                        orders.t_sum,
                                        orders.total_before_discount,
                                        orders.man_2 ?: "",
                                        orders.last_user ?: "",
                                        orders.text_1 ?: "",
                                        orders.practical,
                                        orders.add_portion,
                                        orders.duty_hist,
                                        orders.discount_percent,
                                        orders.add_sum,
                                        orders.hist_dollar ?: "",
                                        orders.last_update ?: "",
                                        orderId?.toInt()
                                    )
                                )
                            }
                            binding.relLoading.visibility = View.GONE
                        } else {
                            println("GET ORDER SUMMERY ${it.data}")
                        }
                    }
                }

                Resource.Status.ERROR -> {
                    binding.relLoading.visibility = View.GONE
                    it?.errorResponse?.Messages?.get(0)?.let { it1 -> Utils.showCustomToast(mContext, it1) }
                }

                Resource.Status.LOADING -> {
                    binding.relLoading.visibility = View.VISIBLE
                }
            }
        }
        viewModel.saveSummary.observe(viewLifecycleOwner) {
            when (it.status) {
                Resource.Status.SUCCESS -> {
                    if (it.responseCode in 200..299) {
                        if (it.data?.RequestResponse == true) {
                            Timber.tag("Response").e(it.data.Data.toString())
                            val orders: OrderSummaryData? = it.data.Data
                            if (orders != null) {
                                orderSummary?.selected(
                                    OrderSummaryData(
                                        orders.add_common,
                                        orders.num_portions,
                                        orders.possible_portions,
                                        orders.addition_1,
                                        orders.date_finish,
                                        orders.cost_1,
                                        orders.min_portions,
                                        orders.Include_Vat,
                                        orders.discount_2,
                                        orders.sum_total,
                                        orders.t_mam_sum,
                                        orders.t_sum,
                                        orders.total_before_discount,
                                        orders.man_2,
                                        orders.last_user,
                                        orders.text_1,
                                        orders.practical,
                                        orders.add_portion,
                                        orders.duty_hist,
                                        orders.discount_percent,
                                        orders.add_sum,
                                        orders.hist_dollar,
                                        orders.last_update,
                                        orderId?.toInt()
                                    )
                                )
                            }
                            binding.relLoading.visibility = View.GONE
                            isComfromFilter = false
                            findNavController().navigateUp()
                        }
                    }
                }

                Resource.Status.ERROR -> {
                    binding.relLoading.visibility = View.GONE
                    it?.errorResponse?.Messages?.get(0)?.let { it1 -> Utils.showCustomToast(mContext, it1) }
                }

                Resource.Status.LOADING -> {
                    binding.relLoading.visibility = View.VISIBLE
                }
            }
        }
        viewModel.orderCalSummary.observe(viewLifecycleOwner) {
            when (it.status) {
                Resource.Status.SUCCESS -> {
                    if (it.responseCode in 200..299) {
                        if (it.data?.RequestResponse == true) {
                            binding.relLoading.visibility = View.GONE
                            Timber.tag("Response").e(it.data.Data.toString())
                            val orders: OrderSummaryData? = it.data.Data
                            if (orders != null) {
                                binding.editAddCommon.setText(
                                    (onef.format(orders.add_common) ?: "").toString()
                                )
                                binding.editNumPortion.setText(
                                    (onef.format(orders.num_portions) ?: "").toString()
                                )
                                binding.editPossiblePortions.setText(
                                    (onef.format(orders.possible_portions) ?: "").toString()
                                )
                                binding.editAddition1.setText(
                                    (onef.format(orders.addition_1) ?: "").toString()
                                )
                                binding.editCost1.setText(
                                    (onef.format(orders.cost_1) ?: "").toString()
                                )
                                binding.editMinPortions.setText(
                                    (onef.format(orders.min_portions) ?: "").toString()
                                )
                                binding.editPractical.setText(
                                    (onef.format(orders.practical) ?: "").toString()
                                )
                                binding.editDutyHist.setText(
                                    (onef.format(orders.duty_hist) ?: "").toString()
                                )
                                binding.editDiscount2.setText(
                                    ((onef.format(orders.discount_2)) ?: "").toString()
                                )
                                binding.editTSum.setText(
                                    (onef.format(orders.t_sum) ?: "").toString()
                                )
                                binding.editTMamSum.setText(
                                    (onef.format(orders.t_mam_sum) ?: "").toString()
                                )
                                binding.editSumTotal.setText(
                                    (onef.format(orders.sum_total) ?: "").toString()
                                )
                                if (orders.discount_percent == null) {
                                    binding.editNan.setText("0")
                                } else {
                                    binding.editNan.setText(
                                        (onef.format(orders.discount_percent) ?: "").toString()
                                    )
                                }
                                binding.rdoInclude.isChecked = orders.Include_Vat ?: false
                                orderSummary?.selected(
                                    OrderSummaryData(
                                        orders.add_common,
                                        orders.num_portions,
                                        orders.possible_portions,
                                        orders.addition_1,
                                        orderSummary?.data?.value?.date_finish ?: "",
                                        orders.cost_1,
                                        orders.min_portions,
                                        orders.Include_Vat,
                                        orders.discount_2,
                                        orders.sum_total,
                                        orders.t_mam_sum,
                                        orders.t_sum,
                                        orders.total_before_discount,
                                        orderSummary?.data?.value?.man_2,
                                        orderSummary?.data?.value?.last_user,
                                        orderSummary?.data?.value?.text_1,
                                        orders.practical,
                                        orders.add_portion,
                                        orders.duty_hist,
                                        orders.discount_percent,
                                        orders.add_sum,
                                        orders.hist_dollar,
                                        orders.last_update,
                                        orderId?.toInt()
                                    )
                                )
                                if (isCallSaveSummary) {
                                    binding.relLoading.visibility = View.VISIBLE
                                    Handler().postDelayed({
                                        saveSummaryApi()
                                    }, 2000)
                                }

                            }
                        }
                    }
                }

                Resource.Status.ERROR -> {
                    it?.errorResponse?.Messages?.get(0)?.let { it1 -> Utils.showCustomToast(mContext, it1) }
                    binding.relLoading.visibility = View.GONE
                }

                Resource.Status.LOADING -> {
                    binding.relLoading.visibility = View.VISIBLE
                }
            }
        }
    }

    fun clearFocus() {
        binding.editNumPortion.clearFocus()
        binding.editPossiblePortions.clearFocus()
        binding.editAddition1.clearFocus()
        binding.editText1.clearFocus()
        binding.editCost1.clearFocus()
        binding.editMinPortions.clearFocus()
        binding.editMinPortions.clearFocus()
        binding.editNan.clearFocus()
        binding.editDiscount2.clearFocus()
    }

    private fun calOrderSummaryApi(change: String?) {
        val json = JSONObject()
        json.put(Constant.SHARED.ORDER, orderId?.toInt() ?: 0)
        json.put(Constant.SHARED.ADD_COMMON, orderSummary?.data?.value?.add_common ?: 0)
        if (binding.editNumPortion.text?.isNotEmpty() == true) {
            json.put(Constant.SHARED.NUM_PORTIONS, binding.editNumPortion.text.toString().toDouble())
        } else {
            json.put(Constant.SHARED.NUM_PORTIONS, 0)
        }
        if (binding.editPossiblePortions.text?.isNotEmpty() == true) {
            json.put(Constant.SHARED.POSSIBLE_PORTIONS, binding.editPossiblePortions.text.toString().toDouble())
        } else {
            json.put(Constant.SHARED.POSSIBLE_PORTIONS, 0)
        }
        if (binding.editAddition1.text?.isNotEmpty() == true) {
            json.put(Constant.SHARED.ADDITION_1, binding.editAddition1.text.toString().toDouble())
        } else {
            json.put(Constant.SHARED.ADDITION_1, 0)
        }
        if (binding.editCost1.text?.isNotEmpty() == true) {
            json.put(Constant.SHARED.COST_1, binding.editCost1.text.toString().toDouble())
        } else {
            json.put(Constant.SHARED.COST_1, 0)
        }
        if (binding.editMinPortions.text?.isNotEmpty() == true) {
            json.put(Constant.SHARED.MIN_PORTIONS, binding.editMinPortions.text.toString().toDouble())
        } else {
            json.put(Constant.SHARED.MIN_PORTIONS, 0)
        }
        if (binding.editPractical.text?.isNotEmpty() == true) {
            json.put(Constant.SHARED.PRACTICAL, binding.editPractical.text.toString().toDouble())
        } else {
            json.put(Constant.SHARED.PRACTICAL, 0)
        }
        json.put(Constant.SHARED.DUTY_HIST, binding.editDutyHist.text.toString().toDouble())
        json.put(Constant.SHARED.IS_INCLUDE_VAT, orderSummary?.data?.value?.Include_Vat ?: false)
        json.put(Constant.SHARED.DISCOUNT_2, binding.editDiscount2.text ?: 0)
        json.put(Constant.SHARED.ADD_PORTION, orderSummary?.data?.value?.add_portion ?: 0)
        json.put(Constant.SHARED.HIST_DOLLAR, orderSummary?.data?.value?.hist_dollar ?: 0)
        json.put(Constant.SHARED.DISCOUNT_PERCENT, binding.editNan.text.toString())
        json.put(Constant.SHARED.ADD_SUM, orderSummary?.data?.value?.add_sum ?: 0)
        json.put(Constant.SHARED.CHANGE_COLUMN, change)
        orderSummaryObj = json

        viewModel.startOrderCalSummary(CommonRequest(json))
    }

    private fun saveSummaryApi() {
        val createOrderObject = orderBookingViewModel?.createOrder?.value
        val json = JSONObject()
        json.put(Constant.SHARED.ORDER, orderId?.toInt() ?: 0)
        json.put(Constant.SHARED.ADD_COMMON, orderSummary?.data?.value?.add_common ?: 0)
        json.put(Constant.SHARED.NUM_PORTIONS, orderSummary?.data?.value?.num_portions ?: 0)
        json.put(
            Constant.SHARED.POSSIBLE_PORTIONS,
            orderSummary?.data?.value?.possible_portions ?: 0
        )
        json.put(Constant.SHARED.ADDITION_1, orderSummary?.data?.value?.addition_1 ?: 0)
        json.put(Constant.SHARED.COST_1, orderSummary?.data?.value?.cost_1 ?: 0)
        json.put(Constant.SHARED.MIN_PORTIONS, orderSummary?.data?.value?.min_portions ?: 0)
        json.put(Constant.SHARED.PRACTICAL, orderSummary?.data?.value?.practical ?: 0)
        json.put(Constant.SHARED.DUTY_HIST, orderSummary?.data?.value?.duty_hist ?: 0)
        json.put(Constant.SHARED.IS_INCLUDE_VAT, orderSummary?.data?.value?.Include_Vat ?: false)
        json.put(Constant.SHARED.DISCOUNT_2, orderSummary?.data?.value?.discount_2 ?: 0)
        json.put(Constant.SHARED.ADD_PORTION, orderSummary?.data?.value?.add_portion ?: 0)
        json.put(Constant.SHARED.HIST_DOLLAR, orderSummary?.data?.value?.hist_dollar ?: 0)
        json.put(Constant.SHARED.DISCOUNT_PERCENT, orderSummary?.data?.value?.discount_percent ?: 0)
        json.put(Constant.SHARED.DATE_FINISH, orderSummary?.data?.value?.date_finish ?: "")
        json.put(Constant.SHARED.ADD_SUM, orderSummary?.data?.value?.add_sum ?: 0)
        json.put(Constant.SHARED.TEXT_1, orderSummary?.data?.value?.text_1 ?: 0)
        json.put(Constant.SHARED.SUM_TOTAL, orderSummary?.data?.value?.sum_total ?: 0.0)

        val eventJsonArray = JSONArray()
        val eventItemJsonArray = JSONArray()
        if (PreferenceUtils.getEdit(mContext, Constant.SHARED.IsFromEditOrder, false)) {
            val eventData = orderBookingViewModel?.createOrder?.value?.events?.last()
            if ((eventData?.EventItems?.isNotEmpty() == true) && (eventData.EventItems != null)) {
                eventData.EventItems?.forEach { _ ->
                    val jsonEvent = JSONObject()
                    if (PreferenceUtils.getEdit(
                            requireContext(),
                            Constant.SHARED.IsFromEditOrder
                        )
                    ) {
                        jsonEvent.put(Constant.SHARED.T_EVENTID, eventData.t_eventId ?: "")
                    } else {
                        jsonEvent.put(Constant.SHARED.T_EVENTID, "")
                    }
                    jsonEvent.put(Constant.SHARED.DAY_EVENT, eventData.day_event ?: "")
                    jsonEvent.put(Constant.SHARED.SERVER, eventData.server)
                    jsonEvent.put(
                        Constant.SHARED.DATE_EVENT,
                        AppUtils().changeDateFormat(
                            "dd-MM-yyyy",
                            "yyyy-MM-dd",
                            eventData.date_event.toString()
                        )
                    )
                    jsonEvent.put(
                        Constant.SHARED.FROM_DATE,
                        AppUtils().updateEventSendingDate(eventData.from_date.toString())
                    )
                    jsonEvent.put(Constant.SHARED.HALL, eventData.hall)
                    jsonEvent.put(
                        Constant.SHARED.FROM_TIME,
                        (eventData.from_date.toString())
                    )
                    jsonEvent.put(
                        Constant.SHARED.TO_DATE,
                        AppUtils().updateEventSendingDate(eventData.to_date.toString())
                    )
                    jsonEvent.put(Constant.SHARED.EVENT_LINE, 0)
                    jsonEvent.put(
                        Constant.SHARED.TO_TIME,
                        (eventData.to_date.toString())
                    )
                    jsonEvent.put(Constant.SHARED.MENU, eventData.menu)
                    jsonEvent.put(
                        Constant.SHARED.EVENT_FLAG,
                        PreferenceUtils.getEdit(requireContext(), Constant.SHARED.IsFromEditOrder)
                    )
                    jsonEvent.put(Constant.SHARED.EVENTITEMS, eventItemJsonArray)
                    eventJsonArray.put(jsonEvent)
                }
            } else {
                val jsonEvent = JSONObject()
                jsonEvent.put(Constant.SHARED.T_EVENTID, "")
                jsonEvent.put(Constant.SHARED.DAY_EVENT, eventData?.day_event.toString())
                jsonEvent.put(Constant.SHARED.SERVER, eventData?.server ?: "")
                jsonEvent.put(
                    Constant.SHARED.DATE_EVENT,
                    AppUtils().updateEventSendingDate(eventData?.from_date.toString())
                )
                jsonEvent.put(Constant.SHARED.HALL, eventData?.hall ?: "")
                jsonEvent.put(Constant.SHARED.EVENT_LINE, 0)
                jsonEvent.put(
                    Constant.SHARED.FROM_DATE,
                    AppUtils().updateEventSendingDate(eventData?.from_date.toString())
                )
                jsonEvent.put(
                    Constant.SHARED.TO_DATE,
                    AppUtils().updateEventSendingDate(eventData?.to_date.toString())
                )
                jsonEvent.put(
                    Constant.SHARED.FROM_TIME,
                    (eventData?.from_date.toString())
                )
                jsonEvent.put(Constant.SHARED.TO_TIME, (eventData?.to_time.toString()))
                jsonEvent.put(Constant.SHARED.MENU, eventData?.menu ?: "")
                jsonEvent.put(
                    Constant.SHARED.EVENT_FLAG,
                    PreferenceUtils.getEdit(requireContext(), Constant.SHARED.IsFromEditOrder)
                )
                jsonEvent.put(Constant.SHARED.EVENTITEMS, eventItemJsonArray)
                eventJsonArray.put(jsonEvent)
            }
        }
        val jsonOrderMobObject = JSONObject()
        val jsonBooking = JSONObject()
        jsonBooking.put(
            Constant.SHARED.BOOKING_NUMBER,
            createOrderObject?.booking?.BookingNumber ?: ""
        )
        jsonBooking.put(Constant.SHARED.BOOKING_ID, createOrderObject?.booking?.BookingId ?: "")
        jsonBooking.put(Constant.SHARED.TERMS, createOrderObject?.booking?.terms ?: "")
        jsonBooking.put(Constant.SHARED.NAME, createOrderObject?.booking?.name ?: "")
        jsonBooking.put(Constant.SHARED.ADDRESS_1, createOrderObject?.booking?.address_1 ?: "")
        jsonBooking.put(Constant.SHARED.TELEFON_1, createOrderObject?.booking?.telefon_1 ?: "")
        jsonBooking.put(
            Constant.SHARED.EMAIL_ADDRESS,
            createOrderObject?.booking?.email_adress ?: ""
        )
        jsonBooking.put(Constant.SHARED.NUM, createOrderObject?.booking?.num ?: "")

        jsonOrderMobObject.put(Constant.SHARED.orderId, createOrderObject?.orderId ?: "")
        jsonOrderMobObject.put(Constant.SHARED.ORDER, createOrderObject?.order ?: "")
        jsonOrderMobObject.put(Constant.SHARED.EVENT, createOrderObject?.event ?: "")
        jsonOrderMobObject.put(Constant.SHARED.STATUS, createOrderObject?.status ?: "")
        jsonOrderMobObject.put(Constant.SHARED.AGENT, createOrderObject?.agent ?: "")
        jsonOrderMobObject.put(
            Constant.SHARED.Event_LOCATION,
            createOrderObject?.eventLocation ?: ""
        )
        jsonOrderMobObject.put(Constant.SHARED.IS_INCLUDE_VAT, false)
        jsonOrderMobObject.put(Constant.SHARED.DUTY_HIST, 0)
        jsonOrderMobObject.put(Constant.SHARED.BOOKING, jsonBooking)
        json.putOpt(Constant.SHARED.MOBORDER, jsonOrderMobObject)
        json.putOpt(Constant.SHARED.EVENTS, eventJsonArray)
        viewModel.startSaveSummary(CommonRequest(json))
        isComfromFilter = false
        viewModel.saveSummary.observe(viewLifecycleOwner) {
            when (it.status) {
                Resource.Status.SUCCESS -> {
                    Utils.showToast(mContext, it.data?.Messages?.get(0) ?: "")
                    if (isComeFromEvents) {
                        orderBookingViewModel?.createOrder?.value = null
                    }
                }

                Resource.Status.ERROR -> it?.errorResponse?.Messages?.get(0)?.let { it1 -> Utils.showCustomToast(mContext, it1) }

                Resource.Status.LOADING -> binding.relLoading.visibility = View.VISIBLE
            }
        }
    }

    override fun onFocusChange(v: View?, hasFocus: Boolean) {
        when (v!!.id) {
            R.id.editNan -> {
                if (hasFocus && Summary1Fragment.mEdit) {
                    if (binding.editNan.text?.isNotEmpty() == true) {
                        orderSummary?.data?.value?.discount_percent =
                            binding.editNan.text.toString().toDouble()
                    }
                    if (binding.editNan.text?.isNotEmpty() == true) {
                        binding.editNan.text?.length?.let { binding.editNan.setSelection(it) }
                    }
                    calOrderSummaryApi(lastChange)
                }
            }

            R.id.editDiscount2 -> {
                if (hasFocus && Summary1Fragment.mEdit) {
                    if (binding.editDiscount2.text?.isNotEmpty() == true) {
                        orderSummary?.data?.value?.discount_2 =
                            binding.editDiscount2.text.toString().toDouble()
                        calOrderSummaryApi(lastChange)
                    }
                }
            }

            R.id.editPractical -> {
                if (hasFocus && Summary1Fragment.mEdit) {
                    if (binding.editPractical.text?.isNotEmpty() == true) {
                        orderSummary?.data?.value?.practical =
                            binding.editPractical.text.toString().toDouble()
                        calOrderSummaryApi(lastChange)
                    }
                }
            }

            R.id.editMinPortions -> {
                if (hasFocus && Summary1Fragment.mEdit) {
                    if (binding.editMinPortions.text?.isNotEmpty() == true) {
                        orderSummary?.data?.value?.min_portions =
                            binding.editMinPortions.text.toString().toDouble()
                        calOrderSummaryApi(lastChange)
                    }
                }
            }

            R.id.editCost1 -> {
                if (hasFocus && Summary1Fragment.mEdit) {
                    Summary1Fragment.mEdit = false
                    if (binding.editCost1.text?.isNotEmpty() == true) {
                        orderSummary?.data?.value?.cost_1 =
                            binding.editCost1.text.toString().toDouble()
                        calOrderSummaryApi(lastChange)
                    }
                }
            }

            R.id.editAddition1 -> {
                if (hasFocus && Summary1Fragment.mEdit) {
                    Summary1Fragment.mEdit = false
                    if (binding.editAddition1.text?.isNotEmpty() == true) {
                        orderSummary?.data?.value?.addition_1 =
                            binding.editAddition1.text.toString().toDouble()
                        calOrderSummaryApi(lastChange)
                    }
                }
            }

            R.id.editPossiblePortions -> {
                if (hasFocus && Summary1Fragment.mEdit) {
                    Summary1Fragment.mEdit = false
                    if (binding.editPossiblePortions.text?.isNotEmpty() == true) {
                        orderSummary?.data?.value?.possible_portions =
                            binding.editPossiblePortions.text.toString().toDouble()
                        calOrderSummaryApi(lastChange)
                    }
                }
            }

            R.id.editNumPortion -> {
                if (hasFocus && Summary1Fragment.mEdit) {
                    Summary1Fragment.mEdit = false
                    if (binding.editNumPortion.text?.isNotEmpty() == true) {
                        orderSummary?.data?.value?.num_portions =
                            binding.editNumPortion.text.toString().toDouble()
                        calOrderSummaryApi(lastChange)
                    }
                }
            }
        }
    }
}