package com.craigvg.lichun_android.ui.screens.activities

import androidx.compose.foundation.background
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.*
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.vector.ImageVector
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.unit.dp
import androidx.hilt.navigation.compose.hiltViewModel
import com.craigvg.lichun_android.R
import com.craigvg.lichun_android.domain.models.*
import com.craigvg.lichun_android.ui.screens.activities.components.*
import com.craigvg.lichun_android.ui.theme.AppColors
import com.craigvg.lichun_android.ui.theme.AppSpacing
import com.craigvg.lichun_android.ui.theme.AppTypography
import com.craigvg.lichun_android.viewmodel.GameStateViewModel
import com.craigvg.lichun_android.viewmodel.PlayerViewModel
import androidx.lifecycle.compose.collectAsStateWithLifecycle

/**
 * Activities screen - Browse and manage activities
 * Ported from iOS ActivityView.swift
 */
@Composable
fun ActivitiesScreen(
    playerViewModel: PlayerViewModel = hiltViewModel(),
    gameStateViewModel: GameStateViewModel = hiltViewModel(),
    onNavigateToActivityDetail: (String) -> Unit = {},
    onPerformActivity: () -> Unit = {}
) {
    val currentActivities by playerViewModel.currentActivities.collectAsStateWithLifecycle()
    val extracurriculars by playerViewModel.extracurriculars.collectAsStateWithLifecycle()
    val occupations by playerViewModel.occupations.collectAsStateWithLifecycle()
    val habits by playerViewModel.habits.collectAsStateWithLifecycle()
    val person by playerViewModel.person.collectAsStateWithLifecycle()

    val tooltipMessage = stringResource(R.string.tooltip_activities_intro)
    LaunchedEffect(Unit) {
        gameStateViewModel.showTooltipIfNeeded("activities_intro", tooltipMessage)
    }

    var selectedTab by remember { mutableStateOf(0) }
    val tabs = listOf("Current", "Jobs", "Activities", "Habits")

    Column(
        modifier = Modifier
            .fillMaxSize()
            .background(AppColors.background)
    ) {
        // Proactive-agency entry point: pick a player-initiated activity now.
        Button(
            onClick = onPerformActivity,
            modifier = Modifier
                .fillMaxWidth()
                .padding(horizontal = AppSpacing.md, vertical = AppSpacing.sm),
            shape = androidx.compose.foundation.shape.RoundedCornerShape(AppSpacing.cornerRadius),
            colors = ButtonDefaults.buttonColors(
                containerColor = AppColors.primary,
                contentColor = androidx.compose.ui.graphics.Color.White
            )
        ) {
            Icon(Icons.Default.Bolt, null, modifier = Modifier.size(18.dp))
            Spacer(modifier = Modifier.width(AppSpacing.xs))
            Text("Do an Activity Now", style = AppTypography.bodyBold)
        }

        TabRow(
            selectedTabIndex = selectedTab,
            containerColor = AppColors.surfaceElevated,
            contentColor = AppColors.primaryText
        ) {
            tabs.forEachIndexed { index, title ->
                Tab(
                    selected = selectedTab == index,
                    onClick = { selectedTab = index },
                    text = {
                        Text(
                            text = title,
                            style = AppTypography.captionBold,
                            color = if (selectedTab == index) AppColors.primary else AppColors.secondaryText
                        )
                    }
                )
            }
        }

        when (selectedTab) {
            0 -> CurrentActivitiesTab(currentActivities, onNavigateToActivityDetail)
            1 -> OccupationsTab(occupations, playerViewModel)
            2 -> ExtracurricularsTab(extracurriculars, playerViewModel)
            3 -> HabitsTab(habits, playerViewModel)
        }
    }
}

@Composable
private fun CurrentActivitiesTab(activities: List<Activity>, onActivityClick: (String) -> Unit) {
    if (activities.isEmpty()) {
        EmptyStateView(
            icon = Icons.Default.WorkOutline,
            message = "No active activities",
            submessage = "Browse jobs or activities to get started"
        )
    } else {
        LazyColumn(
            modifier = Modifier
                .fillMaxSize()
                .padding(AppSpacing.md),
            verticalArrangement = Arrangement.spacedBy(AppSpacing.sm)
        ) {
            items(activities) { activity ->
                ActivityButton(
                    activity = activity,
                    onClick = { onActivityClick(activity.id) }
                )
            }
        }
    }
}

@Composable
private fun OccupationsTab(occupations: List<OccupationClass>, playerViewModel: PlayerViewModel) {
    if (occupations.isEmpty()) {
        EmptyStateView(
            icon = Icons.Default.Work,
            message = "No jobs available",
            submessage = "Jobs will appear as you meet requirements"
        )
    } else {
        LazyColumn(
            modifier = Modifier
                .fillMaxSize()
                .padding(AppSpacing.md),
            verticalArrangement = Arrangement.spacedBy(AppSpacing.sm)
        ) {
            items(occupations) { occupation ->
                OccupationCard(
                    occupation = occupation,
                    onApply = { playerViewModel.applyForJob(occupation.id) }
                )
            }
        }
    }
}

@Composable
private fun ExtracurricularsTab(extracurriculars: List<ExtracurricularClass>, playerViewModel: PlayerViewModel) {
    if (extracurriculars.isEmpty()) {
        EmptyStateView(
            icon = Icons.Default.Sports,
            message = "No activities available",
            submessage = "Check back later for available activities"
        )
    } else {
        LazyColumn(
            modifier = Modifier
                .fillMaxSize()
                .padding(AppSpacing.md),
            verticalArrangement = Arrangement.spacedBy(AppSpacing.sm)
        ) {
            items(extracurriculars) { extracurricular ->
                ExtracurricularCard(
                    extracurricular = extracurricular,
                    onEnroll = { playerViewModel.enrollInActivity(extracurricular.id) }
                )
            }
        }
    }
}

@Composable
private fun HabitsTab(habits: List<Habit>, playerViewModel: PlayerViewModel) {
    if (habits.isEmpty()) {
        EmptyStateView(
            icon = Icons.Default.CheckCircle,
            message = "No habits",
            submessage = "You're habit-free!"
        )
    } else {
        LazyColumn(
            modifier = Modifier
                .fillMaxSize()
                .padding(AppSpacing.md),
            verticalArrangement = Arrangement.spacedBy(AppSpacing.sm)
        ) {
            items(habits) { habit ->
                HabitRow(
                    habit = habit,
                    onQuit = { playerViewModel.quitHabit(habit.name) },
                    onStopQuit = { playerViewModel.stopQuitHabit(habit.name) }
                )
            }
        }
    }
}

@Composable
fun EmptyStateView(
    icon: ImageVector,
    message: String,
    submessage: String
) {
    Box(
        modifier = Modifier.fillMaxSize(),
        contentAlignment = Alignment.Center
    ) {
        Column(
            horizontalAlignment = Alignment.CenterHorizontally,
            modifier = Modifier.padding(AppSpacing.xl)
        ) {
            Icon(
                imageVector = icon,
                contentDescription = null,
                tint = AppColors.disabledText,
                modifier = Modifier.size(64.dp)
            )
            Spacer(modifier = Modifier.height(AppSpacing.md))
            Text(
                text = message,
                style = AppTypography.headline,
                color = AppColors.secondaryText,
                textAlign = TextAlign.Center
            )
            Spacer(modifier = Modifier.height(AppSpacing.xs))
            Text(
                text = submessage,
                style = AppTypography.body,
                color = AppColors.disabledText,
                textAlign = TextAlign.Center
            )
        }
    }
}