package com.bitchat.android.ui

import androidx.compose.foundation.background
import androidx.compose.foundation.clickable
import androidx.compose.foundation.isSystemInDarkTheme
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.foundation.lazy.rememberLazyListState
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.ArrowUpward
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.res.pluralStringResource
import com.bitchat.android.R
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import com.bitchat.android.geohash.GeohashChannelLevel
import com.bitchat.android.geohash.LocationChannelManager
import com.bitchat.android.nostr.LocationNotesManager
import java.text.SimpleDateFormat
import java.util.*
import java.util.Calendar

/**
 * Location Notes Sheet - EXACT iOS UI match for bitchat
 * Matches iOS LocationNotesView.swift exactly in style, colors, fonts, and text
 */
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun LocationNotesSheet(
    geohash: String,
    locationName: String?,
    nickname: String?,
    onDismiss: () -> Unit,
    modifier: Modifier = Modifier
) {
    val context = LocalContext.current
    val isDark = isSystemInDarkTheme()
    
    // iOS color scheme
    val backgroundColor = if (isDark) Color.Black else Color.White
    val accentGreen = if (isDark) Color.Green else Color(0xFF008000) // dark: green, light: dark green (0, 0.5, 0)
    
    // Managers
    val notesManager = remember { LocationNotesManager.getInstance() }
    val locationManager = remember { LocationChannelManager.getInstance(context) }
    
    // State
    val notes by notesManager.notes.collectAsStateWithLifecycle()
    val state by notesManager.state.collectAsStateWithLifecycle(LocationNotesManager.State.IDLE)
    val errorMessage by notesManager.errorMessage.collectAsStateWithLifecycle()
    val initialLoadComplete by notesManager.initialLoadComplete.collectAsStateWithLifecycle(false)
    
    // SIMPLIFIED: Get count directly from notes list (no separate counter needed)
    val count = notes.size
    
    // Get location name (building or block) - matches iOS locationNames lookup
    val locationNames by locationManager.locationNames.collectAsStateWithLifecycle()
    val displayLocationName = locationNames[GeohashChannelLevel.BUILDING]?.takeIf { it.isNotEmpty() }
        ?: locationNames[GeohashChannelLevel.BLOCK]?.takeIf { it.isNotEmpty() }
    
    // Input field state
    var draft by remember { mutableStateOf("") }
    val sendButtonEnabled = draft.trim().isNotEmpty() && state != LocationNotesManager.State.NO_RELAYS
    
    // Scroll state
    val listState = rememberLazyListState()
    
    // Effect to set geohash when sheet opens
    LaunchedEffect(geohash) {
        notesManager.setGeohash(geohash)
    }
    
    // Cleanup when sheet closes
    DisposableEffect(Unit) {
        onDispose {
            notesManager.cancel()
        }
    }
    
    ModalBottomSheet(
        onDismissRequest = onDismiss,
        modifier = modifier,
        sheetState = rememberModalBottomSheetState(skipPartiallyExpanded = true),
        containerColor = backgroundColor,
        contentColor = if (isDark) Color.White else Color.Black
    ) {
        Column(
            modifier = Modifier
                .fillMaxWidth()
                .fillMaxHeight(0.9f)
        ) {
            // Header section (matches iOS headerSection)
            LocationNotesHeader(
                geohash = geohash,
                count = count,
                locationName = displayLocationName,
                state = state,
                accentGreen = accentGreen,
                backgroundColor = backgroundColor,
                onClose = onDismiss
            )
            
            // ScrollView with notes content
            Box(
                modifier = Modifier
                    .weight(1f)
                    .fillMaxWidth()
                    .background(backgroundColor)
            ) {
                LazyColumn(
                    state = listState,
                    modifier = Modifier.fillMaxSize(),
                    contentPadding = PaddingValues(horizontal = 16.dp, vertical = 8.dp)
                ) {
                    // Notes content (matches iOS notesContent)
                    when {
                        state == LocationNotesManager.State.NO_RELAYS -> {
                            item {
                                NoRelaysRow(
                                    onRetry = { notesManager.refresh() }
                                )
                            }
                        }
                        state == LocationNotesManager.State.LOADING && !initialLoadComplete -> {
                            item {
                                LoadingRow()
                            }
                        }
                        notes.isEmpty() -> {
                            item {
                                EmptyRow()
                            }
                        }
                        else -> {
                            items(notes, key = { it.id }) { note ->
                                NoteRow(note = note)
                                Spacer(modifier = Modifier.height(12.dp))
                            }
                        }
                    }
                    
                    // Error row (matches iOS errorRow)
                    errorMessage?.let { error ->
                        if (state != LocationNotesManager.State.NO_RELAYS) {
                            item {
                                ErrorRow(
                                    message = error,
                                    onDismiss = { notesManager.clearError() }
                                )
                            }
                        }
                    }
                }
            }
            
            // Divider before input (matches iOS overlay)
            HorizontalDivider(
                modifier = Modifier.fillMaxWidth(),
                color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.2f),
                thickness = 1.dp
            )
            
            // Input section (matches iOS inputSection)
            LocationNotesInputSection(
                draft = draft,
                onDraftChange = { draft = it },
                sendButtonEnabled = sendButtonEnabled,
                accentGreen = accentGreen,
                backgroundColor = backgroundColor,
                onSend = {
                    val content = draft.trim()
                    if (content.isNotEmpty()) {
                        notesManager.send(content, nickname)
                        draft = ""
                    }
                }
            )
        }
    }
}

