package com.focasoftware.deboinventariov20.UI.inventario

import android.annotation.SuppressLint
import android.app.AlertDialog
import android.app.Dialog
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.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.Articles
import com.focasoftware.deboinventariov20.Model.InvBody
import com.focasoftware.deboinventariov20.Model.InvHead
import com.focasoftware.deboinventariov20.R
import com.focasoftware.deboinventariov20.UI.Utils.NoEncontradoSimple
import com.focasoftware.deboinventariov20.UI.Utils.modificarCantidadEnCabecera
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 java.time.LocalDateTime
import java.time.format.DateTimeFormatter
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

    @SuppressLint("MissingPermission")
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        sharedPreferences = requireActivity().getSharedPreferences("SP_INFO", Context.MODE_PRIVATE)
        if (sharedPreferences.contains("Inventario")) if (sharedPreferences.getString("Inventario", "").toString() != "-1") {
            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)

        if (InventarioNuevo == 0) {// TODO: SI INVETNARIO NUEVO
            GlobalScope.launch(Dispatchers.Main) {
                //TODO: BUSCO EL ULTIMO INVENTARIO EN LA BD PARA PODER CREAR EL PROXIMO
                InventarioNuevo = AppDb.getAppDb(requireActivity())?.InvHeadDAO()?.findLastInv()?.plus(1) ?: 1
                //TODO: CREAMOS EL INVENTARIO EN LA CABECERA DEL INVENTARIO
                invHead = InvHead(InventarioNuevo, if (!SerchArea()) "Ventas" else "Deposito", 1, ObtenerFechaActual(), ObtenerFechaActual(), 0L, SerchArea(), AjusteProductos(), ProdNoCont())
                AppDb.getAppDb(requireActivity())!!.InvHeadDAO()!!.insertInvHead(invHead)
                tvTitulo.text = "Inventario Dinamico" + " N° $InventarioNuevo"
            }
        } else {// TODO (SI VENGO DE FRAGMENT DESCRIPCION)
            listArticulos.clear()
            CargarDeBdInventario(InventarioNuevo)
            tvTitulo.text = "Inventario Dinamico" + " N° $InventarioNuevo"
        }

        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 $InventarioNuevo fue Borrado", Toast.LENGTH_LONG).show()
                    navController.navigate(R.id.action_inventarioFragment_to_mainFragment2)
                    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 ->
                    BorrarInvActual()
                    Toast.makeText(requireContext(), "El inventario $InventarioNuevo fue Exportado al Servidor", Toast.LENGTH_LONG).show()
                    navController.navigate(R.id.action_inventarioFragment_to_mainFragment2)
                    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. 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. Origen"
                    swSumaUno.visibility = View.GONE
                    iBusquedaPor = 2
                    iEstado = 0
                }
            }
        }
    }

    private fun BorrarInvActual() {
        lifecycleScope.launch {
            withContext(Dispatchers.IO) {
                AppDb.getAppDb(requireActivity())!!.InvHeadDAO()!!.deleteinvHead(InventarioNuevo.toLong())
                AppDb.getAppDb(requireActivity())!!.InvBodyDAO()!!.deleteInvBody(InventarioNuevo.toLong())
            }
        }
    }

    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", 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", 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", 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(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(Dispatchers.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(Dispatchers.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.toLong())
            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(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(), InventarioNuevo.toString())
                    (viewAdapter as ProductosListAdapter).removeItem(viewHolder)
                    viewAdapter.notifyDataSetChanged()
                    modificarCantidadEnCabecera(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(InventarioNuevo.toLong())
        }.await()

    }

    fun ObtenerFechaActual(): String? {
        //TODO OBTENGO FECHA Y HORA ACTUAL PARA LA CABECERA DEL INVENTARIO Y PARA CADA ITEM QUE SE INSERTA EN LA BD
        val current = LocalDateTime.now()
        val formatter = DateTimeFormatter.ofPattern("dd/MM/yyyy hh:mm:ss")
        val dFechaHora = current.format(formatter)
        return dFechaHora.toString()
    }

    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(Dispatchers.IO) {
                AppDb.getAppDb(requireActivity())!!.InvBodyDAO()!!.UpdateInvBody(cantidad, sector.toLong(), codigo.toLong())
            }
        }
    }

    suspend fun cargarInventario(inventario: Int): List<InvBody>? {
        return GlobalScope.async(Dispatchers.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", 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
                      }
                  }

        }
    }
}