package com.shukria.kiosklauncher.ui

import android.content.IntentFilter
import android.os.Bundle
import android.os.Environment
import android.util.Log
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.Button
import android.widget.ProgressBar
import android.widget.TextView
import android.widget.Toast
import androidx.fragment.app.Fragment
import androidx.recyclerview.widget.LinearLayoutManager
import androidx.recyclerview.widget.RecyclerView
import androidx.swiperefreshlayout.widget.SwipeRefreshLayout
import com.shukria.kiosklauncher.R
import com.shukria.kiosklauncher.adapter.MarketplaceAdapter
import com.shukria.kiosklauncher.model.AppCatalogItem
import com.shukria.kiosklauncher.network.RetrofitClient
import com.shukria.kiosklauncher.receiver.PackageStateReceiver
import com.shukria.kiosklauncher.util.MQTTConfig
import com.shukria.kiosklauncher.util.YSDKManager
import okhttp3.Request
import retrofit2.Call
import retrofit2.Callback
import java.io.File

class MarketplaceFragment : Fragment() {

    private val TAG = "MarketplaceFragment"

    private lateinit var recyclerView: RecyclerView
    private lateinit var swipeRefresh: SwipeRefreshLayout
    private lateinit var progressBar: ProgressBar
    private lateinit var tvEmpty: TextView

    private var catalogItems: List<AppCatalogItem> = emptyList()
    private val installedPackages = mutableSetOf<String>()

    private val packageReceiver = PackageStateReceiver { pkg, installed ->
        if (installed) {
            installedPackages.add(pkg)
            requireActivity().runOnUiThread {
                Toast.makeText(requireContext(), "Installed successfully: $pkg", Toast.LENGTH_LONG).show()
                Log.i(TAG, "Install confirmed by system: $pkg")
            }
        } else {
            installedPackages.remove(pkg)
            Log.i(TAG, "Package removed: $pkg")
        }
        refreshAdapter()
    }

    override fun onCreateView(
        inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?
    ): View? {
        val view = inflater.inflate(R.layout.fragment_marketplace, container, false)

        recyclerView = view.findViewById(R.id.rv_marketplace)
        swipeRefresh = view.findViewById(R.id.swipe_refresh)
        progressBar = view.findViewById(R.id.progress_bar)
        tvEmpty = view.findViewById(R.id.tv_empty)

        recyclerView.layoutManager = LinearLayoutManager(requireContext())

        view.findViewById<Button>(R.id.btn_back).setOnClickListener {
            requireActivity().supportFragmentManager.popBackStack()
        }

        swipeRefresh.setOnRefreshListener { loadCatalog() }

        seedInstalledPackages()
        loadCatalog()

        return view
    }

    override fun onStart() {
        super.onStart()
        val filter = IntentFilter().apply {
            addAction(android.content.Intent.ACTION_PACKAGE_ADDED)
            addAction(android.content.Intent.ACTION_PACKAGE_REPLACED)
            addAction(android.content.Intent.ACTION_PACKAGE_REMOVED)
            addDataScheme("package")
        }
        requireContext().registerReceiver(packageReceiver, filter)
    }

    override fun onStop() {
        super.onStop()
        requireContext().unregisterReceiver(packageReceiver)
    }

    private fun seedInstalledPackages() {
        requireContext().packageManager.getInstalledPackages(0)
            .mapTo(installedPackages) { it.packageName }
    }