/**
 * Header section - matches iOS headerSection exactly
 * Shows: "#geohash • X notes", location name, description, and close button
 */
@Composable
private fun LocationNotesHeader(
    geohash: String,
    count: Int,
    locationName: String?,
    state: LocationNotesManager.State,
    accentGreen: Color,
    backgroundColor: Color,
    onClose: () -> Unit
) {
    Column(
        modifier = Modifier
            .fillMaxWidth()
            .background(backgroundColor)
            .padding(horizontal = 16.dp)
            .padding(top = 16.dp, bottom = 12.dp)
    ) {
        // Title row with close button
        Row(
            modifier = Modifier.fillMaxWidth(),
            horizontalArrangement = Arrangement.SpaceBetween,
            verticalAlignment = Alignment.CenterVertically
        ) {
            // Localized title with ±1 and note count
            Text(
                text = pluralStringResource(
                    id = R.plurals.location_notes_title,
                    count = count,
                    geohash,
                    count
                ),
                fontFamily = FontFamily.Monospace,
                fontSize = 18.sp,
                color = MaterialTheme.colorScheme.onSurface
            )
            
            // Close button - iOS style with xmark icon
            Box(
                modifier = Modifier
                    .size(32.dp)
                    .clickable(onClick = onClose),
                contentAlignment = Alignment.Center
            ) {
                Text(
                    text = "✕",
                    fontFamily = FontFamily.Monospace,
                    fontSize = 13.sp,
                    fontWeight = FontWeight.SemiBold,
                    color = MaterialTheme.colorScheme.onSurface
                )
            }
        }
        
        Spacer(modifier = Modifier.height(8.dp))
        
        // Location name in green (building or block)
        locationName?.let { name ->
            if (name.isNotEmpty()) {
                Text(
                    text = name,
                    fontFamily = FontFamily.Monospace,
                    fontSize = 12.sp,
                    color = accentGreen
                )
                Spacer(modifier = Modifier.height(8.dp))
            }
        }
        
        // Description
        Text(
            text = stringResource(R.string.location_notes_description),
            fontFamily = FontFamily.Monospace,
            fontSize = 12.sp,
            color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.6f)
        )
        
        // Relays paused message if no relays
        if (state == LocationNotesManager.State.NO_RELAYS) {
            Spacer(modifier = Modifier.height(4.dp))
            Text(
                text = stringResource(R.string.location_notes_relays_unavailable),
                fontFamily = FontFamily.Monospace,
                fontSize = 11.sp,
                color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.6f)
            )
        }
    }
}

/**
 * Note row - matches iOS noteRow exactly
 * Shows @basename then timestamp, then content below
 */
@Composable
private fun NoteRow(note: LocationNotesManager.Note) {
    // Extract baseName (before #suffix like iOS)
    val baseName = note.displayName.split("#", limit = 2).firstOrNull() ?: note.displayName
    val ts = timestampText(note.createdAt)
    
    Column(
        modifier = Modifier
            .fillMaxWidth()
            .padding(vertical = 4.dp)
    ) {
        // First row: @nickname and timestamp
        Row(
            modifier = Modifier.fillMaxWidth(),
            horizontalArrangement = Arrangement.Start,
            verticalAlignment = Alignment.CenterVertically
        ) {
            Text(
                text = "@$baseName",
                fontFamily = FontFamily.Monospace,
                fontSize = 12.sp,
                fontWeight = FontWeight.SemiBold,
                color = MaterialTheme.colorScheme.onSurface
            )
            if (ts.isNotEmpty()) {
                Spacer(modifier = Modifier.width(6.dp))
                Text(
                    text = ts,
                    fontFamily = FontFamily.Monospace,
                    fontSize = 11.sp,
                    color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.6f)
                )
            }
        }
        
        Spacer(modifier = Modifier.height(2.dp))
        
        // Second row: content
        Text(
            text = note.content,
            fontFamily = FontFamily.Monospace,
            fontSize = 14.sp,
            color = MaterialTheme.colorScheme.onSurface
        )
    }
}

