package com.focasoftware.deboinventariov20.UI.inventario

import android.annotation.SuppressLint
import android.app.AlertDialog
import android.content.Context
import android.content.Context.INPUT_METHOD_SERVICE
import android.content.DialogInterface
import android.content.SharedPreferences
import android.graphics.Canvas
import android.graphics.Color
import android.graphics.drawable.Drawable
import android.os.Bundle
import android.text.Editable
import android.text.InputType.TYPE_CLASS_NUMBER
import android.text.TextWatcher
import android.view.*
import android.view.inputmethod.InputMethodManager
import android.widget.EditText
import android.widget.TextView
import android.widget.Toast
import androidx.core.content.ContextCompat
import androidx.core.os.bundleOf
import androidx.fragment.app.Fragment
import androidx.lifecycle.ViewModel
import androidx.lifecycle.ViewModelProviders
import androidx.lifecycle.lifecycleScope
import androidx.navigation.NavController
import androidx.navigation.Navigation
import androidx.recyclerview.widget.ItemTouchHelper
import androidx.recyclerview.widget.LinearLayoutManager
import androidx.recyclerview.widget.RecyclerView
import com.focasoftware.deboinventariov20.DB.DataBase.AppDb
import com.focasoftware.deboinventariov20.Model.*
import com.focasoftware.deboinventariov20.R
import com.focasoftware.deboinventariov20.UI.Utils.NoEncontradoSimple
import com.focasoftware.deboinventariov20.UI.Utils.ObtenerFechaActual
import com.focasoftware.deboinventariov20.UI.Utils.modificarCantidadEnCabecera
import com.focasoftware.deboinventariov20.UI.inventario.viewModel.InventarioViewModel
import kotlinx.android.synthetic.main.fragment_inventario.*
import kotlinx.android.synthetic.main.ingresar_cantidad.view.*
import kotlinx.android.synthetic.main.login_dialog.view.*
import kotlinx.android.synthetic.main.login_dialog.view.btnAceptar
import kotlinx.coroutines.*
import kotlinx.coroutines.Dispatchers.IO
import retrofit2.Call
import retrofit2.Callback
import retrofit2.Response
import java.util.*

class InventarioFragment : Fragment(), ProductosListAdapter.OnImageDotsClickListener {

    private lateinit var sharedPreferences: SharedPreferences
    private var iArea: Boolean = false
    private lateinit var invHead: InvHead
    private lateinit var rcInventarios: RecyclerView
    private lateinit var viewAdapter: RecyclerView.Adapter<*>
    private lateinit var viewManager: RecyclerView.LayoutManager
    private lateinit var sChangeUpper: String
    private var listArticulos = ArrayList<ItemsRecycler>()
    private lateinit var navController: NavController
    var InventarioNuevo: Int = 0
    private var iEstado = 0
    private var iBusquedaPor = 0
    private var fCant = 0F
    private var bFirst = false
    private lateinit var deleteIcon: Drawable
    lateinit var mDialogView: View
    lateinit var inventarioViewModel: ViewModel

    @SuppressLint("MissingPermission")
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        inventarioViewModel= ViewModelProviders.of(this).get(InventarioViewModel::class.java)
        
        sharedPreferences = requireActivity().getSharedPreferences("SP_INFO", Context.MODE_PRIVATE)
        if (sharedPreferences.contains("Inventario")) if (sharedPreferences.getString("Inventario", "").toString() != "-1") {
            (inventarioViewModel as InventarioViewModel).InventarioNuevo = sharedPreferences.getString("Inventario", "").toString().toInt()
            val editor = sharedPreferences.edit()
            editor?.putString("Inventario", "-1")
            editor?.apply()
            editor.commit()
        }
//        val c = Calendar.getInstance()
//        c[2009, 9, 9, 12, 0] = 0
//        val am: AlarmManager = requireActivity().getSystemService(Context.ALARM_SERVICE) as AlarmManager
//        am.setTime(c.timeInMillis)
    }
