#!/bin/bash
# Restore script for AI Learning Platform

# Colors for output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
CYAN='\033[0;36m'
NC='\033[0m' # No Color

BACKUP_DIR="/home/$USER/backups"

# Nombres de contenedores (debe coincidir con docker-compose.yml)
POSTGRES_CONTAINER="ai-learning-platform-ewc-postgres"
BACKEND_CONTAINER="ai-learning-platform-ewc-backend"
FRONTEND_PROD_CONTAINER="ai-learning-platform-ewc-frontend-prod"
FRONTEND_DEV_CONTAINER="ai-learning-platform-ewc-frontend-dev"
TEMPORAL_CONTAINER="ai-learning-platform-ewc-temporal"

# Nombres de servicios (para docker-compose exec/restart)
POSTGRES_SERVICE="postgres"
BACKEND_SERVICE="backend"
FRONTEND_PROD_SERVICE="frontend-prod"

# Volumen de logs del backend
BACKEND_LOGS_VOLUME="ai_learning_platform_EWC_backend_logs"

# Function to display header
show_header() {
    echo -e "${BLUE}╔══════════════════════════════════════════════════════════════╗${NC}"
    echo -e "${BLUE}║                    RESTORE BACKUP TOOL                      ║${NC}"
    echo -e "${BLUE}║              AI Learning Platform Chatbot                     ║${NC}"
    echo -e "${BLUE}╚══════════════════════════════════════════════════════════════╝${NC}"
    echo
}

# Function to check if backup directory exists
check_backup_dir() {
    if [ ! -d "$BACKUP_DIR" ]; then
        echo -e "${RED}❌ Backup directory not found: $BACKUP_DIR${NC}"
        echo -e "${YELLOW}💡 Make sure you have run backup.sh at least once${NC}"
        exit 1
    fi
}

