package com.focasoftware.deboinventariov20.UI.Utils

import android.app.Activity
import android.app.AlertDialog
import android.app.Dialog
import android.content.Context
import android.content.Intent
import android.os.Bundle
import android.provider.Settings
import android.view.LayoutInflater
import android.view.View
import android.view.WindowManager
import android.view.inputmethod.InputMethodManager
import androidx.core.content.ContextCompat.getSystemService
import androidx.fragment.app.DialogFragment
import androidx.fragment.app.FragmentActivity
import com.focasoftware.deboinventariov20.DB.DataBase.AppDb
import com.focasoftware.deboinventariov20.Model.ServeInv
import com.focasoftware.deboinventariov20.R
import com.focasoftware.deboinventariov20.UI.inventario.InventarioFragment
import kotlinx.android.synthetic.main.fragment_inventario.*
import kotlinx.android.synthetic.main.solicitar_fecha.view.*
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.async
import java.io.IOException
import java.net.UnknownHostException
import java.time.LocalDateTime
import java.time.format.DateTimeFormatter


private var serverPre: ServeInv? = null

fun modificarCantidadEnCabecera(inventarioActual: Int, b: Boolean, context: Context) {
    GlobalScope.async(Dispatchers.IO) {
        var cantProductos = 0
        cantProductos =
            AppDb.getAppDb(context)!!.InvHeadDAO()!!.consultaCantidadInvH(inventarioActual)
        if (b) {
            AppDb.getAppDb(context)!!.InvHeadDAO()!!
                .updateInvCantHead(inventarioActual, cantProductos + 1)
        } else {
            AppDb.getAppDb(context)!!.InvHeadDAO()!!
                .updateInvCantHead(inventarioActual, cantProductos - 1)
        }
    }
}

open class AlertDialogBorrarInv : DialogFragment() {

    interface OnBorrarInvClickListener {
        fun onPositiveClick()
        fun onCancelClick()
    }

    override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
        return activity?.let {
            val title = "Borrar Inventario"
            val content = "¿Seguro que desea Borrar el inventario?"
            val builder: AlertDialog.Builder = AlertDialog.Builder(requireActivity())
            builder.setTitle(title).setMessage(content)

                .setPositiveButton(android.R.string.ok) { _, _ ->
                    val listener = activity as OnBorrarInvClickListener?
                    listener!!.onPositiveClick()
                }
                .setNegativeButton(android.R.string.cancel) { _, _ ->
                    val listener = activity as OnBorrarInvClickListener?
                    listener!!.onCancelClick()
                }
            return builder.create()
        } ?: throw IllegalStateException("Activity cannot be null")
    }
}

class NoEncontradoSimple : DialogFragment() {
    override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
        return activity?.let {
            val builder: AlertDialog.Builder = AlertDialog.Builder(requireActivity())
                .setCancelable(true)

            builder.show()
            val title = ""
            val content = "¡El producto buscado NO fue encontrado!"

            builder.setTitle(title).setMessage(content)
                .setPositiveButton(android.R.string.ok) { _, _ ->

                }
            return builder.create()
        } ?: throw IllegalStateException("Activity cannot be null")
    }
}

class NoServerConf : DialogFragment() {
    override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
        return activity?.let {
            val title = ""
            val content = "¡Antes de importar debe configurar un servidor!"
            val builder: AlertDialog.Builder = AlertDialog.Builder(requireActivity())
            builder.setTitle(title).setMessage(content)
                .setPositiveButton(android.R.string.ok) { _, _ ->
                    activity?.onBackPressed()
                }

            return builder.create()
        } ?: throw IllegalStateException("Activity cannot be null")
    }
}

fun isConnectedToThisServer(host: String): Boolean {

    val runtime = Runtime.getRuntime()
    try {
        val ipProcess = runtime.exec("/system/bin/ping -c 1 $host")
        val exitValue = ipProcess.waitFor()
        ipProcess.destroy()
        return exitValue == 0
    } catch (e: UnknownHostException) {
        e.printStackTrace()
    } catch (e: IOException) {
        e.printStackTrace()
    } catch (e: InterruptedException) {
        e.printStackTrace()
    }

    return false
}

class ServerValido : DialogFragment() {
    override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
        return activity?.let {
            val title = ""
            val content = "¡La IP del servidor es correcta!"
            val builder: AlertDialog.Builder = AlertDialog.Builder(requireActivity())
            builder.setTitle(title).setMessage(content)
                .setPositiveButton(android.R.string.ok) { _, _ -> }
            return builder.create()
        } ?: throw IllegalStateException("Activity cannot be null")
    }
}

class ServerNoValido : DialogFragment() {
    override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
        return activity?.let {
            val title = ""
            val content = "¡La IP del servidor es Incorrecta! Verfique en la carga de Servidores."
            val builder: AlertDialog.Builder = AlertDialog.Builder(requireActivity())
            builder.setTitle(title).setMessage(content)
                .setPositiveButton(android.R.string.ok) { _, _ -> }
            return builder.create()
        } ?: throw IllegalStateException("Activity cannot be null")
    }
}

