package com.taf.waf

import android.Manifest
import android.app.Activity
import android.content.Intent
import android.content.pm.PackageManager
import android.net.Uri
import android.os.Bundle
import android.provider.MediaStore
import android.widget.Button
import android.widget.EditText
import android.widget.Spinner
import android.widget.TextView
import android.widget.Toast
import androidx.activity.result.ActivityResultLauncher
import androidx.activity.result.contract.ActivityResultContracts
import androidx.appcompat.app.AlertDialog
import androidx.appcompat.app.AppCompatActivity
import androidx.core.app.ActivityCompat
import androidx.core.content.ContextCompat
import androidx.core.content.FileProvider
import androidx.lifecycle.lifecycleScope
import com.google.android.gms.location.LocationServices
import com.taf.waf.BuildConfig
import kotlinx.coroutines.launch
import java.io.File

class ReportOhsIncidentActivity : AppCompatActivity() {
    private lateinit var repo: IncidentRepository
    private lateinit var cameraLauncher: ActivityResultLauncher<Intent>
    private lateinit var galleryLauncher: ActivityResultLauncher<Intent>
    private val imageFiles = mutableListOf<File>()
    private var currentPhoto: File? = null
    private var gps: String? = null
    private val locationClient by lazy { LocationServices.getFusedLocationProviderClient(this) }

    companion object {
        private const val REQ_LOCATION = 100
        private const val REQ_CAMERA = 101
        private const val REQ_GALLERY = 102
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_report_ohs_incident)
        repo = IncidentRepository(this)

        val takePhotoBtn = findViewById<Button>(R.id.takePhotoBtn)
        val galleryBtn = findViewById<Button>(R.id.galleryBtn)
        val gpsBtn = findViewById<Button>(R.id.gpsButton)
        val submitBtn = findViewById<Button>(R.id.submitBtn)

        cameraLauncher = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { result ->
            if (result.resultCode == Activity.RESULT_OK) {
                currentPhoto?.let { addImageFile(it) }
            }
        }

        galleryLauncher = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { result ->
            if (result.resultCode == Activity.RESULT_OK) {
                val uri: Uri? = result.data?.data
                if (uri != null) {
                    val file = createImageFile()
                    contentResolver.openInputStream(uri)?.use { input ->
                        file.outputStream().use { input.copyTo(it) }
                    }
                    addImageFile(file)
                }
            }
        }

        takePhotoBtn.setOnClickListener { checkCameraPermission() }
        galleryBtn.setOnClickListener { checkGalleryPermission() }
        gpsBtn.setOnClickListener { checkLocationPermission() }
        submitBtn.setOnClickListener { submit() }
    }

    private fun checkLocationPermission() {
        if (ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED) {
            fetchLocation()
        } else {
            if (ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.ACCESS_FINE_LOCATION)) {
                showRationale("Location access is required to attach GPS coordinates.") {
                    ActivityCompat.requestPermissions(this, arrayOf(Manifest.permission.ACCESS_FINE_LOCATION), REQ_LOCATION)
                }
            } else {
                ActivityCompat.requestPermissions(this, arrayOf(Manifest.permission.ACCESS_FINE_LOCATION), REQ_LOCATION)
            }
        }
    }

    private fun checkCameraPermission() {
        if (ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED) {
            openCamera()
        } else {
            if (ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.CAMERA)) {
                showRationale("Camera access is required to take photos.") {
                    ActivityCompat.requestPermissions(this, arrayOf(Manifest.permission.CAMERA), REQ_CAMERA)
                }
            } else {
                ActivityCompat.requestPermissions(this, arrayOf(Manifest.permission.CAMERA), REQ_CAMERA)
            }
        }
    }

    private fun checkGalleryPermission() {
        if (ContextCompat.checkSelfPermission(this, Manifest.permission.READ_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED) {
            openGallery()
        } else {
            if (ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.READ_EXTERNAL_STORAGE)) {
                showRationale("Storage access is required to select images.") {
                    ActivityCompat.requestPermissions(this, arrayOf(Manifest.permission.READ_EXTERNAL_STORAGE), REQ_GALLERY)
                }
            } else {
                ActivityCompat.requestPermissions(this, arrayOf(Manifest.permission.READ_EXTERNAL_STORAGE), REQ_GALLERY)
            }
        }
    }

    private fun openCamera() {
        val file = createImageFile()
        currentPhoto = file
        val uri = FileProvider.getUriForFile(this, "${BuildConfig.APPLICATION_ID}.fileprovider", file)
        val intent = Intent(MediaStore.ACTION_IMAGE_CAPTURE).apply {
            putExtra(MediaStore.EXTRA_OUTPUT, uri)
        }
        cameraLauncher.launch(intent)
    }

    private fun openGallery() {
        val intent = Intent(Intent.ACTION_PICK).apply { type = "image/*" }
        galleryLauncher.launch(intent)
    }

    private fun fetchLocation() {
        locationClient.lastLocation.addOnSuccessListener { loc ->
            gps = loc?.let { "${it.latitude},${it.longitude}" }
            findViewById<TextView>(R.id.gpsLabel).text = gps ?: "GPS not captured"
        }
    }

    private fun showRationale(message: String, onPositive: () -> Unit = {}) {
        AlertDialog.Builder(this)
            .setMessage(message)
            .setPositiveButton("OK") { _, _ -> onPositive() }
            .setNegativeButton("Cancel", null)
            .show()
    }

    override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<out String>, grantResults: IntArray) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults)
        if (grantResults.isNotEmpty() && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
            when (requestCode) {
                REQ_LOCATION -> fetchLocation()
                REQ_CAMERA -> openCamera()
                REQ_GALLERY -> openGallery()
            }
        } else {
            when (requestCode) {
                REQ_LOCATION -> showRationale("Location permission denied.")
                REQ_CAMERA -> showRationale("Camera permission denied.")
                REQ_GALLERY -> showRationale("Storage permission denied.")
            }
        }
    }

    private fun addImageFile(file: File) {
        imageFiles.add(file)
        findViewById<TextView>(R.id.attachmentsLabel).text = "Images: ${imageFiles.size}"
    }

    private fun createImageFile(): File {
        val dir = File(cacheDir, "images")
        if (!dir.exists()) dir.mkdirs()
        return File.createTempFile("img_", ".jpg", dir)
    }

    private fun submit() {
        val type = findViewById<Spinner>(R.id.incidentTypeInput).selectedItem.toString()
        val locText = findViewById<Spinner>(R.id.locationInput).selectedItem.toString()
        val desc = findViewById<EditText>(R.id.descriptionInput).text.toString()
        val notes = findViewById<EditText>(R.id.notesInput).text.toString().takeIf { it.isNotBlank() }

        val data = mutableMapOf<String, Any>(
            "incident_type" to type,
            "location" to locText,
            "description" to desc
        )
        notes?.let { data["notes"] = it }
        gps?.let { data["gps"] = it }

        lifecycleScope.launch {
            val success = repo.submitOhsIncident(data, imageFiles)
            if (success) {
                Toast.makeText(this@ReportOhsIncidentActivity, "Incident submitted", Toast.LENGTH_SHORT).show()
                startActivity(Intent(this@ReportOhsIncidentActivity, MainActivity::class.java))
                finish()
            } else {
                Toast.makeText(this@ReportOhsIncidentActivity, "Submission failed", Toast.LENGTH_SHORT).show()
            }
        }
    }
}