/**
 * No relays row - matches iOS noRelaysRow
 */
@Composable
private fun NoRelaysRow(onRetry: () -> Unit) {
    Column(
        modifier = Modifier
            .fillMaxWidth()
            .padding(vertical = 6.dp)
    ) {
        Text(
            text = stringResource(R.string.location_notes_no_relays_title),
            fontFamily = FontFamily.Monospace,
            fontSize = 13.sp,
            fontWeight = FontWeight.SemiBold,
            color = MaterialTheme.colorScheme.onSurface
        )
        Spacer(modifier = Modifier.height(4.dp))
        Text(
            text = stringResource(R.string.location_notes_no_relays_desc),
            fontFamily = FontFamily.Monospace,
            fontSize = 12.sp,
            color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.6f)
        )
        Spacer(modifier = Modifier.height(4.dp))
        Text(
            text = stringResource(R.string.retry),
            fontFamily = FontFamily.Monospace,
            fontSize = 12.sp,
            color = MaterialTheme.colorScheme.primary,
            modifier = Modifier.clickable(onClick = onRetry)
        )
    }
}

/**
 * Loading row - matches iOS loadingRow
 */
@Composable
private fun LoadingRow() {
    Row(
        modifier = Modifier
            .fillMaxWidth()
            .padding(vertical = 8.dp),
        horizontalArrangement = Arrangement.Start,
        verticalAlignment = Alignment.CenterVertically
    ) {
        CircularProgressIndicator(
            modifier = Modifier.size(16.dp),
            strokeWidth = 2.dp
        )
        Spacer(modifier = Modifier.width(10.dp))
        Text(
            text = stringResource(R.string.loading_location_notes),
            fontFamily = FontFamily.Monospace,
            fontSize = 12.sp,
            color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.6f)
        )
    }
}

/**
 * Empty row - matches iOS emptyRow
 */
@Composable
private fun EmptyRow() {
    Column(
        modifier = Modifier
            .fillMaxWidth()
            .padding(vertical = 6.dp)
    ) {
        Text(
            text = stringResource(R.string.location_notes_empty_title),
            fontFamily = FontFamily.Monospace,
            fontSize = 13.sp,
            fontWeight = FontWeight.SemiBold,
            color = MaterialTheme.colorScheme.onSurface
        )
        Spacer(modifier = Modifier.height(4.dp))
        Text(
            text = stringResource(R.string.location_notes_empty_desc),
            fontFamily = FontFamily.Monospace,
            fontSize = 12.sp,
            color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.6f)
        )
    }
}

/**
 * Error row - matches iOS errorRow
 */
@Composable
private fun ErrorRow(message: String, onDismiss: () -> Unit) {
    Column(
        modifier = Modifier
            .fillMaxWidth()
            .padding(vertical = 6.dp)
    ) {
        Row(
            horizontalArrangement = Arrangement.Start,
            verticalAlignment = Alignment.CenterVertically
        ) {
            Text(
                text = "⚠",
                fontSize = 12.sp
            )
            Spacer(modifier = Modifier.width(6.dp))
            Text(
                text = message,
                fontFamily = FontFamily.Monospace,
                fontSize = 12.sp,
                color = MaterialTheme.colorScheme.onSurface
            )
        }
        Spacer(modifier = Modifier.height(4.dp))
        Text(
            text = stringResource(R.string.dismiss),
            fontFamily = FontFamily.Monospace,
            fontSize = 12.sp,
            color = MaterialTheme.colorScheme.primary,
            modifier = Modifier.clickable(onClick = onDismiss)
        )
    }
}

/**
 * Input section - matches main chat input exactly
 */