    private fun loadCatalog() {
        progressBar.visibility = View.VISIBLE
        tvEmpty.visibility = View.GONE

        RetrofitClient.marketplaceApi
            .getApps(vendor = MQTTConfig.VENDOR, model = MQTTConfig.MODEL)
            .enqueue(object : Callback<List<AppCatalogItem>> {
                override fun onResponse(call: Call<List<AppCatalogItem>>, response: retrofit2.Response<List<AppCatalogItem>>) {
                    progressBar.visibility = View.GONE
                    swipeRefresh.isRefreshing = false
                    if (response.isSuccessful) {
                        catalogItems = response.body() ?: emptyList()
                        refreshAdapter()
                        tvEmpty.visibility = if (catalogItems.isEmpty()) View.VISIBLE else View.GONE
                    } else {
                        Log.e(TAG, "Catalog fetch failed: ${response.code()}")
                        showError("Failed to load catalog (${response.code()})")
                    }
                }

                override fun onFailure(call: Call<List<AppCatalogItem>>, t: Throwable) {
                    progressBar.visibility = View.GONE
                    swipeRefresh.isRefreshing = false
                    Log.e(TAG, "Catalog fetch error: ${t.message}")
                    showError("Network error: ${t.message}")
                }
            })
    }

    private fun refreshAdapter() {
        recyclerView.adapter = MarketplaceAdapter(
            context = requireContext(),
            items = catalogItems,
            installedPackages = installedPackages.toSet(),
            onInstall = ::startDownload,
            onUninstall = ::uninstallApp
        )
    }

    // -------------------------------------------------------------------------
    // Download + install
    // -------------------------------------------------------------------------

    fun startDownload(item: AppCatalogItem) {
        val destDir = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS)
        val destFile = File(destDir, "ota/${item.packageName}-${item.appVersion}.apk")
        destFile.parentFile?.mkdirs()

        Log.i(TAG, "Starting download: ${item.downloadUrl} → ${destFile.absolutePath}")
        Toast.makeText(requireContext(), "Downloading ${item.displayName}…", Toast.LENGTH_SHORT).show()

        Thread {
            try {
                val request = Request.Builder().url(item.downloadUrl).build()
                val response = RetrofitClient.okHttpClient.newCall(request).execute()
                if (!response.isSuccessful) {
                    Log.e(TAG, "HTTP ${response.code()} downloading ${item.packageName}")
                    requireActivity().runOnUiThread { showError("Download failed: HTTP ${response.code()}") }
                    return@Thread
                }
                response.body()?.byteStream()?.use { input ->
                    destFile.outputStream().use { output -> input.copyTo(output) }
                } ?: run {
                    requireActivity().runOnUiThread { showError("Download failed: empty body") }
                    return@Thread
                }
                Log.i(TAG, "Download complete: ${destFile.absolutePath} (${destFile.length()} bytes)")
                requireActivity().runOnUiThread { installApk(item, destFile.absolutePath) }
            } catch (e: Exception) {
                Log.e(TAG, "Download error for ${item.packageName}: ${e.message}")
                requireActivity().runOnUiThread { showError("Download error: ${e.message}") }
            }
        }.start()
    }

    private fun installApk(item: AppCatalogItem, apkPath: String) {
        Log.i(TAG, "Installing ${item.packageName} from $apkPath")
        val ok = YSDKManager.installApp(apkPath, item.packageName)
        if (!ok) {
            Log.w(TAG, "YSDK not connected — falling back to PackageInstaller")
            installViaPackageInstaller(apkPath, item.packageName)
        }
    }

    private fun installViaPackageInstaller(apkPath: String, packageName: String) {
        Log.i(TAG, "PackageInstaller fallback for $packageName at $apkPath")
        Toast.makeText(requireContext(), "Initiating install for $packageName", Toast.LENGTH_SHORT).show()
    }

    private fun uninstallApp(item: AppCatalogItem) {
        Log.i(TAG, "Uninstall requested for ${item.packageName}")
        if (!YSDKManager.uninstallApp(item.packageName)) {
            Toast.makeText(requireContext(), "YSDK not connected — cannot uninstall", Toast.LENGTH_SHORT).show()
        }
    }

    private fun showError(msg: String) {
        if (isAdded) {
            Toast.makeText(requireContext(), msg, Toast.LENGTH_LONG).show()
        }
    }

    companion object {
        fun newInstance() = MarketplaceFragment()
    }
}