class ServerNoConf : DialogFragment() {
    override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
        return activity?.let {
            val title = "Servidor no Valido"
            val content = "!Debe configurar el Servidor en Configuraciones¡"
            val builder: AlertDialog.Builder = AlertDialog.Builder(requireActivity())
            builder.setTitle(title).setMessage(content)
                .setPositiveButton(android.R.string.ok) { _, _ -> }
            return builder.create()
        } ?: throw IllegalStateException("Activity cannot be null")
    }
}

class ExportacionExitosa : DialogFragment() {
    override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
        return activity?.let {
            val title = "Exportación de Inventarios"
            val content = "!La exportacion del inventario se realizo exitosamente¡"
            val builder: AlertDialog.Builder = AlertDialog.Builder(requireActivity())
            builder.setTitle(title).setMessage(content)
                .setPositiveButton(android.R.string.ok) { _, _ -> }
            return builder.create()
        } ?: throw IllegalStateException("Activity cannot be null")
    }
}

class ExportacionFracasada : DialogFragment() {
    override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
        return activity?.let {
            val title = "Exportación de Inventarios"
            val content = "!No se pudo realizar la expotación¡"
            val builder: AlertDialog.Builder = AlertDialog.Builder(requireActivity())
            builder.setTitle(title).setMessage(content)
                .setPositiveButton(android.R.string.ok) { _, _ -> }
            return builder.create()
        } ?: throw IllegalStateException("Activity cannot be null")
    }
}

fun obtenerFechaActualFormatoFoca(): 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("yyyy-MM-dd HH:mm:ss")
    val dFechaHora = current.format(formatter)
    return dFechaHora.toString()
}
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 obtenerHoraActual(): 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("HHmmss")
    val dFechaHora = current.format(formatter)
    return dFechaHora.toString()
}

fun obtenerDiaActual(): 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("ddMMyyyy")
    val dFechaHora = current.format(formatter)
    return dFechaHora.toString()
}
class SelAreaInventarioVentas : DialogFragment() {
    override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
        return activity?.let {
            val title = "Inventarios de Ventas"
            val content = "!En busqueda de articulos no estaran disponibles los articulos de DEPOSITO¡"
            val builder: AlertDialog.Builder = AlertDialog.Builder(requireActivity())
            builder.setTitle(title).setMessage(content)
                .setPositiveButton(android.R.string.ok) { _, _ -> }
            return builder.create()
        } ?: throw IllegalStateException("Activity cannot be null")
    }
}

class SelAreaInventarioDeposito : DialogFragment() {
    override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
        return activity?.let {
            val title = "Inventarios de Depositos"
            val content = "!En busqueda de articulos no estaran disponibles los articulos de VENTAS¡"
            val builder: AlertDialog.Builder = AlertDialog.Builder(requireActivity())
            builder.setTitle(title).setMessage(content)
                .setPositiveButton(android.R.string.ok) { _, _ -> }
            return builder.create()
        } ?: throw IllegalStateException("Activity cannot be null")
    }
}

fun dialogoHoraServer(reqActivity: FragmentActivity, context: Context, fechaHoraDispositivo: String, fechaHoraServer: String) {
    val mDialogView: View = LayoutInflater.from(context).inflate(R.layout.solicitar_fecha, null)
    val mBuilder = AlertDialog.Builder(context).setView(mDialogView).setCancelable(false)


    mDialogView.tvHoraDispositivo.text = fechaHoraDispositivo
    mDialogView.tvHoraServidor.text = fechaHoraServer
    val mAlertDialog = mBuilder.show()

//    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)
//
//    val imm = reqActivity.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager?
//    imm!!.hideSoftInputFromWindow(reqActivity.currentFocus?.windowToken, InputMethodManager.HIDE_NOT_ALWAYS)

    mDialogView.btnCambiarHora.setOnClickListener {
        context.startActivity(Intent(Settings.ACTION_DATE_SETTINGS))
        mAlertDialog.dismiss()
    }

    mDialogView.btnSalir.setOnClickListener {
        mAlertDialog.dismiss()
    }
}

class InvSecImp : DialogFragment() {
    override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
        return activity?.let {
            val title = "Inventarios de Sectorizados"
            val content = "!Inventario importado correctamente¡"
            val builder: AlertDialog.Builder = AlertDialog.Builder(requireActivity())
            builder.setTitle(title).setMessage(content)
                .setPositiveButton(android.R.string.ok) { _, _ -> }
            return builder.create()
        } ?: throw IllegalStateException("Activity cannot be null")
    }
}

suspend fun fetchServerPreOne(reqActivity: FragmentActivity): ServeInv? {
    return GlobalScope.async(Dispatchers.IO) {
        return@async AppDb.getAppDb(reqActivity)!!.ServeInvDao()!!.fetchServerPreOne()
    }.await()
}

//fun hideSoftKeyboard(reqActivity: FragmentActivity) {
//    val imm = reqActivity.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager?
//     imm!!.hideSoftInputFromWindow(reqActivity.currentFocus?.windowToken, InputMethodManager.HIDE_NOT_ALWAYS)
//
//
//}
fun Context.hideSoftKeyboard(view: View) {
val inputMethodManager = getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager
inputMethodManager.hideSoftInputFromWindow(view.windowToken, 0) }