package com.taf.waf

import android.Manifest
import android.app.Activity
import android.content.Intent
import android.content.SharedPreferences
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 kotlinx.coroutines.launch
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.MediaType.Companion.toMediaTypeOrNull
import okhttp3.MultipartBody
import okhttp3.OkHttpClient
import okhttp3.RequestBody.Companion.asRequestBody
import okhttp3.RequestBody.Companion.toRequestBody
import org.json.JSONObject
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory
import java.io.File

class ReportSafetyIncidentActivity : AppCompatActivity() {
    private lateinit var repo: IncidentRepository
    private lateinit var service: IncidentApiService
    private lateinit var prefs: SharedPreferences
    private lateinit var cameraLauncher: ActivityResultLauncher<Intent>
    private lateinit var galleryLauncher: ActivityResultLauncher<Intent>
    private val images = 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_safety_incident)

        repo = IncidentRepository(this)
        prefs = getSharedPreferences("auth", MODE_PRIVATE)

        val token = prefs.getString("token", null)
        val client = OkHttpClient.Builder()
            .addInterceptor { chain ->
                val req = chain.request().newBuilder()
                if (!token.isNullOrEmpty()) {
                    req.addHeader("Authorization", "Bearer $token")
                }
                chain.proceed(req.build())
            }
            .build()

        service = Retrofit.Builder()
            .baseUrl(ApiConfig.BASE_URL)
            .client(client)
            .addConverterFactory(GsonConverterFactory.create())
            .build()
            .create(IncidentApiService::class.java)

        checkLocationPermission()

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

        cameraLauncher = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { result ->
            if (result.resultCode == Activity.RESULT_OK) {
                currentPhoto?.let { addImage(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) }
                    }
                    addImage(file)
                }
            }
        }

        takePhotoBtn.setOnClickListener { checkCameraPermission() }
        galleryBtn.setOnClickListener { checkGalleryPermission() }
        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}" }
        }
    }

    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 addImage(file: File) {
        images.add(file)
        findViewById<TextView>(R.id.attachmentsLabel).text = "Images: ${images.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.incidentTypeSpinner).selectedItem.toString()
        val locText = findViewById<Spinner>(R.id.locationSpinner).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>(
            "incidentType" to type,
            "location" to locText,
            "description" to desc
        )
        gps?.let { data["gps"] = it }
        notes?.let { data["notes"] = it }

        val json = JSONObject(data as Map<*, *>).toString()
        val body = json.toRequestBody("application/json".toMediaType())
        val parts = images.map { file ->
            val req = file.asRequestBody("image/*".toMediaTypeOrNull())
            MultipartBody.Part.createFormData("files[]", file.name, req)
        }

        lifecycleScope.launch {
            try {
                val result = service.submitSafetyIncident(body, parts)
                if (result.status == "ok") {
                    Toast.makeText(this@ReportSafetyIncidentActivity, "Incident submitted", Toast.LENGTH_SHORT).show()
                    startActivity(Intent(this@ReportSafetyIncidentActivity, MainActivity::class.java))
                    finish()
                } else {
                    Toast.makeText(this@ReportSafetyIncidentActivity, "Submission failed", Toast.LENGTH_SHORT).show()
                }
            } catch (e: Exception) {
                repo.submitSafetyIncident(data, images)
                Toast.makeText(
                    this@ReportSafetyIncidentActivity,
                    "Saved offline. Will sync when connected.",
                    Toast.LENGTH_SHORT
                ).show()
                startActivity(Intent(this@ReportSafetyIncidentActivity, MainActivity::class.java))
                finish()
            }
        }
    }
}