//    private fun setupTimeZone(timeZoneName: String) {
//        val am = requireContext().getSystemService(Context.ALARM_SERVICE) as AlarmManager
//        am.setTimeZone("Europe/Madrid")
//    }


    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
        val v = inflater.inflate(R.layout.fragment_inventario, container, false)
        sharedPreferences = requireActivity().getSharedPreferences("SP_INFO", Context.MODE_PRIVATE)
        val tCodigoBarras = v.findViewById<EditText>(R.id.etCodigoBarras)
        rcInventarios = v.findViewById(R.id.rcInventarios)
        val tvTitulo = v.findViewById<TextView>(R.id.tvTitulo)
        val descArea: String = if (!SerchArea()) "Ventas" else "Deposito"

        if ((inventarioViewModel as InventarioViewModel).InventarioNuevo == 0) {// TODO: SI INVETNARIO NUEVO
            GlobalScope.launch(Dispatchers.Main) {
                //TODO: BUSCO EL ULTIMO INVENTARIO EN LA BD PARA PODER CREAR EL PROXIMO
                (inventarioViewModel as InventarioViewModel).InventarioNuevo = AppDb.getAppDb(requireActivity())?.InvHeadDAO()?.findLastInv()?.plus(1) ?: 1
                //TODO: CREAMOS EL INVENTARIO EN LA CABECERA DEL INVENTARIO
                invHead = InvHead(
                    (inventarioViewModel as InventarioViewModel).InventarioNuevo,
                    if (!SerchArea()) "Ventas" else "Deposito",
                    1,
                    ObtenerFechaActual(),
                    ObtenerFechaActual(),
                    0L,
                    SerchArea(),
                    AjusteProductos(),
                    ProdNoCont()
                )
                AppDb.getAppDb(requireActivity())!!.InvHeadDAO()!!.insertInvHead(invHead)

                tvTitulo.text = "Inventario " + " # ${(inventarioViewModel as InventarioViewModel).InventarioNuevo} "+descArea
            }
        } else {// TODO (SI VENGO DE FRAGMENT DESCRIPCION)
            listArticulos.clear()
            cargarDeBdInventario((inventarioViewModel as InventarioViewModel).InventarioNuevo)
            tvTitulo.text = "Inventario " + " # ${(inventarioViewModel as InventarioViewModel).InventarioNuevo} "+ descArea
        }

        tCodigoBarras.setOnKeyListener { _, keyCode, keyEvent ->
            if (keyCode == KeyEvent.KEYCODE_ENTER && keyEvent.action == KeyEvent.ACTION_UP) {
                sChangeUpper = tCodigoBarras.text.toString()
                var indiceDelArtEncontrado = 0

                if (tCodigoBarras.text.isNullOrBlank() ) {
                    tCodigoBarras.error = "No puede estar vacio"
                    tCodigoBarras.requestFocus()
                    tCodigoBarras.hint = "No puede estar vacio"
                }else if (tCodigoBarras.text.toString().length<4 && iEstado==2) {
                    tCodigoBarras.error = "Minimo 4 caracteres"
                    tCodigoBarras.requestFocus()
                    tCodigoBarras.hint = "4 Minimo"

                } else {

                    //TODO COMIENZA LA BUSQUEDA POR CODIGO DE BARRAS
                    when (iBusquedaPor) {
                        0 -> {
                            // TODO: ESCONDE EL TECLADO VIRTUAL AL PRESIONAR ENTER
                            val imm = requireActivity().getSystemService(INPUT_METHOD_SERVICE) as InputMethodManager?
                            imm!!.hideSoftInputFromWindow(requireActivity().currentFocus?.windowToken, InputMethodManager.HIDE_NOT_ALWAYS)

                            GlobalScope.launch(Dispatchers.Main) {
                                indiceDelArtEncontrado = buscoArtEnRv(sChangeUpper.toUpperCase(Locale.ROOT), 0)//TODO Si encuentra el articulo en el RV devuelve el indice
                                //TODO (Si no lo encuentra devuelve -1)
                                if (indiceDelArtEncontrado != -1) {
                                    if (swSumaUno!!.isChecked) {
//                                        fCant = 0F
//                                        fCant = listArticulos[indiceDelArtEncontrado].cantTomada
//                                        fCant += 1F
                                        //TODO ACTUALIZO LA CANTIDAD EN LA BD
                                        updateCantidad(
                                            listArticulos[indiceDelArtEncontrado].sector.toString(),
                                            listArticulos[indiceDelArtEncontrado].codigo.toString(),
                                            listArticulos[indiceDelArtEncontrado].cantTomada + 1
                                        )
                                        //TODO ACTUALIZO LA CANTIDAD EN EL RV
                                        listArticulos[indiceDelArtEncontrado].cantTomada = listArticulos[indiceDelArtEncontrado].cantTomada + 1
                                        viewAdapter.notifyDataSetChanged()
                                    } else {
                                        dialogoSumaResta(requireContext(), indiceDelArtEncontrado, listArticulos[indiceDelArtEncontrado].univta, false)
                                    }

                                } else if (indiceDelArtEncontrado == -1) {// TODO: no lo encontro en el RV, lo va a buscar en al BD
                                    //TODO BUSCO EN BASE DE DATOS
                                    val artEncontrado = buscarCBEnBD(sChangeUpper.toUpperCase(Locale.ROOT))
                                    continuarCargaCB(artEncontrado)//TODO SE MANDA CERO POR QUE ES UN ARTICULO ESCANEADO NUEVO PARA QUE SEA COMPATIBLE
                                }
                                tCodigoBarras.focusable = View.FOCUSABLE
                                tCodigoBarras.setText("")
                                tCodigoBarras.selectAll()
                            }
                            return@setOnKeyListener true


                        }
                        1 -> {//TODO: BUSQUEDA POR DESCRIPCION**************************************************************************
                            // TODO: ESCONDE EL TECLADO VIRTUAL AL PRESIONAR ENTER
                            val imm = requireActivity().getSystemService(INPUT_METHOD_SERVICE) as InputMethodManager?
                            imm!!.hideSoftInputFromWindow(requireActivity().currentFocus?.windowToken, InputMethodManager.HIDE_NOT_ALWAYS)
                            //                    indiceDelArtEncontrado = buscoArtEnRv(sChangeUpper.toUpperCase(Locale.ROOT), 1) //TODO :Si encuentra el articulo en el RV devuelve el indice
                            //                    //TODO Si no lo encuentra devuelve -1
                            //                    if (indiceDelArtEncontrado != -1) {
                            ////                        if (swSumaUno!!.isChecked) {
                            ////                            fCant = 0F
                            ////                            fCant = listArticulos[indiceDelArtEncontrado].cantTomada
                            ////                            fCant += 1F
                            ////                            listArticulos[indiceDelArtEncontrado].cantTomada = fCant
                            ////                            viewAdapter.notifyDataSetChanged()
                            ////                        } else {
                            //                        fCant = listArticulos[indiceDelArtEncontrado].cantTomada
                            //                        MaterialDialog(requireContext()).show {
                            //                            title(R.string.sTituloNueva)
                            //                            message(R.string.sCantidadNueva)
                            //                            input { materialDialog, charSequence ->
                            //                                fCant = 0F
                            //                                fCant = charSequence.toString().toFloat()
                            //                            }
                            //                            positiveButton(R.string.btnOk) {
                            //                                listArticulos[indiceDelArtEncontrado].cantTomada = fCant
                            //                                viewAdapter.notifyDataSetChanged()
                            //                                dismiss()
                            //                            }
                            //                        }.cancelOnTouchOutside(false).cornerRadius(10F)
                            ////                        }
                            //
                            //                    } else if
                            //                       (indiceDelArtEncontrado == -1) {// TODO: no lo encontro en el RV, lo va a buscar en al BD
                            GlobalScope.launch(Dispatchers.Main) {
                                val artEncontrado = buscarDescEnBD(sChangeUpper.toUpperCase(Locale.ROOT))
                                continuarCargaDesc(artEncontrado as ArrayList<Articles>)
                            }

                            iBusquedaPor = 0
                            //                    }

                            return@setOnKeyListener true
                        }
                        2 -> {//TODO: BUSQUEDA POR CODIGO DE ORIGEN**************************************************************************
                            val imm = requireActivity().getSystemService(INPUT_METHOD_SERVICE) as InputMethodManager?
                            imm!!.hideSoftInputFromWindow(requireActivity().currentFocus?.windowToken, InputMethodManager.HIDE_NOT_ALWAYS)

//                            GlobalScope.launch(Dispatchers.Main) {
//                                indiceDelArtEncontrado = buscoArtEnRv(sChangeUpper.toUpperCase(Locale.ROOT), 2)//TODO Si encuentra el articulo en el RV devuelve el indice
////                            //TODO Si no lo encuentra devuelve -1
//                                if (indiceDelArtEncontrado != -1) {
//                                    if (swSumaUno!!.isChecked) {
//                                        fCant = 0F
//                                        fCant = listArticulos[indiceDelArtEncontrado].cantTomada
//                                        fCant += 1F
//                                        //TODO ACTUALIZO LA CANTIDAD EN LA BD
//                                        updateCantidad(listArticulos[indiceDelArtEncontrado].sector.toString(), listArticulos[indiceDelArtEncontrado].codigo.toString(), fCant)
//                                        //TODO ACTUALIZO LA CANTIDAD EN EL RV
//                                        listArticulos[indiceDelArtEncontrado].cantTomada = fCant
//                                        viewAdapter.notifyDataSetChanged()
//                                    } else {
//                                        dialogoSumaResta(requireContext(), indiceDelArtEncontrado, listArticulos[indiceDelArtEncontrado].univta, false)
//                                    }
//                                    } else {
//                                        val mDialogView = LayoutInflater.from(context).inflate(R.layout.login_dialog, null)
//                                        val mBuilder =
//                                            AlertDialog.Builder(context).setView(mDialogView).setTitle("Producto '${listArticulos[indiceDelArtEncontrado].descripcion}', se encuentra cargado.")
//                                                .setCancelable(false)
//                                        mDialogView.tvCantInicial.text = listArticulos[indiceDelArtEncontrado].cantTomada.toString()
//                                        val mAlertDialog = mBuilder.show()
//                                        mDialogView.rbSumar.setOnClickListener {
//                                            if (!mDialogView.tvNuevaCantidad.text.isNullOrEmpty()) {
//                                                mDialogView.tvgenerico4.text = (mDialogView.tvCantInicial.text.toString().toFloat() + mDialogView.tvNuevaCantidad.text.toString().toFloat()).toString()
//                                            }
//                                        }
//                                        mDialogView.rbRestar.setOnClickListener {
//                                            if (!mDialogView.tvNuevaCantidad.text.isNullOrEmpty()) {
//                                                if (mDialogView.tvCantInicial.text.toString().toFloat() >= mDialogView.tvNuevaCantidad.text.toString().toFloat()) {
//                                                    mDialogView.tvgenerico4.text =
//                                                        (mDialogView.tvCantInicial.text.toString().toFloat() - mDialogView.tvNuevaCantidad.text.toString().toFloat()).toString()
//                                                }
//                                            }
//                                        }
//                                        mDialogView.rbMdodificar.setOnClickListener {
//                                            if (!mDialogView.tvNuevaCantidad.text.isNullOrEmpty()) {
//                                                mDialogView.tvgenerico4.text = (mDialogView.tvNuevaCantidad.text.toString().toFloat()).toString()
//                                            }
//                                        }
//                                        mDialogView.btnAceptar.setOnClickListener {
//                                            mAlertDialog.dismiss()
//                                            val name = mDialogView.tvgenerico4.text.toString().toFloat()
//                                            fCant = 0F
//                                            fCant = name
//                                            listArticulos[indiceDelArtEncontrado].cantTomada = fCant
//                                            updateCantidad(listArticulos[indiceDelArtEncontrado].sector.toString(), listArticulos[indiceDelArtEncontrado].codigo.toString(), fCant)
//                                            viewAdapter.notifyDataSetChanged()
//                                        }
//                                        mDialogView.dialogCancelBtn.setOnClickListener {
//                                            mAlertDialog.dismiss()
//                                        }
//                                fCant = listArticulos[indiceDelArtEncontrado].cantTomada
//                                val type = InputType.TYPE_CLASS_NUMBER
//                                MaterialDialog(requireContext()).show {
//
//                                    title(text = "Producto '$sChangeUpper', se encuentra cargado.")
//                                    message(R.string.sCantidadNueva)
//                                    input(waitForPositiveButton = false, hint = "99.99", inputType = type) { materialDialog, charSequence ->
//                                        fCant = 0F
//                                        fCant = charSequence.toString().toFloat()
//                                    }
//                                    positiveButton(R.string.btnOk) {
//                                        //TODO ACTUALIZO CANTIADAD EN BD
//                                        updateCantidad(listArticulos[indiceDelArtEncontrado].sector.toString(), listArticulos[indiceDelArtEncontrado].codigo.toString(), fCant)
//                                        //TODO ACTUALIZO CANTIDAD EN RV
//                                        listArticulos[indiceDelArtEncontrado].cantTomada = fCant
//                                        viewAdapter.notifyDataSetChanged()
//                                        dismiss()
//                                    }
//                                }.cancelOnTouchOutside(false).cornerRadius(10F)
//                                }
//                                } else if (indiceDelArtEncontrado == -1) {
                            // no lo encontro en el RV, lo va a buscar en al BD

                            GlobalScope.launch(Dispatchers.Main) {
                                //TODO BUSCO EN BASE DE DATOS
                                val artEncontrado = buscarCodiogoOriEnBD(sChangeUpper.toUpperCase(Locale.ROOT))
                                continuarCargaCodigoOri(artEncontrado)
                            }
                            iBusquedaPor = 0
//                                }
//                            }
                            return@setOnKeyListener true
                        }
                    }
                }
            }
            return@setOnKeyListener false
        }
        return v
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        navController = Navigation.findNavController(view)
        etCodigoBarras.requestFocus()
