Untitled

import android.Manifest
import android.content.Context
import android.content.pm.PackageManager
import android.os.Bundle
import android.widget.Toast
import androidx.activity.result.contract.ActivityResultContracts
import androidx.core.app.ActivityCompat
import androidx.core.content.ContextCompat
import androidx.fragment.app.viewModels
import com.twilio.voice.Call
import com.twilio.voice.CallException
import com.twilio.voice.ConnectOptions
import com.twilio.voice.RegistrationException
import com.twilio.voice.RegistrationListener
import com.twilio.voice.Voice
import com.usmh.core.base.fragment.BaseFragment
import com.usmh.core.model.ActionState
import com.usmh.core.utils.Constants
import com.usmh.core.utils.StringUtils.isEmailValid
import com.usmh.core.utils.onTextChange
import com.usmh.core.utils.setOnSafeClickListener
import com.usmh.core.utils.toastMessage
import com.usmh.taskmanager.R
import com.usmh.taskmanager.TaskManagerNavigation
import com.usmh.taskmanager.databinding.FragmentForgotPasswordBinding
import dagger.hilt.android.AndroidEntryPoint
import timber.log.Timber
import javax.inject.Inject

@AndroidEntryPoint
class ForgotPasswordFragment :
    BaseFragment<FragmentForgotPasswordBinding, ForgotPasswordViewModel>(R.layout.fragment_forgot_password) {

    lateinit var twilioVoiceManager: TwilioVoiceManager

    @Inject
    lateinit var taskManagerNavigation: TaskManagerNavigation

    private val viewModel: ForgotPasswordViewModel by viewModels()

    override fun getVM() = viewModel

    override fun initView(savedInstanceState: Bundle?) {
        super.initView(savedInstanceState)

        twilioVoiceManager = TwilioVoiceManager(requireContext())
        twilioVoiceManager.init(
            ""
        )
    }

    override fun setOnClick() {
        super.setOnClick()

        binding.btnContinue.setOnSafeClickListener {
            if (ContextCompat.checkSelfPermission(requireContext(), Manifest.permission.RECORD_AUDIO) != PackageManager.PERMISSION_GRANTED) {
                requestPermissionLauncher.launch(Manifest.permission.RECORD_AUDIO)
            } else {
                twilioVoiceManager.makeCall()
            }

//            val email = binding.edtEmailLogin.editText?.text.toString()
//            if (email.isEmailValid()) {
//                showEmailError(false)
//                viewModel.sendOTP(binding.edtEmailLogin.editText?.text.toString())
//            } else {
//                showEmailError(true)
//            }
        }

        binding.toolbar.setOnClickBackButton {
            taskManagerNavigation.navigateUp()
        }
    }

    private val requestPermissionLauncher = registerForActivityResult(ActivityResultContracts.RequestPermission()) { isGranted ->
        if (isGranted) {
            twilioVoiceManager.makeCall()
        } else {
            toastMessage("Please allow to make call")
        }
    }



    override fun bindingAction() {
        super.bindingAction()

        viewModel.sendOtpState.observe(viewLifecycleOwner) {
            when(it) {
                is ActionState.Success -> {
                    val args = Bundle()
                    args.putString(
                        Constants.KeyParam.KEY_EMAIL,
                        binding.edtEmailLogin.editText?.text.toString()
                    )
                    taskManagerNavigation.openEnterOTPScreen(
                        bundle = args
                    )
                }
                is ActionState.Error -> {}
                else -> { }
            }
        }

        binding.edtEmailLogin.editText?.onTextChange {
            showEmailError(!binding.edtEmailLogin.editText?.text.toString().isEmailValid())
        }
    }

    private fun showEmailError(showError: Boolean) {
        binding.edtEmailLogin.helperText =
            if (showError) getString(R.string.email_validation_error)
            else null
        binding.edtEmailLogin.editText?.setBackgroundResource(
            if (showError) R.drawable.bg_edt_login_error
            else R.drawable.bg_edt_login
        )
    }
}

class TwilioVoiceManager(private val context: Context) {

    private lateinit var accessToken: String;
    fun init(accessToken: String) {
        this.accessToken = accessToken
        Voice.register(
            accessToken,
            Voice.RegistrationChannel.FCM,
            "",
            registrationListener()
        );
    }

    private fun getFcmToken() {

    }
    private fun registrationListener(): RegistrationListener {
        return object : RegistrationListener {
            override fun onRegistered(accessToken: String, fcmToken: String) {
                Timber.tag(tag).d("Successfully registered FCM $fcmToken")
            }

            override fun onError(
                registrationException: RegistrationException,
                accessToken: String,
                fcmToken: String
            ) {
                val message = String.format("Registration Error:" +
                        " ${registrationException.message}" +
                        " ${registrationException.errorCode}"
                )
                Timber.tag(tag).d(message)
            }
        }
    }
    fun makeCall() {

        val params = mapOf("To" to "client:Tom1")
        val connectOptions: ConnectOptions = ConnectOptions.Builder(accessToken)
            .params(params)
            .build()

        Voice.connect(context, connectOptions, callListener())
    }

    val tag: String = "Twilio call listener"
    private fun callListener(): Call.Listener {
        return object : Call.Listener {
            override fun onRinging(call: Call) {
                Timber.tag(tag).d("Ringing")
            }

            override fun onConnectFailure(call: Call, error: CallException) {
                Timber.tag(tag).d( "Connect failure")
            }

            override fun onConnected(call: Call) {
                Timber.tag(tag).d( "Connected")
            }

            override fun onReconnecting(call: Call, callException: CallException) {
                Timber.tag(tag).d( "Reconnecting")
            }

            override fun onReconnected(call: Call) {
                Timber.tag(tag).d( "Reconnected")
            }

            override fun onDisconnected(call: Call, error: CallException?) {
                Timber.tag(tag).d( "Disconnected")
            }
        }
    }

}