package com.example

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.layout.*
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import androidx.lifecycle.viewmodel.compose.viewModel
import com.example.data.local.AppDatabase
import com.example.data.model.AppLanguage
import com.example.data.model.BottomTab
import com.example.data.model.Screen
import com.example.data.repository.SatarkRepository
import com.example.ui.components.AppHeader
import com.example.ui.components.BottomNavBar
import com.example.ui.screens.*
import com.example.ui.theme.MyApplicationTheme
import com.example.ui.viewmodel.SatarkViewModel
import com.example.ui.viewmodel.SatarkViewModelFactory

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()

        val database = AppDatabase.getDatabase(applicationContext)
        val repository = SatarkRepository(database)

        setContent {
            MyApplicationTheme {
                val viewModel: SatarkViewModel = viewModel(
                    factory = SatarkViewModelFactory(repository)
                )
                val uiState by viewModel.uiState.collectAsStateWithLifecycle()

                SatarkApp(
                    uiState = uiState,
                    viewModel = viewModel
                )
            }
        }
    }
}

@Composable
fun SatarkApp(
    uiState: com.example.ui.viewmodel.UiState,
    viewModel: SatarkViewModel
) {
    val currentScreen = uiState.currentScreen
    val lang = uiState.currentLanguage

    // Full screen overlays that do not show header or bottom bar
    val isFullscreen = currentScreen == Screen.SPLASH || 
                       currentScreen == Screen.ONBOARDING || 
                       currentScreen == Screen.AUTH

    // Map screen to bottom tab if applicable
    val currentBottomTab = when (currentScreen) {
        Screen.HOME -> BottomTab.HOME
        Screen.SEARCH -> BottomTab.SEARCH
        Screen.REPORT_FORM, Screen.PROOF_UPLOAD -> BottomTab.REPORT
        Screen.PUBLIC_WARNINGS -> BottomTab.ALERTS
        Screen.PROFILE -> BottomTab.PROFILE
        else -> BottomTab.HOME
    }

    // Title and back button settings
    val (headerTitle, showBack) = when (currentScreen) {
        Screen.HOME -> Pair(if (lang == AppLanguage.BN) "সতর্ক বাংলাদেশ" else "Satark BD", false)
        Screen.SEARCH -> Pair(if (lang == AppLanguage.BN) "প্রতিষ্ঠান যাচাই" else "Company Verification", false)
        Screen.COMPANY_PROFILE -> Pair(if (lang == AppLanguage.BN) "কোম্পানি প্রোফাইল" else "Company Profile", true)
        Screen.REPORT_FORM -> Pair(if (lang == AppLanguage.BN) "অভিযোগ দায়ের (১/২)" else "Report Fraud (1/2)", true)
        Screen.PROOF_UPLOAD -> Pair(if (lang == AppLanguage.BN) "প্রমাণপত্র আপলোড (২/২)" else "Proof Upload (2/2)", true)
        Screen.TRACKING -> Pair(if (lang == AppLanguage.BN) "অভিযোগ ট্র্যাকিং" else "Track Report", true)
        Screen.PUBLIC_WARNINGS -> Pair(if (lang == AppLanguage.BN) "পাবলিক সতর্কতা" else "Public Warnings", false)
        Screen.ADMIN_PANEL -> Pair(if (lang == AppLanguage.BN) "অ্যাডমিন রিভিউ প্যানেল" else "Admin Review Panel", true)
        Screen.NOTIFICATIONS -> Pair(if (lang == AppLanguage.BN) "বিজ্ঞপ্তি ও নোটিফিকেশন" else "Notifications", true)
        Screen.PROFILE -> Pair(if (lang == AppLanguage.BN) "আমার প্রোফাইল ও সেটিংস" else "Profile & Settings", false)
        else -> Pair("Satark BD", false)
    }

    Scaffold(
        topBar = {
            if (!isFullscreen) {
                AppHeader(
                    title = headerTitle,
                    subtitle = if (currentScreen == Screen.HOME) {
                        if (lang == AppLanguage.BN) "সাইবার ও আর্থিক প্রতারণা প্রতিরোধ প্ল্যাটফর্ম" else "BD Fraud Prevention & Verification"
                    } else null,
                    currentLang = lang,
                    onToggleLang = { viewModel.toggleLanguage() },
                    onOpenNotifications = { viewModel.navigateTo(Screen.NOTIFICATIONS) },
                    unreadNotifCount = uiState.unreadNotificationCount,
                    showBackButton = showBack,
                    onBack = { viewModel.navigateBack() },
                    isAdminMode = uiState.isAdminMode
                )
            }
        },
        bottomBar = {
            if (!isFullscreen && currentScreen != Screen.ADMIN_PANEL && currentScreen != Screen.COMPANY_PROFILE) {
                BottomNavBar(
                    selectedTab = currentBottomTab,
                    onTabSelected = { tab ->
                        when (tab) {
                            BottomTab.HOME -> viewModel.navigateTo(Screen.HOME)
                            BottomTab.SEARCH -> viewModel.navigateTo(Screen.SEARCH)
                            BottomTab.REPORT -> viewModel.startReportWithEntity("")
                            BottomTab.ALERTS -> viewModel.navigateTo(Screen.PUBLIC_WARNINGS)
                            BottomTab.PROFILE -> viewModel.navigateTo(Screen.PROFILE)
                        }
                    },
                    lang = lang
                )
            }
        },
        modifier = Modifier.fillMaxSize()
    ) { innerPadding ->
        Box(
            modifier = Modifier
                .fillMaxSize()
                .padding(innerPadding)
        ) {
            when (currentScreen) {
                Screen.SPLASH -> {
                    SplashScreen(
                        lang = lang,
                        onToggleLang = { viewModel.toggleLanguage() },
                        onContinue = { viewModel.completeSplash() }
                    )
                }

                Screen.ONBOARDING -> {
                    OnboardingScreen(
                        lang = lang,
                        onFinish = { viewModel.completeOnboarding() }
                    )
                }

                Screen.AUTH -> {
                    AuthScreen(
                        lang = lang,
                        onAuthSuccess = { name, phone, isNid ->
                            viewModel.setAuthenticatedUser(name, phone, isNid)
                        }
                    )
                }

                Screen.HOME -> {
                    HomeScreen(
                        companies = uiState.companies,
                        reports = uiState.reports,
                        warnings = uiState.publicWarnings,
                        lang = lang,
                        onNavigateToSearch = { query ->
                            if (query != null) viewModel.setSearchQuery(query)
                            viewModel.navigateTo(Screen.SEARCH)
                        },
                        onStartReport = { viewModel.startReportWithEntity("") },
                        onSelectCompany = { companyId ->
                            viewModel.selectCompany(companyId)
                        },
                        onSelectWarning = { warningId ->
                            viewModel.selectWarning(warningId)
                        },
                        onSelectReportTrack = { reportId ->
                            viewModel.setSearchTrackingId(reportId)
                            viewModel.navigateTo(Screen.TRACKING)
                        },
                        onOpenAdmin = { viewModel.navigateTo(Screen.ADMIN_PANEL) },
                        isAdminMode = uiState.isAdminMode
                    )
                }

                Screen.SEARCH -> {
                    SearchScreen(
                        companies = uiState.companies,
                        searchQuery = uiState.searchQuery,
                        onSearchQueryChange = { viewModel.setSearchQuery(it) },
                        selectedCategory = uiState.selectedCategoryFilter,
                        onSelectCategory = { viewModel.setCategoryFilter(it) },
                        selectedDivision = uiState.selectedDivisionFilter,
                        onSelectDivision = { viewModel.setDivisionFilter(it) },
                        selectedRisk = uiState.selectedRiskFilter,
                        onSelectRisk = { viewModel.setRiskFilter(it) },
                        lang = lang,
                        onSelectCompany = { companyId ->
                            viewModel.selectCompany(companyId)
                        },
                        onStartReportWithEntity = { entityName ->
                            viewModel.startReportWithEntity(entityName)
                        }
                    )
                }

                Screen.COMPANY_PROFILE -> {
                    CompanyProfileScreen(
                        company = uiState.selectedCompany,
                        lang = lang,
                        onBack = { viewModel.navigateBack() },
                        onReportCompany = { entityName ->
                            viewModel.startReportWithEntity(entityName)
                        }
                    )
                }

                Screen.REPORT_FORM -> {
                    ReportFormScreen(
                        targetName = uiState.reportTargetName,
                        contactInfo = uiState.reportContactInfo,
                        category = uiState.reportCategory,
                        city = uiState.reportCity,
                        description = uiState.reportDescription,
                        moneyLost = uiState.reportMoneyLost,
                        incidentDate = uiState.reportIncidentDate,
                        isAnonymous = uiState.reportIsAnonymous,
                        reporterName = uiState.userName,
                        reporterPhone = uiState.userPhone,
                        errors = uiState.reportErrors,
                        lang = lang,
                        onFieldChange = { targetName, contactInfo, category, city, description, moneyLost, isAnon, rName, rPhone ->
                            viewModel.updateReportFields(
                                targetName = targetName,
                                contactInfo = contactInfo,
                                category = category,
                                city = city,
                                description = description,
                                moneyLost = moneyLost,
                                isAnonymous = isAnon,
                                reporterName = rName,
                                reporterPhone = rPhone
                            )
                        },
                        onProceedToProof = {
                            viewModel.proceedToProofUpload()
                        },
                        onCancel = {
                            viewModel.resetReportForm()
                            viewModel.navigateBack()
                        }
                    )
                }

                Screen.PROOF_UPLOAD -> {
                    ProofUploadScreen(
                        step = uiState.reportStep,
                        evidenceList = uiState.evidenceList,
                        isSubmitting = uiState.isSubmittingReport,
                        submittedReportId = uiState.submittedReportId,
                        lang = lang,
                        onAddSampleEvidence = { type, title, note ->
                            viewModel.addEvidence(type, title, note)
                        },
                        onRemoveEvidence = { id ->
                            viewModel.removeEvidence(id)
                        },
                        onSubmitReport = {
                            viewModel.submitReport()
                        },
                        onBackToStep1 = {
                            viewModel.backToReportStep1()
                        },
                        onViewTracking = { reportId ->
                            viewModel.resetReportForm()
                            viewModel.setSearchTrackingId(reportId)
                            viewModel.navigateTo(Screen.TRACKING)
                        },
                        onFinish = {
                            viewModel.resetReportForm()
                            viewModel.navigateTo(Screen.HOME)
                        }
                    )
                }

                Screen.TRACKING -> {
                    ReportTrackingScreen(
                        reports = uiState.reports,
                        searchTrackingId = uiState.searchTrackingId,
                        onSearchTrackingIdChange = { viewModel.setSearchTrackingId(it) },
                        lang = lang,
                        onBack = { viewModel.navigateTo(Screen.HOME) },
                        onOpenHelpline = { viewModel.navigateTo(Screen.PROFILE) }
                    )
                }

                Screen.PUBLIC_WARNINGS -> {
                    PublicWarningsScreen(
                        warnings = uiState.publicWarnings,
                        selectedWarningId = uiState.selectedWarningId,
                        lang = lang,
                        onSelectWarning = { viewModel.selectWarning(it) },
                        onStartReportForWarning = { entityName ->
                            viewModel.startReportWithEntity(entityName)
                        }
                    )
                }

                Screen.ADMIN_PANEL -> {
                    AdminPanelScreen(
                        reports = uiState.reports,
                        selectedTab = uiState.adminSelectedTab,
                        onTabChange = { viewModel.setAdminTab(it) },
                        reviewingReportId = uiState.adminReviewingReportId,
                        onSelectReportForReview = { viewModel.selectReportForAdminReview(it) },
                        adminNotesInput = uiState.adminNotesInput,
                        onAdminNotesChange = { viewModel.setAdminNotesInput(it) },
                        onApproveReport = { reportId, publishWarning ->
                            viewModel.approveReport(reportId, publishWarning)
                        },
                        onRejectReport = { reportId ->
                            viewModel.rejectReport(reportId)
                        },
                        lang = lang,
                        onBack = { viewModel.navigateBack() }
                    )
                }

                Screen.NOTIFICATIONS -> {
                    NotificationsScreen(
                        notifications = uiState.notifications,
                        lang = lang,
                        onNotificationClick = { notif ->
                            viewModel.markNotificationRead(notif.id)
                            if (notif.actionRoute != null) {
                                when (notif.actionRoute) {
                                    "PUBLIC_WARNINGS" -> viewModel.navigateTo(Screen.PUBLIC_WARNINGS)
                                    "TRACKING" -> viewModel.navigateTo(Screen.TRACKING)
                                    else -> viewModel.navigateTo(Screen.HOME)
                                }
                            }
                        }
                    )
                }

                Screen.PROFILE -> {
                    ProfileSettingsScreen(
                        userName = uiState.userName,
                        userPhone = uiState.userPhone,
                        isNidVerified = uiState.isNidVerified,
                        reportCount = uiState.reports.count { it.reporterPhone == uiState.userPhone || it.reporterName == uiState.userName },
                        isAdminMode = uiState.isAdminMode,
                        onToggleAdminMode = { viewModel.toggleAdminMode() },
                        lang = lang,
                        onToggleLanguage = { viewModel.toggleLanguage() },
                        onLogout = { viewModel.logout() }
                    )
                }
            }
        }
    }
}