//        val modalDialog = NoEncontradoSimple()
//        modalDialog.show(requireActivity().supportFragmentManager, "confirmDialog")

        btnBorrarInv.setOnClickListener {
            AlertDialog.Builder(requireContext()).setTitle("Eliminación de Inventarios").setMessage("¿Confirma que desea eliminar el inventario?")
                .setPositiveButton(R.string.btnOk, DialogInterface.OnClickListener { dialog, which ->
                    borrarInvActual()
                    Toast.makeText(requireContext(), "El inventario $(inventarioViewModel as InventarioViewModel).InventarioNuevo fue Borrado", Toast.LENGTH_LONG).show()
                    navController.navigate(R.id.action_inventarioFragment_to_mainFragment2)
                    (inventarioViewModel as InventarioViewModel).InventarioNuevo = 0

                }).setNegativeButton(R.string.btnCancelar, DialogInterface.OnClickListener { dialog, which ->
                    //botón cancel pulsado
                }).show()
        }

        btnExportarInv.setOnClickListener {
            AlertDialog.Builder(requireContext()).setTitle(R.string.sTituloExportar).setMessage(R.string.sMensajeExportar)
                .setPositiveButton(R.string.btnOk, DialogInterface.OnClickListener { dialog, which ->
                    exportarInventario(InventarioNuevo)
                    borrarInvActual()
                    Toast.makeText(requireContext(), "El inventario $(inventarioViewModel as InventarioViewModel).InventarioNuevo fue Exportado al Servidor", Toast.LENGTH_LONG).show()
                    navController.navigate(R.id.action_inventarioFragment_to_mainFragment2)
                    (inventarioViewModel as InventarioViewModel).InventarioNuevo = 0

                }).setNegativeButton(R.string.btnCancelar, DialogInterface.OnClickListener { dialog, which -> }).show()
        }
        ivCamara.setOnClickListener {
            if (!bFirst) {
                iEstado = 1
                bFirst = true
            }

            when (iEstado) {
                0 -> {
                    ivCamara.setImageResource(R.drawable.codbar)
                    etCodigoBarras.hint = "Busqueda por Código de Barras"
                    swSumaUno.visibility = View.VISIBLE
                    iBusquedaPor = 0
                    iEstado = 1
                }
                1 -> {
                    ivCamara.setImageResource(R.drawable.desc)
                    etCodigoBarras.hint = "Busqueda por Descripción"
                    swSumaUno.visibility = View.GONE
                    iBusquedaPor = 1
                    iEstado = 2
                }
                2 -> {
                    ivCamara.setImageResource(R.drawable.cod_origen)
                    etCodigoBarras.hint = "Busqueda por Código de Origen"
                    swSumaUno.visibility = View.GONE
                    iBusquedaPor = 2
                    iEstado = 0
                }
            }
        }
    }

    private fun exportarInventario(inventario: Int) {
        GlobalScope.launch(Dispatchers.Main) {
            val aEnviar: MutableList<InvToSend>?=null
            val datosCabecera = foundInvHeadDB(inventario)
            val datosCuerpo=foundInvBodyBD(inventario)

            for (cuerpo in datosCuerpo){
                 val temp=InvToSend(
                    datosCabecera.fechaInicio,
                    datosCabecera.fechaFinal,
                    if (datosCabecera.lugar!!) 1 else 0,
                    cuerpo.sector,
                    cuerpo.codigo,
                    cuerpo.descripcion,
                    cuerpo.cantTomada,
                    cuerpo.fechaInicio,
                    cuerpo.fechaFinal)
                aEnviar!!.add (temp)
            }
            exportarInventario(aEnviar!!)
        }


          }
    private fun exportarInventario(aEnviar:List<InvToSend> ){

        val call: Call<Void?>? = WebService
                  .getInstance()
                  ?.createService(WebServiceApi::class.java)
                  ?.inventarioToSend(aEnviar)

                      call!!.enqueue(object : Callback<Void?> {
                          override fun onResponse(call: Call<Void?>?, response: Response<Void?>) {
                              if (response.code() == 201) {
                              }
                              if (response.code() == 409) {
                              }
                          }

                          override fun onFailure(call: Call<Void?>?, t: Throwable?) {}
                      })

    }

    private suspend fun foundInvHeadDB(inv: Int): InvHead {
        var busqueda: InvHead
        return GlobalScope.async(IO) {
            busqueda = AppDb.getAppDb(requireContext())!!.InvHeadDAO()!!.foundInvHead(inv)
            return@async busqueda
        }.await()
    }

    private suspend fun foundInvBodyBD(inv: Int): List<InvBody> {
            var busqueda: List<InvBody>
            return GlobalScope.async(IO) {
                busqueda = AppDb.getAppDb(requireContext())!!.InvBodyDAO()!!.fetchAllInvBody(inv)
                return@async busqueda
            }.await()
        }

    private fun borrarInvActual() {
        lifecycleScope.launch {
            withContext(Dispatchers.IO) {
                AppDb.getAppDb(requireActivity())!!.InvHeadDAO()!!.deleteinvHead((inventarioViewModel as InventarioViewModel).InventarioNuevo)
                AppDb.getAppDb(requireActivity())!!.InvBodyDAO()!!.deleteInvBody((inventarioViewModel as InventarioViewModel).InventarioNuevo)
            }
        }
    }

    private fun cargarDeBdInventario(ultimoInv: Int) {
        GlobalScope.launch(Dispatchers.Main) {
            val invbody = cargarInventario(ultimoInv)
            for ((i, _) in invbody!!.withIndex()) {
                val art = Articles(
                    invbody[i].sector,
                    invbody[i].codigo,
                    invbody[i].descripcion,
                    invbody[i].codBar,
                    invbody[i].codOrigen,
                    invbody[i].precio,
                    invbody[i].costo,
                    "",
                    "",
                    "",
                    invbody[i].balanza,
                    invbody[i].depSn,
                    invbody[i].costo)
                cargarRecicler(art, invbody[i].cantTomada!!.toFloat())
            }
        }
    }

    private fun continuarCargaCodigoOri(artAcargar: List<Articles>) {

        if (artAcargar.isNotEmpty() || !artAcargar.isNullOrEmpty()) {// TODO: Si lo encuentra en la BD
            // TODO: ESCONDE EL TECLADO VIRTUAL AL PRESIONAR ENTER
            val imm = requireActivity().getSystemService(INPUT_METHOD_SERVICE) as InputMethodManager?
            imm!!.hideSoftInputFromWindow(requireActivity().currentFocus?.windowToken, InputMethodManager.HIDE_NOT_ALWAYS)

            var bundle = Bundle()
            bundle = bundleOf("ArrayDesc" to artAcargar)
            bundle.putInt("numeroInv", (inventarioViewModel as InventarioViewModel).InventarioNuevo)
            navController.navigate(R.id.action_inventarioFragment_to_codigoOriFragment, bundle)

        } else {//TODO si no lo encuentra en la BD
            val modalDialog = NoEncontradoSimple()
            modalDialog.show(requireActivity().supportFragmentManager, "confirmDialog")
        }
        etCodigoBarras.focusable = View.FOCUSABLE
        etCodigoBarras.setText("")
        etCodigoBarras.selectAll()
    }

    private fun continuarCargaDesc(artAcargar: ArrayList<Articles>) {
        //TODO DESPUES DE INGRESAR LA DESCRIPCION Y DE BUSCAR LOS CAINCIDENCIAS EN LA BASE SE VA A MOSTRAR LAS MISMAS
        //TODO SI LA CANTIDAD ENCONTRADA ES UNO, LO CARGO DIRECTAMENTE EN EL RV

        if (artAcargar.isNotEmpty() || !artAcargar.isNullOrEmpty()) {// TODO: Si lo encuentra en la BD
//            if (artAcargar.size == 1) { // TODO: SI EN EL ARRAY SOLO HAY UN ITEM LO METE DIRECTAMENTE AL RV
//                fCant = 0F
//                fCant += 1F
//                // TODO PASO DEL ARRAY A UN ITEM PARA QUE LO CARGUE EN EL RV
//                val acargarPorDesc = Articles(artAcargar[0].sector,
//                    artAcargar[0].codigo,
//                    artAcargar[0].descripcion,
//                    artAcargar[0].codBar,
//                    artAcargar[0].codOrigen,
//                    artAcargar[0].precio,
//                    artAcargar[0].costo,
//                    "",
//                    "",
//                    "",
//                    artAcargar[0].balanza,
//                    artAcargar[0].depSn,
//                    "")
//                // TODO LO ENVIO A CARGAR EN EL RV Y EN LA BD
//                cargarArtEnBd(acargarPorDesc, fCant)
//                cargarRecicler(acargarPorDesc, fCant)
//            } else {
            // TODO: ESCONDE EL TECLADO VIRTUAL AL PRESIONAR ENTER
            val imm = requireActivity().getSystemService(INPUT_METHOD_SERVICE) as InputMethodManager?
            imm!!.hideSoftInputFromWindow(requireActivity().currentFocus?.windowToken, InputMethodManager.HIDE_NOT_ALWAYS)
            var bundle = Bundle()
            bundle = bundleOf("ArrayDesc" to artAcargar)
            bundle.putInt("numeroInv", (inventarioViewModel as InventarioViewModel).InventarioNuevo)
            navController.navigate(R.id.action_inventarioFragment_to_descripcionFragment, bundle)
            //navController.backStack.removeLast()
//            }
//            } else {//SI NO ESTA +1
//                if (artAcargar.size == 1) { // TODO: SI EN EL ARRAY SOLO HAY UN ITEM LO METE DIRECTAMENTE AL RV
//                    fCant = listArticulos[0].cantTomada
//                    MaterialDialog(requireContext()).show {
//                        title(R.string.sTituloNueva)
//                        message(R.string.sCantidadNueva)
//                        input { materialDialog, charSequence ->
//                            fCant = 0F
//                            fCant = charSequence.toString().toFloat()
//                        }
//                        positiveButton(R.string.btnOk) {
//                            listArticulos[0].cantTomada = fCant
//                            viewAdapter.notifyDataSetChanged()
//                            dismiss()
//                        }
//                    }.cancelOnTouchOutside(false).cornerRadius(10F)
//                    // TODO PASO DEL ARRAY A UN ITEM PARA QUE LO CARGUE EN EL RV
//                    val acargarPorDesc = Articles(artAcargar[0].sector,
//                        artAcargar[0].codigo,
//                        artAcargar[0].descripcion,
//                        artAcargar[0].codBar,
//                        artAcargar[0].cod_origen,
//                        artAcargar[0].precio,
//                        artAcargar[0].costo,
//                        artAcargar[0].balanza,
//                        artAcargar[0].depSn,
//                        "")
//                    // TODO LO ENVIO A CARGAR EN EL RV Y EN LA BD
//                    cargarArtEnBd(acargarPorDesc, fCant)
//                    cargarRecicler(acargarPorDesc, fCant)
//                } else {
//                    var bundle = Bundle()
//                    bundle = bundleOf("ArrayDesc" to artAcargar)
//                    bundle.putInt("numeroInv", (inventarioViewModel as InventarioViewModel).InventarioNuevo)
//                    navController.navigate(R.id.action_inventarioFragment_to_descripcionFragment, bundle)
//                }
//            }
        } else {//TODO si no lo encuentra en la BD
            val modalDialog = NoEncontradoSimple()
            modalDialog.show(requireActivity().supportFragmentManager, "confirmDialog")
        }
        etCodigoBarras.focusable = View.FOCUSABLE
        etCodigoBarras.setText("")
        etCodigoBarras.selectAll()
    }

    private fun continuarCargaCB(artAcargar: Articles?) {

        if (artAcargar != null) {// TODO: Si lo encuentra en la BD
            if (swSumaUno!!.isChecked) {//TODO: SI ESTA +1, PONE CANTIDAD 1
                fCant = 0F
                fCant += 1F
                cargarArtEnBd(artAcargar, String.format("%.3f", fCant))
                cargarRecicler(artAcargar, fCant)
            } else {//TODO: SI NO ESTA +1 PREGUNTA CANTIDAD

                dialogingresarCantidad(requireContext(), artAcargar)

            }
        } else {// TODO si no lo encuentra en la BD
            val modalDialog = NoEncontradoSimple()
            modalDialog.show(requireActivity().supportFragmentManager, "confirmDialog")
        }
        etCodigoBarras.focusable = View.FOCUSABLE
        etCodigoBarras.setText("")
        etCodigoBarras.selectAll()
    }

    fun dialogingresarCantidad(cnxt: Context, artAcargar: Articles?): Float {
        var cantidad = 0F
        val mDialogView = LayoutInflater.from(cnxt).inflate(R.layout.ingresar_cantidad, null)
        val mBuilder = AlertDialog.Builder(cnxt).setView(mDialogView).setCancelable(false)
        if (artAcargar!!.balanza!!.toInt() == 1 || artAcargar.balanza!!.toInt() == 3 || artAcargar.balanza!!.toInt() == 7) mDialogView.etCantidad.inputType = TYPE_CLASS_NUMBER
        mDialogView.tvTitulo.text = artAcargar.descripcion.toString()
        val mAlertDialog = mBuilder.show()

        mDialogView.etCantidad.requestFocus()
        mAlertDialog?.window!!.clearFlags(WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE or WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM)
        mAlertDialog.window!!.setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE)

        mDialogView.btnAceptar.setOnClickListener {
            if (mDialogView.etCantidad.text.isNullOrEmpty()) {
                mDialogView.etCantidad.error = "No vacio"
                mDialogView.etCantidad.requestFocus()
                mDialogView.etCantidad.hint = "Ingrese un valor"
            } else if (!mDialogView.etCantidad.text.isNullOrEmpty()) {
                mAlertDialog.dismiss()
                cantidad = mDialogView.etCantidad.text.toString().toFloat()
                cargarArtEnBd(artAcargar, String.format("%.2f", cantidad))
                cargarRecicler(artAcargar, cantidad)
                modificarCantidadEnCabecera((inventarioViewModel as InventarioViewModel).InventarioNuevo, true, requireContext())
            }
        }
        return cantidad
    }

    fun dialogoSumaResta(context: Context, indiceDelArtEncontrado: Int, univta: String, cancelable: Boolean) {

         mDialogView = LayoutInflater.from(context).inflate(R.layout.login_dialog, null)
        val mBuilder = AlertDialog.Builder(context).setView(mDialogView).setCancelable(cancelable)
        // TODO: SI PERMITE QUE INGRESE DECIMALES
        if (univta.contains("1") || univta.contains("3") || univta.contains("7")) mDialogView.tvNuevaCantidad.inputType = TYPE_CLASS_NUMBER
        mDialogView.tvTitulo2.text="${listArticulos[indiceDelArtEncontrado].descripcion}"
        mDialogView.tvCantInicial.text = String.format("%.2f", listArticulos[indiceDelArtEncontrado].cantTomada)
        val mAlertDialog = mBuilder.show()
        mDialogView.tvNuevaCantidad.requestFocus()



        mAlertDialog?.window!!.clearFlags(WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE or WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM)
        mAlertDialog.window!!.setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE)

        mDialogView.tvNuevaCantidad.addTextChangedListener(textWatcher)

        mDialogView.rbSumar.setOnClickListener {
            if (!mDialogView.tvNuevaCantidad.text.isNullOrEmpty()) {
                mDialogView.tvResultado.text = String.format("%.2f", mDialogView.tvCantInicial.text.toString().toFloat() + mDialogView.tvNuevaCantidad.text.toString().toFloat())
//                mDialogView.tvNuevaCantidad.isEnabled = false
            }
        }
        mDialogView.rbRestar.setOnClickListener {
            if (!mDialogView.tvNuevaCantidad.text.isNullOrEmpty()) {
                if (mDialogView.tvCantInicial.text.toString().toFloat() >= mDialogView.tvNuevaCantidad.text.toString().toFloat()) {
                    mDialogView.tvResultado.text = String.format("%.2f", mDialogView.tvCantInicial.text.toString().toFloat() - mDialogView.tvNuevaCantidad.text.toString().toFloat())
//                    mDialogView.tvNuevaCantidad.isEnabled = false
                } else {
                    mDialogView.tvResultado.text = ""
                    mDialogView.tvResultado.error = "Operación No Valida"
                    mDialogView.tvResultado.requestFocus()
                    mDialogView.tvResultado.hint = "Error"
                }
            }
        }
        mDialogView.rbMdodificar.setOnClickListener {
            if (!mDialogView.tvNuevaCantidad.text.isNullOrEmpty()) {
                mDialogView.tvResultado.text = String.format("%.2f", mDialogView.tvNuevaCantidad.text.toString().toFloat())
//                mDialogView.tvNuevaCantidad.isEnabled = false
            }
        }
        mDialogView.btnAceptar.setOnClickListener {
            if (mDialogView.tvNuevaCantidad.text.isNotEmpty() || !mDialogView.tvNuevaCantidad.text.isBlank()) {
                if (mDialogView.tvResultado.text.isNotEmpty() || !mDialogView.tvResultado.text.isBlank()) {
                    mAlertDialog.dismiss()
                    listArticulos[indiceDelArtEncontrado].cantTomada = String.format("%.2f", mDialogView.tvResultado.text.toString().toFloat()).toFloat()
                    updateCantidad(
                        listArticulos[indiceDelArtEncontrado].sector.toString(),
                        listArticulos[indiceDelArtEncontrado].codigo.toString(),
                        String.format("%.2f", mDialogView.tvResultado.text.toString().toFloat()).toFloat()
                    )

                    viewAdapter.notifyDataSetChanged()
                } else if (mDialogView.tvNuevaCantidad.text.isNotEmpty() || mDialogView.tvNuevaCantidad.text.isBlank()) {
                    mDialogView.tvResultado.error = "Operación Requerida"
                    mDialogView.tvResultado.requestFocus()
                    mDialogView.tvResultado.hint = "Seleccione Operación"
                }
            } else if (mDialogView.tvNuevaCantidad.text.isEmpty() || mDialogView.tvNuevaCantidad.text.isBlank()) {
                mDialogView.tvNuevaCantidad.error = "Completar"
                mDialogView.tvNuevaCantidad.requestFocus()
                mDialogView.tvNuevaCantidad.hint = "Ingrese un valor"
            }
        }
        mDialogView.dialogCancelBtn.setOnClickListener {
            mAlertDialog.dismiss()
        }
    }

    suspend fun buscarCodiogoOriEnBD(CodOri: String):  List<Articles> {
        //TODO BUSQUEDA POR CODIGO DE BARRAS
        var busqueda: List<Articles>
        return GlobalScope.async(IO) {
            busqueda = AppDb.getAppDb(requireContext())!!.ArticulosDAO()!!.findArticuloByCodOri(CodOri, SerchAreaInventario())
            return@async busqueda
        }.await()
    }

    suspend fun buscarCBEnBD(CodigoBarras: String): Articles? {
        //TODO BUSQUEDA POR CODIGO DE BARRAS
        var busqueda: Articles? = null
        return GlobalScope.async(IO) {
            busqueda = AppDb.getAppDb(requireContext())!!.ArticulosDAO()!!.findArticuloByCodBar(CodigoBarras, SerchAreaInventario())
            return@async busqueda
        }.await()
    }

    suspend fun buscarDescEnBD(descripcion: String): List<Articles>? {
        //TODO BUSQUEDA POR DESCRIPCION
        var busqueda: List<Articles>? = null
        return GlobalScope.async(IO) {
            busqueda = AppDb.getAppDb(requireContext())!!.ArticulosDAO()!!.findArticuloByDesc(descripcion, SerchAreaInventario())
            return@async busqueda
        }.await()
    }

    suspend fun borrarArticulo(sector: String, codigo: String, inventario: String): Int? {
        //TODO BUSQUEDA POR DESCRIPCION
        var result: Int
        return GlobalScope.async(IO) {
            result = AppDb.getAppDb(requireContext())!!.InvBodyDAO()!!.deleteItemFromInvBody(sector.toLong(), codigo.toLong(), inventario.toInt())
            return@async result
        }.await()
    }

    private suspend fun buscoArtEnRv(codigoBarras: String, sTipoBusqueda: Int): Int {
        return GlobalScope.async(IO) {
            var indice = 0
            var bEncontrado = false
            if (sTipoBusqueda == 0) {//TODO BUSQUEDA POR CODIGO DE BARRAS
                // TODO CAMBIO DE CB A CODIGO DEBO
                val any = cambioCBporCodigoDebo(codigoBarras)
                if (any != null) {
                    for (item in listArticulos) {
                        if (item.sector!!.toInt() == any.sector!!.toInt() && item.codigo!!.toInt() == any.codigo!!.toInt()) {
                            bEncontrado = true
                            break
                        }
                        indice += 1
                    }
                }

            } else if (sTipoBusqueda == 1) {//TODO BUSQUEDA POR DESCRIPCION
                for (item in listArticulos) {
                    if (item.descripcion!!.toUpperCase(Locale.ROOT).contains(codigoBarras)) {
                        bEncontrado = true
                        break
                    }
                    indice += 1
                }
            } else if (sTipoBusqueda == 2) {//TODO BUSQUEDA POR CODIGO DE ORIGEN
                for (item in listArticulos) {
                    if (item.codigoOrigen!!.toUpperCase(Locale.ROOT).contains(codigoBarras)) {
                        bEncontrado = true
                        break
                    }
                    indice += 1
                }
            }
            return@async if (bEncontrado) indice else -1
        }.await()
    }

    suspend fun cambioCBporCodigoDebo(codigoBarras: String): Articles? {
        //TODO BUSQUEDA POR DESCRIPCION
        var busqueda: Articles? = null
        return GlobalScope.async(IO) {
            busqueda = AppDb.getAppDb(requireContext())!!.ArticulosDAO()!!.findArticuloByCodBar(codigoBarras, SerchAreaInventario())
            return@async busqueda
        }.await()
    }

    private fun cargarArtEnBd(articulos: Articles, cant: String) {
        val body = InvBody(
            (inventarioViewModel as InventarioViewModel).InventarioNuevo,// TODO PREPARO PARA MANDAR A CARGAR EN LA BD
            articulos.sector,
            articulos.codigo,
            articulos.descripcion,
            cant,
            articulos.codBar,
            articulos.codOrigen,
            articulos.precio,
            articulos.precio,
            articulos.balanza,
            articulos.depSn,
            ObtenerFechaActual(),
            ObtenerFechaActual()
        )
        InsertarArtEnDB(body)// TODO MANDO A CARGAR A LA BASE DE DATOS
    }

    fun cargarRecicler(articulos: Articles, cant: Float) {
        //TODO CARGO EN LE RV
        val item = ItemsRecycler(
            if (articulos.sector.toString().toInt() < 9) "0${articulos.sector.toString()}" else articulos.sector.toString(),
            articulos.codigo,
            articulos.descripcion,
            cant,
            articulos.codBar,
            articulos.codOrigen,
            articulos.balanza.toString(),
            articulos.de.toString()
        )
        listArticulos.add(item)

        viewAdapter = ProductosListAdapter(requireContext(), listArticulos, this)
        viewManager = LinearLayoutManager(requireContext())
        deleteIcon = ContextCompat.getDrawable(requireContext(), R.drawable.borrar)!!
        rcInventarios.apply {
            adapter = viewAdapter
            layoutManager = viewManager
        }
        val itemTouchHelperCallback = object : ItemTouchHelper.SimpleCallback(0, ItemTouchHelper.RIGHT) {
            override fun onMove(p0: RecyclerView, p1: RecyclerView.ViewHolder, target: RecyclerView.ViewHolder): Boolean {
                return false
            }

            override fun onSwiped(viewHolder: RecyclerView.ViewHolder, direction: Int) {

                GlobalScope.launch(Dispatchers.Main) {
                    borrarArticulo(
                        listArticulos[viewHolder.adapterPosition].sector.toString(),
                        listArticulos[viewHolder.adapterPosition].codigo.toString(),
                        (inventarioViewModel as InventarioViewModel).InventarioNuevo.toString()
                    )
                    (viewAdapter as ProductosListAdapter).removeItem(viewHolder)
                    viewAdapter.notifyDataSetChanged()
                    modificarCantidadEnCabecera((inventarioViewModel as InventarioViewModel).InventarioNuevo, false, requireContext())
                }
            }

            override fun onChildDraw(c: Canvas, recyclerView: RecyclerView, viewHolder: RecyclerView.ViewHolder, dX: Float, dY: Float, actionState: Int, isCurrentlyActive: Boolean) {
                val itemView = viewHolder.itemView
                val iconMargin = (itemView.height - deleteIcon.intrinsicHeight) / 2
                c.clipRect(0f, itemView.top.toFloat(), dX, itemView.bottom.toFloat())

                if (dX > 0) {

                    if (dX < c.width / 2) c.drawColor(Color.GREEN)
                    else c.drawColor(Color.RED)
                    deleteIcon.setBounds(itemView.left + iconMargin, itemView.top + iconMargin, itemView.left + iconMargin + deleteIcon.intrinsicWidth, itemView.bottom - iconMargin)
                } else {
                }

                super.onChildDraw(c, recyclerView, viewHolder, dX, dY, actionState, isCurrentlyActive)
                deleteIcon.draw(c)
            }
        }

        val itemTouchHelper = ItemTouchHelper(itemTouchHelperCallback)
        itemTouchHelper.attachToRecyclerView(rcInventarios)
    }

    private fun ProdNoCont(): Int? {
        var mostrarStock = 0
        if (sharedPreferences.contains("cbMostrarStock")) if (sharedPreferences.getString("cbMostrarStock", "").toString() == "1") mostrarStock = 1
        return mostrarStock
    }

    private fun AjusteProductos(): Int? {
        var prodInclu = 0
        if (sharedPreferences.contains("rbProInclu")) if (sharedPreferences.getString("rbProInclu", "").toString() == "1") prodInclu = 1

        if (sharedPreferences.contains("rbProNoInclu")) if (sharedPreferences.getString("rbProNoInclu", "").toString() == "0") prodInclu = 0
        return prodInclu
    }

    private fun SerchArea(): Boolean {
        if (sharedPreferences.contains("rbVentas")) if (sharedPreferences.getString("rbVentas", "").toString() == "1") iArea =false
        if (sharedPreferences.contains("rbDeposito")) if (sharedPreferences.getString("rbDeposito", "").toString() == "1") iArea = true
        return iArea
    }

   suspend fun SerchAreaInventario(): Boolean {
        return GlobalScope.async(IO) {
            return@async AppDb.getAppDb(requireActivity())!!.InvHeadDAO()!!.fetchAreaInvH((inventarioViewModel as InventarioViewModel).InventarioNuevo)
        }.await()

    }

    fun InsertarArtEnDB(cuarpoInventario: InvBody) {
        lifecycleScope.launch {
            withContext(Dispatchers.IO) {
                AppDb.getAppDb(requireActivity())!!.InvBodyDAO()!!.insertInvBody(cuarpoInventario)
            }
        }
    }

    fun updateCantidad(sector: String, codigo: String, cantidad: Float) {
        lifecycleScope.launch {
            withContext(IO) {
                AppDb.getAppDb(requireActivity())!!.InvBodyDAO()!!.updateInvBody(cantidad, sector.toLong(), codigo.toLong(), ObtenerFechaActual())
            }
        }
    }

    suspend fun cargarInventario(inventario: Int): List<InvBody>? {
        return GlobalScope.async(IO) {
            return@async AppDb.getAppDb(requireActivity())!!.InvBodyDAO()!!.fetchAllInvBody(inventario)
        }.await()
    }

    override fun onImageDotsClick(sector: String?, codigo: String?) {
        val bundle = Bundle()
        bundle.putString("sector", sector!!.toInt().toString())
        bundle.putString("codigo", codigo)
        bundle.putInt("numeroInv", (inventarioViewModel as InventarioViewModel).InventarioNuevo)
        navController.navigate(R.id.action_inventarioFragment_to_detalleArtFragment, bundle)
    }

    override fun onImagePenClick(sector: String?, codigo: String?, cantidad: String?, position: String) {
        dialogoSumaResta(requireContext(), position.toInt(), listArticulos[position.toInt()].univta, true)
    }

    private val textWatcher = object : TextWatcher {
        override fun afterTextChanged(s: Editable?) {}
        override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) {}

        override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {
            if(mDialogView.rbSumar.isChecked){
//                mDialogView.tvNuevaCantidad.isEnabled=false
                mDialogView.tvResultado.text=String.format("%.2f", mDialogView.tvNuevaCantidad.text.toString().toFloat() + mDialogView.tvCantInicial.text.toString().toFloat())
            }
            if(mDialogView.rbRestar.isChecked) {
                      if (!mDialogView.tvNuevaCantidad.text.isNullOrEmpty()) {
                          if (mDialogView.tvCantInicial.text.toString().toFloat() >= mDialogView.tvNuevaCantidad.text.toString().toFloat()) {
                              mDialogView.tvResultado.text = String.format("%.2f", mDialogView.tvCantInicial.text.toString().toFloat() - mDialogView.tvNuevaCantidad.text.toString().toFloat())
//                              mDialogView.tvNuevaCantidad.isEnabled = false
                          } else {
                              mDialogView.tvResultado.text = ""
                              mDialogView.tvResultado.error = "Operación No Valida"
                              mDialogView.tvResultado.requestFocus()
                              mDialogView.tvResultado.hint = "Error"
                          }
                      }
                  }
                  if(mDialogView.rbMdodificar.isChecked) {
                      if (!mDialogView.tvNuevaCantidad.text.isNullOrEmpty()) {
                          mDialogView.tvResultado.text = String.format("%.2f", mDialogView.tvNuevaCantidad.text.toString().toFloat())
//                          mDialogView.tvNuevaCantidad.isEnabled = false
                      }
                  }

        }
    }
}