@Composable
private fun LocationNotesInputSection(
    draft: String,
    onDraftChange: (String) -> Unit,
    sendButtonEnabled: Boolean,
    accentGreen: Color,
    backgroundColor: Color,
    onSend: () -> Unit
) {
    val isDark = isSystemInDarkTheme()
    val colorScheme = MaterialTheme.colorScheme
    
    Row(
        modifier = Modifier
            .fillMaxWidth()
            .background(backgroundColor)
            .padding(horizontal = 12.dp, vertical = 8.dp), // Match main chat padding
        verticalAlignment = Alignment.CenterVertically,
        horizontalArrangement = Arrangement.spacedBy(8.dp) // Match main chat spacing
    ) {
        // Text input with placeholder overlay (matches main chat exactly)
        Box(
            modifier = Modifier.weight(1f)
        ) {
            androidx.compose.foundation.text.BasicTextField(
                value = draft,
                onValueChange = onDraftChange,
                textStyle = MaterialTheme.typography.bodyMedium.copy(
                    color = colorScheme.primary,
                    fontFamily = FontFamily.Monospace
                ),
                cursorBrush = androidx.compose.ui.graphics.SolidColor(colorScheme.primary),
                keyboardOptions = androidx.compose.foundation.text.KeyboardOptions(
                    imeAction = androidx.compose.ui.text.input.ImeAction.Send
                ),
                keyboardActions = androidx.compose.foundation.text.KeyboardActions(
                    onSend = { if (sendButtonEnabled) onSend() }
                ),
                modifier = Modifier.fillMaxWidth()
            )
            
            // Placeholder when empty (matches main chat)
            if (draft.isEmpty()) {
                Text(
                    text = stringResource(R.string.location_notes_input_placeholder),
                    style = MaterialTheme.typography.bodyMedium.copy(
                        fontFamily = FontFamily.Monospace
                    ),
                    color = colorScheme.onSurface.copy(alpha = 0.5f),
                    modifier = Modifier.fillMaxWidth()
                )
            }
        }
        
        // Send button - circular with icon (matches main chat exactly)
        IconButton(
            onClick = { if (sendButtonEnabled) onSend() },
            enabled = sendButtonEnabled,
            modifier = Modifier.size(32.dp)
        ) {
            Box(
                modifier = Modifier
                    .size(30.dp)
                    .background(
                        color = if (!sendButtonEnabled) {
                            colorScheme.onSurface.copy(alpha = 0.3f)
                        } else {
                            accentGreen.copy(alpha = 0.75f)
                        },
                        shape = CircleShape
                    ),
                contentAlignment = Alignment.Center
            ) {
                Icon(
                    imageVector = Icons.Filled.ArrowUpward,
                    contentDescription = stringResource(R.string.send_message),
                    modifier = Modifier.size(20.dp),
                    tint = if (!sendButtonEnabled) {
                        colorScheme.onSurface.copy(alpha = 0.5f)
                    } else if (isDark) {
                        Color.Black // Black arrow on green in dark theme
                    } else {
                        Color.White // White arrow on green in light theme
                    }
                )
            }
        }
    }
}

/**
 * Timestamp text - matches iOS timestampText exactly
 * Shows relative time for < 7 days, absolute date otherwise
 */
private fun timestampText(createdAt: Int): String {
    val date = Date(createdAt * 1000L)
    val now = Date()
    
    // Calculate days difference
    val calendar = Calendar.getInstance()
    calendar.time = date
    val dateDay = calendar.get(Calendar.DAY_OF_YEAR)
    val dateYear = calendar.get(Calendar.YEAR)
    
    calendar.time = now
    val nowDay = calendar.get(Calendar.DAY_OF_YEAR)
    val nowYear = calendar.get(Calendar.YEAR)
    
    val daysDiff = if (dateYear == nowYear) {
        nowDay - dateDay
    } else {
        // Simplified: just check if less than 7 days by timestamp
        val diff = (now.time - date.time) / (1000 * 60 * 60 * 24)
        diff.toInt()
    }
    
    return if (daysDiff < 7) {
        // Relative formatting (abbreviated)
        val diffMillis = now.time - date.time
        val diffSeconds = diffMillis / 1000
        
        when {
            diffSeconds < 60 -> "" // Don't show "just now" in iOS
            diffSeconds < 3600 -> {
                val minutes = (diffSeconds / 60).toInt()
                "${minutes}m ago"
            }
            diffSeconds < 86400 -> {
                val hours = (diffSeconds / 3600).toInt()
                "${hours}h ago"
            }
            else -> {
                val days = (diffSeconds / 86400).toInt()
                "${days}d ago"
            }
        }
    } else {
        // Absolute date formatting
        val sameYear = dateYear == nowYear
        val formatter = if (sameYear) {
            SimpleDateFormat("MMM d", Locale.getDefault())
        } else {
            SimpleDateFormat("MMM d, y", Locale.getDefault())
        }
        formatter.format(date)
    }
}