# Function to get available backups
get_available_backups() {
    echo -e "${CYAN}🔍 Searching for available backups...${NC}"
    echo
    
    # Find all date folders and sort by modification time (newest first)
    local date_folders=($(find $BACKUP_DIR -type d -name "20*" -printf '%T@ %p\n' 2>/dev/null | sort -nr | head -5 | cut -d' ' -f2-))
    
    if [ ${#date_folders[@]} -eq 0 ]; then
        echo -e "${RED}❌ No backup folders found in $BACKUP_DIR${NC}"
        echo -e "${YELLOW}💡 Available files in backup directory:${NC}"
        ls -la $BACKUP_DIR 2>/dev/null || echo "Directory is empty"
        exit 1
    fi
    
    echo -e "${GREEN}📋 Found ${#date_folders[@]} recent backup folders:${NC}"
    echo
    
    # Display backups with details
    for i in "${!date_folders[@]}"; do
        local date_folder="${date_folders[$i]}"
        local folder_name=$(basename "$date_folder")
        local folder_time=$(stat -c %y "$date_folder" 2>/dev/null | cut -d' ' -f1-2)
        
        # Find the latest backup in this date folder
        local latest_db_backup=$(find "$date_folder" -name "db_backup_*.sql" -type f -printf '%T@ %p\n' 2>/dev/null | sort -nr | head -1 | cut -d' ' -f2-)
        
        if [ -z "$latest_db_backup" ]; then
            continue
        fi
        
        local backup_name=$(basename "$latest_db_backup")
        local backup_timestamp=$(echo "$backup_name" | sed 's/db_backup_\(.*\)\.sql/\1/')
        local backup_size=$(du -sh "$date_folder" | cut -f1)
        
        # Check if corresponding uploads and logs backups exist
        local uploads_backup="${latest_db_backup/db_backup_/uploads_backup_}"
        uploads_backup="${uploads_backup/.sql/.tar.gz}"
        local logs_backup="${latest_db_backup/db_backup_/logs_backup_}"
        logs_backup="${logs_backup/.sql/.tar.gz}"
        
        local has_uploads=""
        local has_logs=""
        
        if [ -f "$uploads_backup" ]; then
            has_uploads="📁"
        fi
        
        if [ -f "$logs_backup" ]; then
            has_logs="📋"
        fi
        
        printf "${CYAN}%d)${NC} ${GREEN}%s${NC} ${YELLOW}(%s)${NC} ${BLUE}[%s]${NC} %s%s\n" \
            $((i+1)) "$folder_name" "$backup_size" "$folder_time" "$has_uploads" "$has_logs"
    done
    
    echo
    return "${#date_folders[@]}"
}

# Function to get user selection
get_user_selection() {
    local total_backups=$1
    local selection=0
    
    while true; do
        echo -e "${YELLOW}🔢 Select backup to restore (1-$total_backups) or 'q' to quit:${NC}" >&2
        read -p "> " selection
        
        if [ "$selection" = "q" ] || [ "$selection" = "Q" ]; then
            echo -e "${YELLOW}👋 Restore cancelled by user${NC}" >&2
            exit 0
        fi
        
        if [[ "$selection" =~ ^[0-9]+$ ]] && [ "$selection" -ge 1 ] && [ "$selection" -le "$total_backups" ]; then
            break
        else
            echo -e "${RED}❌ Invalid selection. Please enter a number between 1 and $total_backups${NC}" >&2
        fi
    done
    
    echo "$selection"
}

# Function to confirm restore
confirm_restore() {
    local backup_file=$1
    local backup_name=$(basename "$backup_file")
    local backup_timestamp=$(echo "$backup_name" | sed 's/db_backup_\(.*\)\.sql/\1/')
    local backup_folder=$(dirname "$backup_file")
    local folder_name=$(basename "$backup_folder")
    
    echo -e "${RED}⚠️  WARNING: This will replace your current database!${NC}"
    echo -e "${YELLOW}📅 Selected backup folder: $folder_name${NC}"
    echo -e "${YELLOW}🕐 Backup timestamp: $backup_timestamp${NC}"
    echo -e "${YELLOW}📁 Backup file: $backup_name${NC}"
    echo
    echo -e "${RED}This action cannot be undone. Make sure you have a current backup!${NC}"
    echo
    echo -e "${YELLOW}Are you sure you want to proceed? (yes/no):${NC}"
    read -p "> " confirm
    
    if [ "$confirm" = "yes" ] || [ "$confirm" = "y" ] || [ "$confirm" = "YES" ] || [ "$confirm" = "Y" ]; then
        return 0
    else
        echo -e "${YELLOW}👋 Restore cancelled by user${NC}"
        exit 0
    fi
}

# Function to check if containers are running
check_containers() {
    echo -e "${CYAN}🔍 Checking if containers are running...${NC}"
    
    if ! docker-compose --profile prod ps | grep -q "Up"; then
        echo -e "${YELLOW}⚠️  No containers are currently running${NC}"
        echo -e "${YELLOW}🚀 Starting containers...${NC}"
        
        if ! docker-compose --profile prod up -d; then
            echo -e "${RED}❌ Failed to start containers${NC}"
            exit 1
        fi
        
        echo -e "${YELLOW}⏳ Waiting for containers to be ready...${NC}"
        sleep 10
    else
        echo -e "${GREEN}✅ Containers are running${NC}"
    fi
}

# Function to restore database
restore_database() {
    local backup_file=$1
    local backup_name=$(basename "$backup_file")
    
    echo -e "${YELLOW}📦 Restoring database from $backup_name...${NC}"
    
    # Check if database exists
    if ! docker exec $POSTGRES_CONTAINER psql -U postgres -lqt | cut -d \| -f 1 | grep -qw ai_learning_platform > /dev/null 2>&1; then
        echo -e "${YELLOW}📝 Creating database ...${NC}"
        docker exec $POSTGRES_CONTAINER psql -U postgres -c "CREATE DATABASE ai_learning_platform;" 2>/dev/null
    fi
    
    # Restore database
    if docker-compose --profile prod exec -T $POSTGRES_SERVICE psql -U postgres -d ai_learning_platform < "$backup_file" 2>/dev/null; then
        echo -e "${GREEN}✅ Database restored successfully${NC}"
    else
        echo -e "${RED}❌ Database restore failed${NC}"
        exit 1
    fi
}

# Function to restore uploads
restore_uploads() {
    local backup_file=$1
    local backup_name=$(basename "$backup_file")
    
    if [ -f "$backup_file" ]; then
        echo -e "${YELLOW}📁 Restoring uploads from $backup_name...${NC}"
        
        # Create uploads directory if it doesn't exist
        mkdir -p backend/uploads
        
        # Extract uploads
        if tar -xzf "$backup_file" -C . 2>/dev/null; then
            echo -e "${GREEN}✅ Uploads restored successfully${NC}"
        else
            echo -e "${YELLOW}⚠️  Uploads restore failed (file may be empty)${NC}"
        fi
    else
        echo -e "${YELLOW}⚠️  No uploads backup found for this date${NC}"
    fi
}

# Function to restore logs
restore_logs() {
    local backup_file=$1
    local backup_name=$(basename "$backup_file")
    
    if [ -f "$backup_file" ]; then
        echo -e "${YELLOW}📋 Restoring logs from $backup_name...${NC}"
        
        # Check if logs volume exists
        if docker volume inspect $BACKEND_LOGS_VOLUME > /dev/null 2>&1; then
            # Create a temporary container to restore logs
            if docker run --rm -v $BACKEND_LOGS_VOLUME:/logs -v "$(pwd)":/backup alpine tar -xzf "/backup/$backup_name" -C /logs 2>/dev/null; then
                echo -e "${GREEN}✅ Logs restored successfully${NC}"
            else
                echo -e "${YELLOW}⚠️  Logs restore failed (file may be empty)${NC}"
            fi
        else
            echo -e "${YELLOW}⚠️  Logs volume not found, skipping logs restore${NC}"
        fi
    else
        echo -e "${YELLOW}⚠️  No logs backup found for this date${NC}"
    fi
}

# Function to restart services
restart_services() {
    echo -e "${YELLOW}🔄 Restarting services...${NC}"
    
    if docker-compose --profile prod restart $BACKEND_SERVICE; then
        echo -e "${GREEN}✅ Backend service restarted${NC}"
    else
        echo -e "${YELLOW}⚠️  Failed to restart backend service${NC}"
    fi
    
    if docker-compose --profile prod restart $FRONTEND_PROD_SERVICE; then
        echo -e "${GREEN}✅ Frontend service restarted${NC}"
    else
        echo -e "${YELLOW}⚠️  Failed to restart frontend service${NC}"
    fi
}

# Main function
main() {
    show_header
    
    # Check if backup directory exists
    check_backup_dir
    
    # Get available backups
    get_available_backups
    local total_backups=$?
    
    # Get user selection
    local selection=$(get_user_selection $total_backups)
    
    # Get the selected backup folder
    local date_folders=($(find $BACKUP_DIR -type d -name "20*" -printf '%T@ %p\n' 2>/dev/null | sort -nr | head -5 | cut -d' ' -f2-))
    local selected_folder="${date_folders[$((selection-1))]}"
    
    # Find the latest database backup in the selected folder
    local selected_backup=$(find "$selected_folder" -name "db_backup_*.sql" -type f -printf '%T@ %p\n' 2>/dev/null | sort -nr | head -1 | cut -d' ' -f2-)
    
    # Confirm restore
    confirm_restore "$selected_backup"
    
    # Check and start containers if needed
    check_containers
    
    # Get corresponding backup files
    local backup_name=$(basename "$selected_backup")
    local backup_timestamp=$(echo "$backup_name" | sed 's/db_backup_\(.*\)\.sql/\1/')
    local backup_folder=$(dirname "$selected_backup")
    local folder_name=$(basename "$backup_folder")
    local uploads_backup="${selected_backup/db_backup_/uploads_backup_}"
    uploads_backup="${uploads_backup/.sql/.tar.gz}"
    local logs_backup="${selected_backup/db_backup_/logs_backup_}"
    logs_backup="${logs_backup/.sql/.tar.gz}"
    
    echo -e "${BLUE}🚀 Starting restore process...${NC}"
    echo
    
    # Restore database
    restore_database "$selected_backup"
    
    # Restore uploads
    restore_uploads "$uploads_backup"
    
    # Restore logs
    restore_logs "$logs_backup"
    
    # Restart services
    restart_services
    
    echo
    echo -e "${GREEN}🎉 Restore completed successfully!${NC}"
    echo -e "${BLUE}📅 Restored backup folder: $folder_name${NC}"
    echo -e "${BLUE}🕐 Restored backup timestamp: $backup_timestamp${NC}"
    echo -e "${YELLOW}💡 You may need to refresh your browser to see the changes${NC}"
}

# Run main function
main "$@"