# Step 1: Check current database
ls -la ./mcp.db
sqlite3 ./mcp.db "SELECT COUNT(*) FROM servers;"

# Step 2: Create backup using SQLite backup command
BACKUP_FILE="$BACKUP_DIR/mcp_$(date +%Y%m%d_%H%M%S).db"
sqlite3 ./mcp.db ".backup '$BACKUP_FILE'"

# Step 3: Verify backup file
ls -la $BACKUP_FILE
sqlite3 $BACKUP_FILE "PRAGMA integrity_check;"
sqlite3 $BACKUP_FILE "SELECT COUNT(*) FROM servers;"

# Step 1: Start background load
for i in {1..100}; do
  curl -s "$GATEWAY_URL/health" &
done

# Step 2: Create backup while under load
BACKUP_FILE="$BACKUP_DIR/mcp_load_$(date +%Y%m%d_%H%M%S).db"
sqlite3 ./mcp.db ".backup '$BACKUP_FILE'"

# Step 3: Wait for load to complete
wait

# Step 4: Verify backup consistency
sqlite3 $BACKUP_FILE "PRAGMA integrity_check;"
sqlite3 $BACKUP_FILE "PRAGMA foreign_key_check;"

# Step 1: Check database size
psql $DATABASE_URL -c "SELECT pg_size_pretty(pg_database_size(current_database()));"

# Step 2: Create full backup
BACKUP_FILE="$BACKUP_DIR/mcpgateway_$(date +%Y%m%d_%H%M%S).dump"
pg_dump $DATABASE_URL --format=custom --file=$BACKUP_FILE

# Step 3: Verify backup
pg_restore --list $BACKUP_FILE | head -50

# Step 4: Check backup metadata
pg_restore --list $BACKUP_FILE | grep -c "TABLE DATA"

# Step 1: Create parallel backup
BACKUP_DIR_PG="$BACKUP_DIR/pg_parallel_$(date +%Y%m%d_%H%M%S)"
mkdir -p $BACKUP_DIR_PG
pg_dump $DATABASE_URL --format=directory --jobs=4 --file=$BACKUP_DIR_PG

# Step 2: Verify parallel backup
ls -la $BACKUP_DIR_PG/
cat $BACKUP_DIR_PG/toc.dat | head -20

# Step 3: Compare with single-threaded time (optional)
time pg_dump $DATABASE_URL --format=custom --file=/tmp/single.dump

# Step 1: Stop the gateway
pkill -f mcpgateway || true

# Step 2: Backup current database (safety)
mv ./mcp.db ./mcp.db.pre-restore

# Step 3: Restore from backup
cp $BACKUP_FILE ./mcp.db

# Step 4: Verify restoration
sqlite3 ./mcp.db "PRAGMA integrity_check;"
sqlite3 ./mcp.db "SELECT COUNT(*) FROM servers;"

# Step 5: Start gateway
make dev &
sleep 5

# Step 6: Validate functionality
curl -s "$GATEWAY_URL/health"
curl -s "$GATEWAY_URL/servers" -H "Authorization: Bearer $ADMIN_TOKEN" | jq '.total'

# Step 1: Stop the gateway
pkill -f mcpgateway || true

# Step 2: Drop and recreate database
psql postgres -c "DROP DATABASE IF EXISTS mcpgateway_restore;"
psql postgres -c "CREATE DATABASE mcpgateway_restore;"

# Step 3: Restore from backup
pg_restore --dbname=postgresql://user:pass@localhost:5432/mcpgateway_restore \
  --verbose --clean --if-exists $BACKUP_FILE

# Step 4: Verify restoration
psql postgresql://user:pass@localhost:5432/mcpgateway_restore \
  -c "SELECT COUNT(*) FROM servers;"

# Step 5: Start gateway with restored database
DATABASE_URL=postgresql://user:pass@localhost:5432/mcpgateway_restore make dev &
sleep 5

# Step 6: Validate functionality
curl -s "$GATEWAY_URL/health"

# Step 1: Restore old backup
pg_restore --dbname=$DATABASE_URL --clean --if-exists $OLD_BACKUP_FILE

# Step 2: Check current migration state
cd mcpgateway && alembic current

# Step 3: Run pending migrations
cd mcpgateway && alembic upgrade head

# Step 4: Verify schema
cd mcpgateway && alembic check

# Step 5: Start gateway and verify
make dev &
sleep 5
curl -s "$GATEWAY_URL/health"

# Record start time
START_TIME=$(date +%s)

# Step 1: Deploy fresh infrastructure
docker-compose up -d postgres redis

# Step 2: Wait for services
sleep 30
python -m mcpgateway.utils.db_isready
python -m mcpgateway.utils.redis_isready

# Step 3: Restore database
pg_restore --dbname=$DATABASE_URL --clean --if-exists $BACKUP_FILE

# Step 4: Run migrations
cd mcpgateway && alembic upgrade head

# Step 5: Start gateway
make serve &
sleep 10

# Step 6: Validate all endpoints
curl -s "$GATEWAY_URL/health" | jq .
curl -s "$GATEWAY_URL/ready" | jq .
curl -s "$GATEWAY_URL/servers" -H "Authorization: Bearer $ADMIN_TOKEN" | jq '.total'

# Calculate recovery time
END_TIME=$(date +%s)
RECOVERY_TIME=$((END_TIME - START_TIME))
echo "Recovery completed in $RECOVERY_TIME seconds"