Upload projects

.env

@@ -0,0 +1,17 @@
+AZURE_SPEECH_KEY=3HsgmegEhUwONKDChLmFlSWXTb4aiwTOjXuBBAOxWjURmt9sOowXJQQJ99BFACqBBLyXJ3w3AAAYACOGoq5r
+AZURE_SPEECH_KEY_ENDPOINT=https://southeastasia.api.cognitive.microsoft.com
+AZURE_REGION=southeastasia
+AZURE_BLOB_CONNECTION=DefaultEndpointsProtocol=https;AccountName=speechtotextservice01;AccountKey=GAFbqMBvIHkRXLIx9173jFVb7W96lQ02t7bGgKwq6LbpU2gqaUeU+pWAKcbdn38rQYfKnOFVy5ar+AStxXjAJA==;EndpointSuffix=core.windows.net
+AZURE_CONTAINER=history
+AZURE_BLOB_SAS_TOKEN=sp=racwdl&st=2025-06-23T07:18:08Z&se=2025-06-30T15:18:08Z&sv=2024-11-04&sr=c&sig=GFwuSzZqOe51QIGDYq%2B2JVLAWoy4UhKs2GaArjyEKEk%3D
+ALLOWED_LANGS={"en-US": "English (United States)", "th-TH": "Thai", "zh-CN": "Chinese (Mandarin, Simplified)"}
+API_VERSION=v3.2
+
+# Application Configuration
+MAX_CONCURRENT_JOBS=5
+DATABASE_PATH=database/transcriptions.db
+CLEANUP_OLDER_THAN_DAYS=30
+
+# Development Settings
+DEBUG=false
+LOG_LEVEL=INFO

Developer.md

@@ -0,0 +1,1904 @@
+# 🛠️ Azure Speech Transcription - Developer Guide
+
+## 📋 Table of Contents
+
+- [System Architecture](#-system-architecture)
+- [Development Environment](#-development-environment)
+- [Deployment Guide](#-deployment-guide)
+- [API Documentation](#-api-documentation)
+- [Database Schema](#-database-schema)
+- [Security Implementation](#-security-implementation)
+- [Monitoring & Maintenance](#-monitoring--maintenance)
+- [Contributing Guidelines](#-contributing-guidelines)
+- [Advanced Configuration](#-advanced-configuration)
+- [Troubleshooting](#-troubleshooting)
+
+---
+
+## 🏗️ System Architecture
+
+### Overview
+
+The Azure Speech Transcription service is built with a modern, secure architecture focusing on user privacy, PDPA compliance, and scalability.
+
+```
+┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
+│   Frontend UI   │    │   Backend API   │    │ Azure Services  │
+│   (Gradio)      │◄──►│   (Python)      │◄──►│ Speech & Blob   │
+└─────────────────┘    └─────────────────┘    └─────────────────┘
+         │                       │                       │
+         │                       │                       │
+         ▼                       ▼                       ▼
+┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
+│   User Session  │    │ SQLite Database │    │  User Storage   │
+│   Management    │    │   (Metadata)    │    │   (Isolated)    │
+└─────────────────┘    └─────────────────┘    └─────────────────┘
+```
+
+### Core Components
+
+#### 1. Frontend Layer (`gradio_app.py`)
+- **Technology**: Gradio with custom CSS
+- **Purpose**: User interface and session management
+- **Features**: Authentication, file upload, real-time status, history management
+
+#### 2. Backend Layer (`app_core.py`)
+- **Technology**: Python with threading and async processing
+- **Purpose**: Business logic, authentication, and Azure integration
+- **Features**: User management, transcription processing, PDPA compliance
+
+#### 3. Data Layer
+- **Database**: SQLite with Azure Blob backup
+- **Storage**: Azure Blob Storage with user separation
+- **Security**: User-isolated folders and encrypted connections
+
+#### 4. External Services
+- **Azure Speech Services**: Transcription processing
+- **Azure Blob Storage**: File and database storage
+- **FFmpeg**: Audio/video conversion
+
+### Data Flow
+
+```
+1. User uploads file → 2. Authentication check → 3. File validation
+        ↓                       ↓                       ↓
+8. Download results ← 7. Store transcript ← 6. Process with Azure
+        ↑                       ↑                       ↑
+9. Update UI status ← 4. Save to user folder ← 5. Background processing
+```
+
+---
+
+## 💻 Development Environment
+
+### Prerequisites
+
+- **Python**: 3.8 or higher
+- **Azure Account**: With Speech Services and Blob Storage
+- **FFmpeg**: For audio/video processing
+- **Git**: For version control
+
+### Environment Setup
+
+#### 1. Clone Repository
+```bash
+git clone <repository-url>
+cd azure-speech-transcription
+```
+
+#### 2. Virtual Environment
+```bash
+# Create virtual environment
+python -m venv venv
+
+# Activate (Windows)
+venv\Scripts\activate
+
+# Activate (macOS/Linux)
+source venv/bin/activate
+```
+
+#### 3. Install Dependencies
+```bash
+pip install -r requirements.txt
+```
+
+#### 4. Environment Configuration
+```bash
+# Copy environment template
+cp .env.example .env
+
+# Edit with your Azure credentials
+nano .env
+```
+
+#### 5. Install FFmpeg
+
+**Windows (Chocolatey):**
+```bash
+choco install ffmpeg
+```
+
+**macOS (Homebrew):**
+```bash
+brew install ffmpeg
+```
+
+**Ubuntu/Debian:**
+```bash
+sudo apt update
+sudo apt install ffmpeg
+```
+
+#### 6. Verify Installation
+```python
+python -c "
+import gradio as gr
+from azure.storage.blob import BlobServiceClient
+import subprocess
+print('Gradio:', gr.__version__)
+print('FFmpeg:', subprocess.run(['ffmpeg', '-version'], capture_output=True).returncode == 0)
+print('Azure Blob:', 'OK')
+"
+```
+
+### Development Server
+
+```bash
+# Start development server
+python gradio_app.py
+
+# Server will be available at:
+# http://localhost:7860
+```
+
+### Development Tools
+
+#### Recommended IDE Setup
+- **VS Code**: With Python, Azure, and Git extensions
+- **PyCharm**: Professional edition with Azure toolkit
+- **Vim/Emacs**: With appropriate Python plugins
+
+#### Useful Extensions
+```json
+{
+  "recommendations": [
+    "ms-python.python",
+    "ms-vscode.azure-cli",
+    "ms-azuretools.azure-cli-tools",
+    "ms-python.black-formatter",
+    "ms-python.flake8"
+  ]
+}
+```
+
+#### Code Quality Tools
+```bash
+# Install development tools
+pip install black flake8 pytest mypy
+
+# Format code
+black .
+
+# Lint code
+flake8 .
+
+# Type checking
+mypy app_core.py gradio_app.py
+```
+
+---
+
+## 🚀 Deployment Guide
+
+### Production Deployment Options
+
+#### Option 1: Traditional Server Deployment
+
+**1. Server Preparation**
+```bash
+# Update system
+sudo apt update && sudo apt upgrade -y
+
+# Install Python and dependencies
+sudo apt install python3 python3-pip python3-venv nginx ffmpeg -y
+
+# Create application user
+sudo useradd -m -s /bin/bash transcription
+sudo su - transcription
+```
+
+**2. Application Setup**
+```bash
+# Clone repository
+git clone <repository-url> /home/transcription/app
+cd /home/transcription/app
+
+# Setup virtual environment
+python3 -m venv venv
+source venv/bin/activate
+pip install -r requirements.txt
+
+# Configure environment
+cp .env.example .env
+# Edit .env with production values
+```
+
+**3. Systemd Service**
+```ini
+# /etc/systemd/system/transcription.service
+[Unit]
+Description=Azure Speech Transcription Service
+After=network.target
+
+[Service]
+Type=simple
+User=transcription
+Group=transcription
+WorkingDirectory=/home/transcription/app
+Environment=PATH=/home/transcription/app/venv/bin
+ExecStart=/home/transcription/app/venv/bin/python gradio_app.py
+Restart=always
+RestartSec=10
+
+[Install]
+WantedBy=multi-user.target
+```
+
+**4. Nginx Configuration**
+```nginx
+# /etc/nginx/sites-available/transcription
+server {
+    listen 80;
+    server_name your-domain.com;
+    client_max_body_size 500M;
+
+    location / {
+        proxy_pass http://127.0.0.1:7860;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        proxy_read_timeout 300s;
+        proxy_connect_timeout 75s;
+    }
+}
+```
+
+**5. SSL Certificate**
+```bash
+# Install Certbot
+sudo apt install certbot python3-certbot-nginx -y
+
+# Get SSL certificate
+sudo certbot --nginx -d your-domain.com
+
+# Verify auto-renewal
+sudo certbot renew --dry-run
+```
+
+**6. Start Services**
+```bash
+# Enable and start application
+sudo systemctl enable transcription
+sudo systemctl start transcription
+
+# Enable and restart nginx
+sudo systemctl enable nginx
+sudo systemctl restart nginx
+
+# Check status
+sudo systemctl status transcription
+sudo systemctl status nginx
+```
+
+#### Option 2: Docker Deployment
+
+**1. Dockerfile**
+```dockerfile
+FROM python:3.9-slim
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    ffmpeg \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set working directory
+WORKDIR /app
+
+# Copy requirements and install Python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Create necessary directories
+RUN mkdir -p uploads database temp
+
+# Expose port
+EXPOSE 7860
+
+# Run application
+CMD ["python", "gradio_app.py"]
+```
+
+**2. Docker Compose**
+```yaml
+# docker-compose.yml
+version: '3.8'
+
+services:
+  transcription:
+    build: .
+    ports:
+      - "7860:7860"
+    environment:
+      - AZURE_SPEECH_KEY=${AZURE_SPEECH_KEY}
+      - AZURE_SPEECH_KEY_ENDPOINT=${AZURE_SPEECH_KEY_ENDPOINT}
+      - AZURE_REGION=${AZURE_REGION}
+      - AZURE_BLOB_CONNECTION=${AZURE_BLOB_CONNECTION}
+      - AZURE_CONTAINER=${AZURE_CONTAINER}
+      - AZURE_BLOB_SAS_TOKEN=${AZURE_BLOB_SAS_TOKEN}
+      - ALLOWED_LANGS=${ALLOWED_LANGS}
+    volumes:
+      - ./uploads:/app/uploads
+      - ./database:/app/database
+      - ./temp:/app/temp
+    restart: unless-stopped
+
+  nginx:
+    image: nginx:alpine
+    ports:
+      - "80:80"
+      - "443:443"
+    volumes:
+      - ./nginx.conf:/etc/nginx/nginx.conf
+      - ./ssl:/etc/ssl/certs
+    depends_on:
+      - transcription
+    restart: unless-stopped
+```
+
+**3. Deploy with Docker**
+```bash
+# Build and start
+docker-compose up -d
+
+# View logs
+docker-compose logs -f transcription
+
+# Update application
+git pull
+docker-compose build transcription
+docker-compose up -d transcription
+```
+
+#### Option 3: Cloud Deployment (Azure Container Instances)
+
+**1. Create Container Registry**
+```bash
+# Create ACR
+az acr create --resource-group myResourceGroup \
+  --name myregistry --sku Basic
+
+# Login to ACR
+az acr login --name myregistry
+
+# Build and push image
+docker build -t myregistry.azurecr.io/transcription:latest .
+docker push myregistry.azurecr.io/transcription:latest
+```
+
+**2. Deploy Container Instance**
+```bash
+# Create container instance
+az container create \
+  --resource-group myResourceGroup \
+  --name transcription-app \
+  --image myregistry.azurecr.io/transcription:latest \
+  --cpu 2 --memory 4 \
+  --port 7860 \
+  --environment-variables \
+    AZURE_SPEECH_KEY=$AZURE_SPEECH_KEY \
+    AZURE_SPEECH_KEY_ENDPOINT=$AZURE_SPEECH_KEY_ENDPOINT \
+    AZURE_REGION=$AZURE_REGION \
+    AZURE_BLOB_CONNECTION="$AZURE_BLOB_CONNECTION" \
+    AZURE_CONTAINER=$AZURE_CONTAINER \
+    AZURE_BLOB_SAS_TOKEN="$AZURE_BLOB_SAS_TOKEN"
+```
+
+---
+
+## 📡 API Documentation
+
+### Core Classes and Methods
+
+#### TranscriptionManager Class
+
+**Purpose**: Main service class handling all transcription operations
+
+```python
+class TranscriptionManager:
+    def __init__(self)
+    
+    # User Authentication
+    def register_user(email: str, username: str, password: str, 
+                     gdpr_consent: bool, data_retention_agreed: bool, 
+                     marketing_consent: bool) -> Tuple[bool, str, Optional[str]]
+    
+    def login_user(login: str, password: str) -> Tuple[bool, str, Optional[User]]
+    
+    # Transcription Operations  
+    def submit_transcription(file_bytes: bytes, original_filename: str,
+                           user_id: str, language: str, 
+                           settings: Dict) -> str
+    
+    def get_job_status(job_id: str) -> Optional[TranscriptionJob]
+    
+    # Data Management
+    def get_user_history(user_id: str, limit: int) -> List[TranscriptionJob]
+    def get_user_stats(user_id: str) -> Dict
+    def export_user_data(user_id: str) -> Dict
+    def delete_user_account(user_id: str) -> bool
+```
+
+#### DatabaseManager Class
+
+**Purpose**: Handle database operations and Azure blob synchronization
+
+```python
+class DatabaseManager:
+    def __init__(db_path: str = None)
+    
+    # User Operations
+    def create_user(...) -> Tuple[bool, str, Optional[str]]
+    def authenticate_user(login: str, password: str) -> Tuple[bool, str, Optional[User]]
+    def get_user_by_id(user_id: str) -> Optional[User]
+    
+    # Job Operations
+    def save_job(job: TranscriptionJob)
+    def get_job(job_id: str) -> Optional[TranscriptionJob]
+    def get_user_jobs(user_id: str, limit: int) -> List[TranscriptionJob]
+    def get_pending_jobs() -> List[TranscriptionJob]
+```
+
+#### AuthManager Class
+
+**Purpose**: Authentication utilities and validation
+
+```python
+class AuthManager:
+    @staticmethod
+    def hash_password(password: str) -> str
+    def verify_password(password: str, password_hash: str) -> bool
+    def validate_email(email: str) -> bool
+    def validate_username(username: str) -> bool
+    def validate_password(password: str) -> Tuple[bool, str]
+```
+
+### Data Models
+
+#### User Model
+```python
+@dataclass
+class User:
+    user_id: str
+    email: str
+    username: str
+    password_hash: str
+    created_at: str
+    last_login: Optional[str] = None
+    is_active: bool = True
+    gdpr_consent: bool = False
+    data_retention_agreed: bool = False
+    marketing_consent: bool = False
+```
+
+#### TranscriptionJob Model
+```python
+@dataclass
+class TranscriptionJob:
+    job_id: str
+    user_id: str
+    original_filename: str
+    audio_url: str
+    language: str
+    status: str  # pending, processing, completed, failed
+    created_at: str
+    completed_at: Optional[str] = None
+    transcript_text: Optional[str] = None
+    transcript_url: Optional[str] = None
+    error_message: Optional[str] = None
+    azure_trans_id: Optional[str] = None
+    settings: Optional[Dict] = None
+```
+
+### Configuration Parameters
+
+#### Environment Variables
+```python
+# Required
+AZURE_SPEECH_KEY: str
+AZURE_SPEECH_KEY_ENDPOINT: str  
+AZURE_REGION: str
+AZURE_BLOB_CONNECTION: str
+AZURE_CONTAINER: str
+AZURE_BLOB_SAS_TOKEN: str
+
+# Optional
+ALLOWED_LANGS: str  # JSON string
+API_VERSION: str = "v3.2"
+PASSWORD_SALT: str = "default_salt"
+MAX_FILE_SIZE_MB: int = 500
+```
+
+#### Transcription Settings
+```python
+settings = {
+    'audio_format': str,           # wav, mp3, etc.
+    'diarization_enabled': bool,   # Speaker identification
+    'speakers': int,               # Max speakers (1-10)
+    'profanity': str,              # masked, removed, raw
+    'punctuation': str,            # automatic, dictated, none
+    'timestamps': bool,            # Include timestamps
+    'lexical': bool,               # Include lexical forms
+    'language_id_enabled': bool,   # Auto language detection
+    'candidate_locales': List[str] # Language candidates
+}
+```
+
+---
+
+## 🗄️ Database Schema
+
+### SQLite Database Structure
+
+#### Users Table
+```sql
+CREATE TABLE users (
+    user_id TEXT PRIMARY KEY,
+    email TEXT UNIQUE NOT NULL,
+    username TEXT UNIQUE NOT NULL,
+    password_hash TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    last_login TEXT,
+    is_active BOOLEAN DEFAULT 1,
+    gdpr_consent BOOLEAN DEFAULT 0,
+    data_retention_agreed BOOLEAN DEFAULT 0,
+    marketing_consent BOOLEAN DEFAULT 0
+);
+
+-- Indexes
+CREATE INDEX idx_users_email ON users(email);
+CREATE INDEX idx_users_username ON users(username);
+```
+
+#### Transcriptions Table
+```sql
+CREATE TABLE transcriptions (
+    job_id TEXT PRIMARY KEY,
+    user_id TEXT NOT NULL,
+    original_filename TEXT NOT NULL,
+    audio_url TEXT,
+    language TEXT NOT NULL,
+    status TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    completed_at TEXT,
+    transcript_text TEXT,
+    transcript_url TEXT,
+    error_message TEXT,
+    azure_trans_id TEXT,
+    settings TEXT,
+    FOREIGN KEY (user_id) REFERENCES users (user_id)
+);
+
+-- Indexes
+CREATE INDEX idx_transcriptions_user_id ON transcriptions(user_id);
+CREATE INDEX idx_transcriptions_status ON transcriptions(status);
+CREATE INDEX idx_transcriptions_created_at ON transcriptions(created_at DESC);
+CREATE INDEX idx_transcriptions_user_created ON transcriptions(user_id, created_at DESC);
+```
+
+### Azure Blob Storage Structure
+
+```
+Container: {AZURE_CONTAINER}/
+├── shared/
+│   └── database/
+│       └── transcriptions.db           # Shared database backup
+├── users/
+│   ├── {user-id-1}/
+│   │   ├── audio/                      # Processed audio files
+│   │   │   ├── {job-id-1}.wav
+│   │   │   └── {job-id-2}.wav
+│   │   ├── transcripts/                # Transcript files
+│   │   │   ├── {job-id-1}.txt
+│   │   │   └── {job-id-2}.txt
+│   │   └── originals/                  # Original uploaded files
+│   │       ├── {job-id-1}_{filename}.mp4
+│   │       └── {job-id-2}_{filename}.wav
+│   └── {user-id-2}/
+│       ├── audio/
+│       ├── transcripts/
+│       └── originals/
+```
+
+### Database Operations
+
+#### User Management Queries
+```sql
+-- Create user
+INSERT INTO users (user_id, email, username, password_hash, created_at, 
+                   gdpr_consent, data_retention_agreed, marketing_consent)
+VALUES (?, ?, ?, ?, ?, ?, ?, ?);
+
+-- Authenticate user
+SELECT * FROM users 
+WHERE (email = ? OR username = ?) AND is_active = 1;
+
+-- Update last login
+UPDATE users SET last_login = ? WHERE user_id = ?;
+
+-- Get user stats
+SELECT status, COUNT(*) FROM transcriptions 
+WHERE user_id = ? GROUP BY status;
+```
+
+#### Job Management Queries
+```sql
+-- Create job
+INSERT INTO transcriptions (job_id, user_id, original_filename, language, 
+                           status, created_at, settings)
+VALUES (?, ?, ?, ?, 'pending', ?, ?);
+
+-- Update job status
+UPDATE transcriptions 
+SET status = ?, completed_at = ?, transcript_text = ?, transcript_url = ?
+WHERE job_id = ?;
+
+-- Get user jobs
+SELECT * FROM transcriptions 
+WHERE user_id = ? 
+ORDER BY created_at DESC LIMIT ?;
+
+-- Get pending jobs for background processor
+SELECT * FROM transcriptions 
+WHERE status IN ('pending', 'processing');
+```
+
+---
+
+## 🔒 Security Implementation
+
+### Authentication Security
+
+#### Password Security
+```python
+# Password hashing with salt
+def hash_password(password: str) -> str:
+    salt = os.environ.get("PASSWORD_SALT", "default_salt")
+    return hashlib.sha256((password + salt).encode()).hexdigest()
+
+# Password validation
+def validate_password(password: str) -> Tuple[bool, str]:
+    if len(password) < 8:
+        return False, "Password must be at least 8 characters"
+    if not re.search(r'[A-Z]', password):
+        return False, "Password must contain uppercase letter"
+    if not re.search(r'[a-z]', password):
+        return False, "Password must contain lowercase letter"
+    if not re.search(r'\d', password):
+        return False, "Password must contain number"
+    return True, "Valid"
+```
+
+#### Session Management
+```python
+# User session state
+session_state = {
+    'user_id': str,
+    'username': str,
+    'logged_in_at': datetime,
+    'last_activity': datetime
+}
+
+# Session validation
+def validate_session(session_state: dict) -> bool:
+    if not session_state or 'user_id' not in session_state:
+        return False
+    
+    # Check session timeout (if implemented)
+    last_activity = session_state.get('last_activity')
+    if last_activity:
+        timeout = timedelta(hours=24)  # 24-hour sessions
+        if datetime.now() - last_activity > timeout:
+            return False
+    
+    return True
+```
+
+### Data Security
+
+#### Access Control
+```python
+# User data access verification
+def verify_user_access(job_id: str, user_id: str) -> bool:
+    job = get_job(job_id)
+    return job and job.user_id == user_id
+
+# File path security
+def get_user_blob_path(user_id: str, blob_type: str, filename: str) -> str:
+    # Ensure user can only access their own folder
+    safe_filename = os.path.basename(filename)  # Prevent path traversal
+    return f"users/{user_id}/{blob_type}/{safe_filename}"
+```
+
+#### Data Encryption
+```python
+# Azure Blob Storage encryption (configured at Azure level)
+# - Encryption at rest: Enabled by default
+# - Encryption in transit: HTTPS enforced
+# - Customer-managed keys: Optional enhancement
+
+# Database encryption (for sensitive fields)
+from cryptography.fernet import Fernet
+
+def encrypt_sensitive_data(data: str, key: bytes) -> str:
+    f = Fernet(key)
+    return f.encrypt(data.encode()).decode()
+
+def decrypt_sensitive_data(encrypted_data: str, key: bytes) -> str:
+    f = Fernet(key)
+    return f.decrypt(encrypted_data.encode()).decode()
+```
+
+### Azure Security
+
+#### Blob Storage Security
+```python
+# SAS token configuration for least privilege
+sas_permissions = BlobSasPermissions(
+    read=True,
+    write=True,
+    delete=True,
+    list=True
+)
+
+# IP restrictions (optional)
+sas_ip_range = "192.168.1.0/24"  # Restrict to specific IP range
+
+# Time-limited tokens
+sas_expiry = datetime.utcnow() + timedelta(hours=1)
+```
+
+#### Speech Service Security
+```python
+# Secure API calls
+headers = {
+    "Ocp-Apim-Subscription-Key": AZURE_SPEECH_KEY,
+    "Content-Type": "application/json"
+}
+
+# Request timeout and retry logic
+response = requests.post(
+    url, 
+    headers=headers, 
+    json=body,
+    timeout=30,
+    verify=True  # Verify SSL certificates
+)
+```
+
+### Input Validation
+
+#### File Upload Security
+```python
+def validate_uploaded_file(file_path: str, max_size: int = 500 * 1024 * 1024) -> Tuple[bool, str]:
+    try:
+        # Check file exists
+        if not os.path.exists(file_path):
+            return False, "File not found"
+        
+        # Check file size
+        file_size = os.path.getsize(file_path)
+        if file_size > max_size:
+            return False, f"File too large: {file_size / 1024 / 1024:.1f}MB"
+        
+        # Check file type by content (not just extension)
+        import magic
+        mime_type = magic.from_file(file_path, mime=True)
+        allowed_types = ['audio/', 'video/']
+        if not any(mime_type.startswith(t) for t in allowed_types):
+            return False, f"Invalid file type: {mime_type}"
+        
+        return True, "Valid"
+    
+    except Exception as e:
+        return False, f"Validation error: {str(e)}"
+```
+
+#### SQL Injection Prevention
+```python
+# Use parameterized queries (already implemented)
+cursor.execute(
+    "SELECT * FROM users WHERE email = ? AND password_hash = ?",
+    (email, password_hash)
+)
+
+# Input sanitization
+def sanitize_input(user_input: str) -> str:
+    # Remove dangerous characters
+    import html
+    sanitized = html.escape(user_input)
+    # Limit length
+    return sanitized[:1000]
+```
+
+---
+
+## 📊 Monitoring & Maintenance
+
+### Application Monitoring
+
+#### Health Checks
+```python
+def health_check() -> Dict[str, Any]:
+    """System health check endpoint"""
+    try:
+        # Database check
+        db_status = check_database_connection()
+        
+        # Azure services check
+        blob_status = check_blob_storage()
+        speech_status = check_speech_service()
+        
+        # FFmpeg check
+        ffmpeg_status = check_ffmpeg_installation()
+        
+        # Disk space check
+        disk_status = check_disk_space()
+        
+        return {
+            'status': 'healthy' if all([db_status, blob_status, speech_status, ffmpeg_status]) else 'unhealthy',
+            'timestamp': datetime.now().isoformat(),
+            'services': {
+                'database': db_status,
+                'blob_storage': blob_status,
+                'speech_service': speech_status,
+                'ffmpeg': ffmpeg_status,
+                'disk_space': disk_status
+            }
+        }
+    
+    except Exception as e:
+        return {
+            'status': 'error',
+            'timestamp': datetime.now().isoformat(),
+            'error': str(e)
+        }
+
+def check_database_connection() -> bool:
+    try:
+        with transcription_manager.db.get_connection() as conn:
+            conn.execute("SELECT 1").fetchone()
+        return True
+    except:
+        return False
+
+def check_blob_storage() -> bool:
+    try:
+        client = BlobServiceClient.from_connection_string(AZURE_BLOB_CONNECTION)
+        client.list_containers(max_results=1)
+        return True
+    except:
+        return False
+```
+
+#### Logging Configuration
+```python
+import logging
+from logging.handlers import RotatingFileHandler
+
+def setup_logging():
+    """Configure application logging"""
+    
+    # Create formatter
+    formatter = logging.Formatter(
+        '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    )
+    
+    # Console handler
+    console_handler = logging.StreamHandler()
+    console_handler.setFormatter(formatter)
+    console_handler.setLevel(logging.INFO)
+    
+    # File handler with rotation
+    file_handler = RotatingFileHandler(
+        'logs/transcription.log',
+        maxBytes=10*1024*1024,  # 10MB
+        backupCount=5
+    )
+    file_handler.setFormatter(formatter)
+    file_handler.setLevel(logging.DEBUG)
+    
+    # Configure root logger
+    logger = logging.getLogger()
+    logger.setLevel(logging.DEBUG)
+    logger.addHandler(console_handler)
+    logger.addHandler(file_handler)
+    
+    # Separate logger for sensitive operations
+    auth_logger = logging.getLogger('auth')
+    auth_handler = RotatingFileHandler(
+        'logs/auth.log',
+        maxBytes=5*1024*1024,  # 5MB
+        backupCount=10
+    )
+    auth_handler.setFormatter(formatter)
+    auth_logger.addHandler(auth_handler)
+    auth_logger.setLevel(logging.INFO)
+```
+
+#### Performance Monitoring
+```python
+import time
+from functools import wraps
+
+def monitor_performance(func):
+    """Decorator to monitor function performance"""
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        start_time = time.time()
+        try:
+            result = func(*args, **kwargs)
+            duration = time.time() - start_time
+            logging.info(f"{func.__name__} completed in {duration:.2f}s")
+            return result
+        except Exception as e:
+            duration = time.time() - start_time
+            logging.error(f"{func.__name__} failed after {duration:.2f}s: {str(e)}")
+            raise
+    return wrapper
+
+# Usage
+@monitor_performance
+def submit_transcription(self, file_bytes, filename, user_id, language, settings):
+    # Implementation here
+    pass
+```
+
+### Database Maintenance
+
+#### Backup Strategy
+```python
+def backup_database():
+    """Backup database to Azure Blob Storage"""
+    try:
+        # Create timestamped backup
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        backup_name = f"shared/backups/transcriptions_backup_{timestamp}.db"
+        
+        # Upload current database
+        blob_client = blob_service.get_blob_client(
+            container=AZURE_CONTAINER, 
+            blob=backup_name
+        )
+        
+        with open(db_path, "rb") as data:
+            blob_client.upload_blob(data)
+        
+        logging.info(f"Database backup created: {backup_name}")
+        
+        # Clean old backups (keep last 30 days)
+        cleanup_old_backups()
+        
+    except Exception as e:
+        logging.error(f"Database backup failed: {str(e)}")
+
+def cleanup_old_backups():
+    """Remove backups older than 30 days"""
+    try:
+        cutoff_date = datetime.now() - timedelta(days=30)
+        container_client = blob_service.get_container_client(AZURE_CONTAINER)
+        
+        for blob in container_client.list_blobs(name_starts_with="shared/backups/"):
+            if blob.last_modified < cutoff_date:
+                blob_service.delete_blob(AZURE_CONTAINER, blob.name)
+                logging.info(f"Deleted old backup: {blob.name}")
+                
+    except Exception as e:
+        logging.error(f"Backup cleanup failed: {str(e)}")
+```
+
+#### Database Optimization
+```python
+def optimize_database():
+    """Optimize database performance"""
+    try:
+        with transcription_manager.db.get_connection() as conn:
+            # Analyze tables
+            conn.execute("ANALYZE")
+            
+            # Vacuum database (compact)
+            conn.execute("VACUUM")
+            
+            # Update statistics
+            conn.execute("PRAGMA optimize")
+            
+        logging.info("Database optimization completed")
+        
+    except Exception as e:
+        logging.error(f"Database optimization failed: {str(e)}")
+
+# Schedule optimization (run weekly)
+import schedule
+
+schedule.every().week.do(optimize_database)
+schedule.every().day.at("02:00").do(backup_database)
+```
+
+### Resource Management
+
+#### Cleanup Tasks
+```python
+def cleanup_temporary_files():
+    """Clean up temporary files older than 24 hours"""
+    try:
+        cutoff_time = time.time() - (24 * 60 * 60)  # 24 hours ago
+        temp_dirs = ['uploads', 'temp']
+        
+        for temp_dir in temp_dirs:
+            if os.path.exists(temp_dir):
+                for filename in os.listdir(temp_dir):
+                    filepath = os.path.join(temp_dir, filename)
+                    if os.path.isfile(filepath) and os.path.getmtime(filepath) < cutoff_time:
+                        os.remove(filepath)
+                        logging.info(f"Cleaned up temporary file: {filepath}")
+                        
+    except Exception as e:
+        logging.error(f"Temporary file cleanup failed: {str(e)}")
+
+def monitor_disk_space():
+    """Monitor and alert on disk space"""
+    try:
+        import shutil
+        total, used, free = shutil.disk_usage("/")
+        
+        # Convert to GB
+        free_gb = free // (1024**3)
+        total_gb = total // (1024**3)
+        usage_percent = (used / total) * 100
+        
+        if usage_percent > 85:
+            logging.warning(f"High disk usage: {usage_percent:.1f}% ({free_gb}GB free)")
+            
+        if free_gb < 5:
+            logging.critical(f"Low disk space: {free_gb}GB remaining")
+            
+    except Exception as e:
+        logging.error(f"Disk space monitoring failed: {str(e)}")
+```
+
+### Monitoring Alerts
+
+#### Email Alerts (Optional)
+```python
+import smtplib
+from email.mime.text import MIMEText
+
+def send_alert(subject: str, message: str):
+    """Send email alert for critical issues"""
+    try:
+        smtp_server = os.environ.get("SMTP_SERVER")
+        smtp_port = int(os.environ.get("SMTP_PORT", "587"))
+        smtp_user = os.environ.get("SMTP_USER")
+        smtp_pass = os.environ.get("SMTP_PASS")
+        alert_email = os.environ.get("ALERT_EMAIL")
+        
+        if not all([smtp_server, smtp_user, smtp_pass, alert_email]):
+            return  # Email not configured
+        
+        msg = MIMEText(message)
+        msg['Subject'] = f"[Transcription Service] {subject}"
+        msg['From'] = smtp_user
+        msg['To'] = alert_email
+        
+        with smtplib.SMTP(smtp_server, smtp_port) as server:
+            server.starttls()
+            server.login(smtp_user, smtp_pass)
+            server.send_message(msg)
+            
+    except Exception as e:
+        logging.error(f"Failed to send alert: {str(e)}")
+```
+
+---
+
+## 🤝 Contributing Guidelines
+
+### Development Workflow
+
+#### 1. Setup Development Environment
+```bash
+# Fork repository
+git clone https://github.com/your-username/azure-speech-transcription.git
+cd azure-speech-transcription
+
+# Create feature branch
+git checkout -b feature/your-feature-name
+
+# Setup environment
+python -m venv venv
+source venv/bin/activate  # or venv\Scripts\activate on Windows
+pip install -r requirements.txt
+pip install -r requirements-dev.txt  # Development dependencies
+```
+
+#### 2. Code Quality Standards
+
+**Python Style Guide**
+- Follow PEP 8 style guidelines
+- Use type hints for function parameters and return values
+- Maximum line length: 88 characters (Black formatter)
+- Use meaningful variable and function names
+
+**Code Formatting**
+```bash
+# Install development tools
+pip install black flake8 mypy pytest
+
+# Format code
+black .
+
+# Check style
+flake8 .
+
+# Type checking
+mypy app_core.py gradio_app.py
+
+# Run tests
+pytest tests/
+```
+
+**Documentation Standards**
+- All functions must have docstrings
+- Include type hints
+- Document complex logic with inline comments
+- Update README.md for new features
+
+```python
+def submit_transcription(
+    self, 
+    file_bytes: bytes, 
+    original_filename: str,
+    user_id: str,
+    language: str,
+    settings: Dict[str, Any]
+) -> str:
+    """
+    Submit a new transcription job for processing.
+    
+    Args:
+        file_bytes: Raw bytes of the audio/video file
+        original_filename: Original name of the uploaded file
+        user_id: ID of the authenticated user
+        language: Language code for transcription (e.g., 'en-US')
+        settings: Transcription configuration options
+        
+    Returns:
+        str: Unique job ID for tracking transcription progress
+        
+    Raises:
+        ValueError: If user_id is invalid or file is too large
+        ConnectionError: If Azure services are unavailable
+    """
+```
+
+#### 3. Testing Requirements
+
+**Unit Tests**
+```python
+import pytest
+from unittest.mock import Mock, patch
+from app_core import TranscriptionManager, AuthManager
+
+class TestAuthManager:
+    def test_password_hashing(self):
+        password = "TestPassword123"
+        hashed = AuthManager.hash_password(password)
+        
+        assert hashed != password
+        assert AuthManager.verify_password(password, hashed)
+        assert not AuthManager.verify_password("wrong", hashed)
+    
+    def test_email_validation(self):
+        assert AuthManager.validate_email("[email protected]")
+        assert not AuthManager.validate_email("invalid-email")
+        assert not AuthManager.validate_email("")
+
+class TestTranscriptionManager:
+    @patch('app_core.BlobServiceClient')
+    def test_submit_transcription(self, mock_blob):
+        manager = TranscriptionManager()
+        
+        job_id = manager.submit_transcription(
+            b"fake audio data",
+            "test.wav",
+            "user123",
+            "en-US",
+            {"audio_format": "wav"}
+        )
+        
+        assert isinstance(job_id, str)
+        assert len(job_id) == 36  # UUID length
+```
+
+**Integration Tests**
+```python
+class TestIntegration:
+    def test_full_transcription_workflow(self):
+        # Test complete workflow from upload to download
+        pass
+    
+    def test_user_registration_and_login(self):
+        # Test complete auth workflow
+        pass
+```
+
+#### 4. Commit Guidelines
+
+**Commit Message Format**
+```
+type(scope): brief description
+
+Detailed explanation of changes if needed
+
+- List specific changes
+- Include any breaking changes
+- Reference issue numbers
+
+Closes #123
+```
+
+**Commit Types**
+- `feat`: New feature
+- `fix`: Bug fix
+- `docs`: Documentation changes
+- `style`: Code style changes (formatting, etc.)
+- `refactor`: Code refactoring
+- `test`: Adding or updating tests
+- `chore`: Maintenance tasks
+
+**Example Commits**
+```bash
+git commit -m "feat(auth): add password strength validation
+
+- Implement password complexity requirements
+- Add client-side validation feedback
+- Update registration form UI
+
+Closes #45"
+
+git commit -m "fix(transcription): handle Azure service timeouts
+
+- Add retry logic for failed API calls
+- Improve error messages for users
+- Log detailed error information
+
+Fixes #67"
+```
+
+#### 5. Pull Request Process
+
+**PR Checklist**
+- [ ] Code follows style guidelines
+- [ ] All tests pass
+- [ ] Documentation updated
+- [ ] Security considerations reviewed
+- [ ] Performance impact assessed
+- [ ] Breaking changes documented
+
+**PR Template**
+```markdown
+## Description
+Brief description of changes
+
+## Type of Change
+- [ ] Bug fix
+- [ ] New feature
+- [ ] Breaking change
+- [ ] Documentation update
+
+## Testing
+- [ ] Unit tests added/updated
+- [ ] Integration tests pass
+- [ ] Manual testing completed
+
+## Security
+- [ ] No sensitive data exposed
+- [ ] Input validation implemented
+- [ ] Access controls maintained
+
+## Performance
+- [ ] No performance degradation
+- [ ] Database queries optimized
+- [ ] Resource usage considered
+```
+
+### Feature Development
+
+#### Adding New Languages
+```python
+# 1. Update environment configuration
+ALLOWED_LANGS = {
+    "en-US": "English (United States)",
+    "es-ES": "Spanish (Spain)",
+    "new-LANG": "New Language Name"
+}
+
+# 2. Test language support
+def test_new_language():
+    # Verify Azure Speech Services supports the language
+    # Test transcription accuracy
+    # Update documentation
+```
+
+#### Adding New Audio Formats
+```python
+# 1. Update supported formats list
+AUDIO_FORMATS = [
+    "wav", "mp3", "ogg", "opus", "flac", 
+    "new_format"  # Add new format
+]
+
+# 2. Update FFmpeg conversion logic
+def _convert_to_audio(self, input_path, output_path, audio_format="wav"):
+    if audio_format == "new_format":
+        # Add specific conversion parameters
+        cmd = ["ffmpeg", "-i", input_path, "-codec", "new_codec", output_path]
+```
+
+#### Adding New Features
+```python
+# 1. Database schema updates
+def upgrade_database_schema():
+    with self.get_connection() as conn:
+        conn.execute("""
+            ALTER TABLE transcriptions 
+            ADD COLUMN new_feature_data TEXT
+        """)
+
+# 2. API endpoint updates
+def new_feature_endpoint(user_id: str, feature_data: Dict) -> Dict:
+    # Implement new feature logic
+    pass
+
+# 3. UI updates
+def add_new_feature_ui():
+    new_feature_input = gr.Textbox(label="New Feature")
+    new_feature_button = gr.Button("Use New Feature")
+```
+
+---
+
+## ⚙️ Advanced Configuration
+
+### Performance Optimization
+
+#### Concurrent Processing
+```python
+# Adjust worker thread pool size based on server capacity
+class TranscriptionManager:
+    def __init__(self, max_workers: int = None):
+        if max_workers is None:
+            # Auto-detect based on CPU cores
+            import multiprocessing
+            max_workers = min(multiprocessing.cpu_count(), 10)
+        
+        self.executor = ThreadPoolExecutor(max_workers=max_workers)
+
+# Configure based on server specs
+# Small server: max_workers=2-4
+# Medium server: max_workers=5-8  
+# Large server: max_workers=10+
+```
+
+#### Database Optimization
+```python
+# SQLite performance tuning
+def configure_database_performance(db_path: str):
+    with sqlite3.connect(db_path) as conn:
+        # Enable WAL mode for better concurrency
+        conn.execute("PRAGMA journal_mode=WAL")
+        
+        # Increase cache size (in KB)
+        conn.execute("PRAGMA cache_size=10000")
+        
+        # Optimize synchronization
+        conn.execute("PRAGMA synchronous=NORMAL")
+        
+        # Enable foreign keys
+        conn.execute("PRAGMA foreign_keys=ON")
+```
+
+#### Memory Management
+```python
+# Large file handling
+def process_large_file(file_path: str):
+    """Process large files in chunks to manage memory"""
+    chunk_size = 64 * 1024 * 1024  # 64MB chunks
+    
+    with open(file_path, 'rb') as f:
+        while chunk := f.read(chunk_size):
+            # Process chunk
+            yield chunk
+
+# Garbage collection for long-running processes
+import gc
+
+def cleanup_memory():
+    """Force garbage collection"""
+    gc.collect()
+    
+# Schedule periodic cleanup
+schedule.every(30).minutes.do(cleanup_memory)
+```
+
+### Security Hardening
+
+#### Rate Limiting
+```python
+from collections import defaultdict
+from time import time
+
+class RateLimiter:
+    def __init__(self, max_requests: int = 100, window: int = 3600):
+        self.max_requests = max_requests
+        self.window = window
+        self.requests = defaultdict(list)
+    
+    def is_allowed(self, user_id: str) -> bool:
+        now = time()
+        user_requests = self.requests[user_id]
+        
+        # Clean old requests
+        user_requests[:] = [req_time for req_time in user_requests 
+                           if now - req_time < self.window]
+        
+        # Check limit
+        if len(user_requests) >= self.max_requests:
+            return False
+        
+        user_requests.append(now)
+        return True
+
+# Usage in endpoints
+rate_limiter = RateLimiter(max_requests=50, window=3600)  # 50 per hour
+
+def submit_transcription(self, user_id: str, ...):
+    if not rate_limiter.is_allowed(user_id):
+        raise Exception("Rate limit exceeded")
+```
+
+#### Input Sanitization
+```python
+import bleach
+import re
+
+def sanitize_filename(filename: str) -> str:
+    """Sanitize uploaded filename"""
+    # Remove path traversal attempts
+    filename = os.path.basename(filename)
+    
+    # Remove dangerous characters
+    filename = re.sub(r'[<>:"/\\|?*]', '_', filename)
+    
+    # Limit length
+    if len(filename) > 255:
+        name, ext = os.path.splitext(filename)
+        filename = name[:250] + ext
+    
+    return filename
+
+def sanitize_user_input(text: str) -> str:
+    """Sanitize user text input"""
+    # Remove HTML tags
+    text = bleach.clean(text, tags=[], strip=True)
+    
+    # Limit length
+    text = text[:1000]
+    
+    return text.strip()
+```
+
+#### Audit Logging
+```python
+class AuditLogger:
+    def __init__(self):
+        self.logger = logging.getLogger('audit')
+    
+    def log_user_action(self, user_id: str, action: str, details: Dict = None):
+        """Log user actions for security auditing"""
+        audit_entry = {
+            'timestamp': datetime.now().isoformat(),
+            'user_id': user_id,
+            'action': action,
+            'details': details or {},
+            'ip_address': self._get_client_ip(),
+            'user_agent': self._get_user_agent()
+        }
+        
+        self.logger.info(json.dumps(audit_entry))
+    
+    def _get_client_ip(self) -> str:
+        # Implementation depends on deployment setup
+        return "unknown"
+    
+    def _get_user_agent(self) -> str:
+        # Implementation depends on deployment setup
+        return "unknown"
+
+# Usage
+audit = AuditLogger()
+audit.log_user_action(user_id, "login", {"success": True})
+audit.log_user_action(user_id, "transcription_submit", {"filename": filename})
+```
+
+### Custom Extensions
+
+#### Plugin Architecture
+```python
+class TranscriptionPlugin:
+    """Base class for transcription plugins"""
+    
+    def pre_process(self, file_bytes: bytes, settings: Dict) -> bytes:
+        """Pre-process audio before transcription"""
+        return file_bytes
+    
+    def post_process(self, transcript: str, settings: Dict) -> str:
+        """Post-process transcript text"""
+        return transcript
+    
+    def get_name(self) -> str:
+        """Return plugin name"""
+        raise NotImplementedError
+
+class NoiseReductionPlugin(TranscriptionPlugin):
+    def get_name(self) -> str:
+        return "noise_reduction"
+    
+    def pre_process(self, file_bytes: bytes, settings: Dict) -> bytes:
+        # Implement noise reduction using audio processing library
+        # This is a placeholder - actual implementation would use
+        # libraries like librosa, scipy, or pydub
+        return file_bytes
+
+class LanguageDetectionPlugin(TranscriptionPlugin):
+    def get_name(self) -> str:
+        return "language_detection"
+    
+    def pre_process(self, file_bytes: bytes, settings: Dict) -> bytes:
+        # Detect language and update settings
+        detected_language = self._detect_language(file_bytes)
+        settings['detected_language'] = detected_language
+        return file_bytes
+
+# Plugin manager
+class PluginManager:
+    def __init__(self):
+        self.plugins: List[TranscriptionPlugin] = []
+    
+    def register_plugin(self, plugin: TranscriptionPlugin):
+        self.plugins.append(plugin)
+    
+    def apply_pre_processing(self, file_bytes: bytes, settings: Dict) -> bytes:
+        for plugin in self.plugins:
+            file_bytes = plugin.pre_process(file_bytes, settings)
+        return file_bytes
+    
+    def apply_post_processing(self, transcript: str, settings: Dict) -> str:
+        for plugin in self.plugins:
+            transcript = plugin.post_process(transcript, settings)
+        return transcript
+```
+
+---
+
+## 🔧 Troubleshooting
+
+### Common Development Issues
+
+#### Environment Setup Problems
+
+**Issue**: Azure connection fails
+```bash
+# Check environment variables
+python -c "
+import os
+print('AZURE_SPEECH_KEY:', bool(os.getenv('AZURE_SPEECH_KEY')))
+print('AZURE_BLOB_CONNECTION:', bool(os.getenv('AZURE_BLOB_CONNECTION')))
+"
+
+# Test Azure connection
+python -c "
+from azure.storage.blob import BlobServiceClient
+client = BlobServiceClient.from_connection_string('$AZURE_BLOB_CONNECTION')
+print('Containers:', list(client.list_containers()))
+"
+```
+
+**Issue**: FFmpeg not found
+```bash
+# Check FFmpeg installation
+ffmpeg -version
+
+# Install FFmpeg (Ubuntu/Debian)
+sudo apt update && sudo apt install ffmpeg
+
+# Install FFmpeg (Windows with Chocolatey)
+choco install ffmpeg
+
+# Install FFmpeg (macOS with Homebrew)
+brew install ffmpeg
+```
+
+**Issue**: Database initialization fails
+```python
+# Check database permissions
+import os
+db_dir = "database"
+if not os.path.exists(db_dir):
+    os.makedirs(db_dir)
+    print(f"Created directory: {db_dir}")
+
+# Test database creation
+import sqlite3
+conn = sqlite3.connect("database/test.db")
+conn.execute("CREATE TABLE test (id INTEGER)")
+conn.close()
+print("Database test successful")
+```
+
+#### Runtime Issues
+
+**Issue**: Memory errors with large files
+```python
+# Monitor memory usage
+import psutil
+
+def check_memory():
+    memory = psutil.virtual_memory()
+    print(f"Memory usage: {memory.percent}%")
+    print(f"Available: {memory.available / 1024**3:.1f}GB")
+
+# Implement file chunking for large uploads
+def process_large_file_in_chunks(file_path: str, chunk_size: int = 64*1024*1024):
+    with open(file_path, 'rb') as f:
+        while chunk := f.read(chunk_size):
+            yield chunk
+```
+
+**Issue**: Transcription jobs stuck
+```python
+# Check pending jobs
+def diagnose_stuck_jobs():
+    pending_jobs = transcription_manager.db.get_pending_jobs()
+    print(f"Pending jobs: {len(pending_jobs)}")
+    
+    for job in pending_jobs:
+        duration = datetime.now() - datetime.fromisoformat(job.created_at)
+        print(f"Job {job.job_id}: {job.status} for {duration}")
+        
+        if duration.total_seconds() > 3600:  # 1 hour
+            print(f"⚠️ Job {job.job_id} may be stuck")
+
+# Reset stuck jobs
+def reset_stuck_jobs():
+    with transcription_manager.db.get_connection() as conn:
+        conn.execute("""
+            UPDATE transcriptions 
+            SET status = 'pending', azure_trans_id = NULL
+            WHERE status = 'processing' 
+            AND created_at < datetime('now', '-1 hour')
+        """)
+```
+
+**Issue**: Azure API errors
+```python
+# Test Azure Speech Service
+def test_azure_speech():
+    try:
+        url = f"{AZURE_SPEECH_KEY_ENDPOINT}/speechtotext/v3.2/transcriptions"
+        headers = {"Ocp-Apim-Subscription-Key": AZURE_SPEECH_KEY}
+        
+        response = requests.get(url, headers=headers)
+        print(f"Status: {response.status_code}")
+        print(f"Response: {response.text[:200]}")
+        
+    except Exception as e:
+        print(f"Azure Speech test failed: {e}")
+
+# Check Azure service status
+def check_azure_status():
+    # Check Azure status page
+    status_url = "https://status.azure.com/en-us/status"
+    print(f"Check Azure status: {status_url}")
+```
+
+### Debugging Tools
+
+#### Debug Mode Configuration
+```python
+# Enable debug mode
+DEBUG = os.environ.get("DEBUG", "false").lower() == "true"
+
+if DEBUG:
+    logging.basicConfig(level=logging.DEBUG)
+    
+    # Enable Gradio debug mode
+    demo.launch(debug=True, show_error=True)
+```
+
+#### Performance Profiling
+```python
+import cProfile
+import pstats
+
+def profile_function(func):
+    """Profile function performance"""
+    profiler = cProfile.Profile()
+    
+    def wrapper(*args, **kwargs):
+        profiler.enable()
+        result = func(*args, **kwargs)
+        profiler.disable()
+        
+        # Print stats
+        stats = pstats.Stats(profiler)
+        stats.sort_stats('cumulative')
+        stats.print_stats(10)  # Top 10 functions
+        
+        return result
+    
+    return wrapper
+
+# Usage
+@profile_function
+def submit_transcription(self, ...):
+    # Function implementation
+    pass
+```
+
+#### Log Analysis
+```python
+def analyze_logs(log_file: str = "logs/transcription.log"):
+    """Analyze application logs for issues"""
+    
+    errors = []
+    warnings = []
+    performance_issues = []
+    
+    with open(log_file, 'r') as f:
+        for line in f:
+            if 'ERROR' in line:
+                errors.append(line.strip())
+            elif 'WARNING' in line:
+                warnings.append(line.strip())
+            elif 'completed in' in line:
+                # Extract timing information
+                import re
+                match = re.search(r'completed in (\d+\.\d+)s', line)
+                if match and float(match.group(1)) > 30:  # > 30 seconds
+                    performance_issues.append(line.strip())
+    
+    print(f"Errors: {len(errors)}")
+    print(f"Warnings: {len(warnings)}")
+    print(f"Performance issues: {len(performance_issues)}")
+    
+    return {
+        'errors': errors[-10:],  # Last 10 errors
+        'warnings': warnings[-10:],  # Last 10 warnings
+        'performance_issues': performance_issues[-10:]
+    }
+```
+
+### Production Troubleshooting
+
+#### Service Health Check
+```bash
+#!/bin/bash
+# health_check.sh
+
+echo "=== System Health Check ==="
+
+# Check service status
+systemctl is-active transcription
+systemctl is-active nginx
+
+# Check disk space
+df -h
+
+# Check memory usage
+free -h
+
+# Check CPU usage
+top -b -n1 | grep "Cpu(s)"
+
+# Check logs for errors
+tail -n 50 /home/transcription/app/logs/transcription.log | grep ERROR
+
+# Check Azure connectivity
+curl -s -o /dev/null -w "%{http_code}" https://azure.microsoft.com/
+
+echo "=== Health Check Complete ==="
+```
+
+#### Database Recovery
+```python
+def recover_database():
+    """Recover database from Azure backup"""
+    try:
+        # List available backups
+        container_client = blob_service.get_container_client(AZURE_CONTAINER)
+        backups = []
+        
+        for blob in container_client.list_blobs(name_starts_with="shared/backups/"):
+            backups.append({
+                'name': blob.name,
+                'modified': blob.last_modified
+            })
+        
+        # Sort by date (newest first)
+        backups.sort(key=lambda x: x['modified'], reverse=True)
+        
+        if not backups:
+            print("No backups found")
+            return
+        
+        # Download latest backup
+        latest_backup = backups[0]['name']
+        print(f"Restoring from: {latest_backup}")
+        
+        blob_client = blob_service.get_blob_client(
+            container=AZURE_CONTAINER,
+            blob=latest_backup
+        )
+        
+        # Download backup
+        with open("database/transcriptions_restored.db", "wb") as f:
+            f.write(blob_client.download_blob().readall())
+        
+        print("Database restored successfully")
+        print("Restart the application to use restored database")
+        
+    except Exception as e:
+        print(f"Database recovery failed: {str(e)}")
+```
+
+---
+
+## 📚 Additional Resources
+
+### Documentation Links
+- [Azure Speech Services Documentation](https://docs.microsoft.com/en-us/azure/cognitive-services/speech-service/)
+- [Azure Blob Storage Documentation](https://docs.microsoft.com/en-us/azure/storage/blobs/)
+- [Gradio Documentation](https://gradio.app/docs/)
+- [SQLite Documentation](https://www.sqlite.org/docs.html)
+- [FFmpeg Documentation](https://ffmpeg.org/documentation.html)
+
+### Useful Tools
+- **Azure Storage Explorer**: GUI for managing blob storage
+- **DB Browser for SQLite**: Visual database management
+- **Postman**: API testing and development
+- **Azure CLI**: Command-line Azure management
+- **Visual Studio Code**: Recommended IDE with Azure extensions
+
+### Community Resources
+- [Azure Speech Services Community](https://docs.microsoft.com/en-us/answers/topics/azure-speech-services.html)
+- [Gradio Community](https://github.com/gradio-app/gradio/discussions)
+- [Python Audio Processing Libraries](https://github.com/topics/audio-processing)
+
+---
+
+**This developer guide provides comprehensive information for setting up, developing, deploying, and maintaining the Azure Speech Transcription service. For additional help, refer to the linked documentation and community resources.** 🚀

USER.md

@@ -0,0 +1,459 @@
+# 🎙️ Azure Speech Transcription - User Guide
+
+## 📋 Table of Contents
+
+- [Getting Started](#-getting-started)
+- [Account Management](#-account-management)
+- [Using Transcription Services](#-using-transcription-services)
+- [Managing Your History](#-managing-your-history)
+- [Privacy & Data Control](#-privacy--data-control)
+- [Troubleshooting](#-troubleshooting)
+- [FAQ](#-faq)
+
+---
+
+## 🚀 Getting Started
+
+### What is Azure Speech Transcription?
+
+Azure Speech Transcription is a secure, PDPA-compliant service that converts your audio and video files into accurate text transcripts with speaker identification and precise timestamps. Your data is stored securely in your own private folder, ensuring complete privacy and compliance with data protection regulations.
+
+### Key Features
+
+- 🎯 **High Accuracy**: Powered by Microsoft Azure Speech Services
+- 🗣️ **Speaker Identification**: Automatically identifies different speakers
+- ⏰ **Precise Timestamps**: Every sentence includes exact timing (HH:MM:SS)
+- 🔒 **Privacy Compliant**: GDPR, PDPA, and data protection compliant
+- 📁 **Multiple Formats**: Supports audio and video files
+- 🌍 **Multi-Language**: Support for multiple languages
+- 📊 **Personal Dashboard**: Track your usage and history
+
+---
+
+## 🔐 Account Management
+
+### Creating Your Account
+
+1. **Go to Registration Tab**
+   - Open the application in your web browser
+   - Click on the "📝 Register" tab
+
+2. **Fill Your Information**
+   - **Email**: Enter a valid email address
+   - **Username**: Choose 3-30 characters (letters, numbers, underscore only)
+   - **Password**: Create a strong password (minimum 8 characters with uppercase, lowercase, and numbers)
+   - **Confirm Password**: Re-enter your password
+
+3. **Privacy Consents** (Required)
+   - ✅ **GDPR Consent**: Required for account creation
+   - ✅ **Data Retention**: Required for service functionality
+   - ☐ **Marketing**: Optional - receive updates and news
+
+4. **Create Account**
+   - Click "📝 Create Account"
+   - You'll see a success message
+   - Click "🔑 Go to Login" to proceed
+
+### Logging In
+
+1. **Go to Login Tab**
+   - Click on the "🔑 Login" tab
+
+2. **Enter Credentials**
+   - **Email or Username**: Enter either your email or username
+   - **Password**: Enter your password
+
+3. **Access Your Account**
+   - Click "🔑 Login"
+   - You'll be taken to your personal dashboard
+
+### Password Requirements
+
+Your password must include:
+- ✅ At least 8 characters
+- ✅ One uppercase letter (A-Z)
+- ✅ One lowercase letter (a-z)
+- ✅ One number (0-9)
+
+**Strong Password Examples:**
+- `MySecure123!`
+- `Transcribe2024#`
+- `AudioFiles456$`
+
+---
+
+## 🎙️ Using Transcription Services
+
+### Supported File Formats
+
+#### Audio Formats
+- **WAV** (recommended for fastest processing)
+- **MP3**, **OGG**, **OPUS**, **FLAC**
+- **WMA**, **AAC**, **M4A**, **AMR**
+- **WebM**, **Speex**
+
+#### Video Formats
+- **MP4**, **MOV**, **AVI**, **MKV**
+- **WMV**, **FLV**, **3GP**
+
+### File Size Limits
+- **Maximum**: 500MB per file
+- **Recommended**: Under 100MB for faster processing
+
+### Step-by-Step Transcription
+
+1. **Upload Your File**
+   - Click "Browse" under "Audio or Video File"
+   - Select your file from your computer
+   - Wait for upload confirmation
+
+2. **Configure Settings**
+   
+   **Basic Settings:**
+   - **Language**: Choose the primary language spoken
+   - **Output Format**: Select audio format (WAV recommended)
+
+   **Advanced Settings:**
+   - **Speaker Identification**: Enable to identify different speakers
+   - **Max Speakers**: Set expected number of speakers (1-10)
+   - **Timestamps**: Include precise timing information
+   - **Profanity Filter**: Choose how to handle profanity
+     - `Masked`: Replace with ***
+     - `Removed`: Remove completely
+     - `Raw`: Keep original
+   - **Punctuation**: Automatic punctuation insertion
+   - **Lexical Form**: Include alternative word forms
+
+3. **Start Transcription**
+   - Click "🚀 Start Transcription"
+   - Processing begins automatically
+   - Status updates every 10 seconds
+
+4. **Monitor Progress**
+   - **⏳ Queued**: Waiting to start
+   - **🔄 Processing**: Converting and analyzing
+   - **✅ Done**: Transcription complete
+
+5. **Download Results**
+   - View transcript in the text area
+   - Download the transcript file
+   - Access from your history anytime
+
+### Understanding Your Transcript
+
+Your transcript includes:
+- **Timestamps**: `[00:02:15]` (hours:minutes:seconds)
+- **Speaker Labels**: `Speaker 0:`, `Speaker 1:`, etc.
+- **Formatted Text**: Proper punctuation and capitalization
+
+**Example Output:**
+```
+[00:00:12] Speaker 0: Welcome to today's meeting. Let's start with the agenda.
+
+[00:00:18] Speaker 1: Thank you. First item is the quarterly review.
+
+[00:00:25] Speaker 0: Perfect. Let me share the presentation now.
+```
+
+---
+
+## 📚 Managing Your History
+
+### Viewing Your Transcriptions
+
+1. **Go to History Tab**
+   - Click "📚 My History" tab
+   - Your transcriptions appear automatically
+
+2. **Understanding the Table**
+   - **Date**: When transcription was created
+   - **Filename**: Original file name
+   - **Language**: Language used for transcription
+   - **Status**: Current status (Done, Processing, etc.)
+   - **Duration**: How long processing took
+   - **Job ID**: Unique identifier
+   - **Download**: Availability status
+
+3. **View Options**
+   - **Recent 20**: Default view of recent transcriptions
+   - **Show All**: Check box to see all your transcriptions
+
+### Downloading Transcripts
+
+**Method 1: From Results**
+- Complete transcription → Download button appears
+- Click to download immediately
+
+**Method 2: From History**
+- Go to "📚 My History" tab
+- Click "🔄 Refresh My History & Downloads"
+- Download files appear below the table
+- Click any available download link
+
+**Method 3: From Downloads Section**
+- Scroll to "📥 Download Your Completed Transcripts"
+- Available transcripts show as file download buttons
+- Click to download specific transcripts
+
+### Personal Statistics
+
+Your dashboard shows:
+- **Total Jobs**: All transcriptions you've created
+- **Completed**: Successfully finished transcriptions
+- **Processing**: Currently in progress
+- **Pending**: Waiting to start
+- **Failed**: Transcriptions that encountered errors
+- **Last 7 Days**: Recent activity
+
+---
+
+## 🔒 Privacy & Data Control
+
+### GDPR & Data Rights
+
+You have complete control over your data:
+
+#### 📊 Data Export
+1. Go to "🔒 Privacy & Data" tab
+2. Click "📦 Export My Data"
+3. Download complete data archive (JSON format)
+
+**What's Included:**
+- Account information
+- All transcription history
+- Usage statistics
+- Privacy preferences
+
+#### 📧 Marketing Preferences
+1. Go to "🔒 Privacy & Data" tab
+2. Update "Marketing Consent" checkbox
+3. Click "✅ Update Consent"
+
+#### 🗑️ Account Deletion
+1. Go to "🔒 Privacy & Data" tab
+2. Type "DELETE MY ACCOUNT" in confirmation field
+3. Click "🗑️ Delete My Account"
+
+**⚠️ Warning**: This permanently deletes:
+- Your account and profile
+- All transcription files
+- Usage history and statistics
+- Data stored in Azure
+
+### Data Security
+
+Your data is protected by:
+- **Encryption**: All data encrypted in transit and at rest
+- **Isolation**: Your files stored in private user folder
+- **Access Control**: Only you can access your data
+- **Compliance**: GDPR, PDPA, and privacy regulation compliant
+- **Audit Trail**: Complete logging for security
+
+### Where Your Data is Stored
+
+- **User Folder**: `users/{your-user-id}/`
+  - `audio/`: Processed audio files
+  - `transcripts/`: Text transcriptions
+  - `originals/`: Original uploaded files
+- **Location**: Secure Azure Blob Storage
+- **Retention**: Until you delete your account
+
+---
+
+## 🛠️ Troubleshooting
+
+### Common Issues
+
+#### Authentication Problems
+
+**Problem**: Can't log in
+- ✅ Check username/email spelling
+- ✅ Verify password (case-sensitive)
+- ✅ Ensure caps lock is off
+- ✅ Try password reset if available
+
+**Problem**: Registration fails
+- ✅ Check email format (must be valid email)
+- ✅ Username requirements (3-30 chars, alphanumeric + underscore)
+- ✅ Password requirements (8+ chars, mixed case, numbers)
+- ✅ Required consents must be checked
+
+#### File Upload Issues
+
+**Problem**: File won't upload
+- ✅ Check file size (max 500MB)
+- ✅ Verify file format is supported
+- ✅ Ensure stable internet connection
+- ✅ Try smaller file first
+
+**Problem**: Unsupported format error
+- ✅ Convert to supported format (WAV, MP3, MP4)
+- ✅ Check file isn't corrupted
+- ✅ Try different file
+
+#### Processing Issues
+
+**Problem**: Transcription stuck in "Processing"
+- ✅ Wait - large files take time
+- ✅ Check auto-refresh is active
+- ✅ Refresh browser if needed
+- ✅ Check Azure service status
+
+**Problem**: Transcription failed
+- ✅ Check error message for details
+- ✅ Verify audio quality is good
+- ✅ Try different audio format
+- ✅ Ensure speakers are clearly audible
+
+#### Results Issues
+
+**Problem**: Poor transcription quality
+- ✅ Use clear, high-quality audio
+- ✅ Minimize background noise
+- ✅ Ensure speakers speak clearly
+- ✅ Select correct language
+- ✅ Try WAV format for best results
+
+**Problem**: Speakers not identified correctly
+- ✅ Enable "Speaker Identification"
+- ✅ Set correct number of speakers
+- ✅ Ensure speakers have distinct voices
+- ✅ Minimize speaker overlap
+
+### Performance Tips
+
+#### For Best Results
+- **Audio Quality**: Use high-quality recordings
+- **File Format**: WAV files process fastest
+- **Speaker Separation**: Clear pauses between speakers
+- **Background Noise**: Minimize environmental noise
+- **Language Selection**: Choose correct primary language
+
+#### For Faster Processing
+- **File Size**: Smaller files process faster
+- **Format**: WAV > MP3 > other formats
+- **Settings**: Disable unused features
+- **Timing**: Process during off-peak hours
+
+---
+
+## ❓ FAQ
+
+### General Questions
+
+**Q: Is my data secure?**
+A: Yes, your data is stored in encrypted, user-separated Azure Blob Storage with enterprise-grade security.
+
+**Q: Can others see my transcriptions?**
+A: No, your data is completely private. Only you can access your transcriptions.
+
+**Q: How long are transcriptions stored?**
+A: Indefinitely, until you delete your account or individual transcriptions.
+
+**Q: Is there a usage limit?**
+A: Check with your administrator for any usage limits or quotas.
+
+### Technical Questions
+
+**Q: What languages are supported?**
+A: Multiple languages including English, Thai, Chinese, Japanese, Korean, Spanish, French, German, and others.
+
+**Q: How accurate are the transcriptions?**
+A: Very high accuracy using Microsoft Azure Speech Services, typically 85-95% depending on audio quality.
+
+**Q: Can I edit transcriptions?**
+A: You can copy and edit the text after download, but the original transcript is preserved.
+
+**Q: Do you store my original files?**
+A: Yes, originals are stored in your private folder and can be downloaded anytime.
+
+### Privacy Questions
+
+**Q: Can I export all my data?**
+A: Yes, use the "Export My Data" feature to download everything in JSON format.
+
+**Q: How do I delete my account?**
+A: Go to Privacy & Data tab and follow the account deletion process.
+
+**Q: What happens to my data if I delete my account?**
+A: All data is permanently deleted from Azure storage within 24 hours.
+
+**Q: Do you use my data for training?**
+A: No, your data is never used for training or shared with third parties.
+
+### Billing Questions
+
+**Q: How much does it cost?**
+A: Contact your administrator for pricing information.
+
+**Q: Are there free tiers available?**
+A: Depends on your organization's setup and Azure subscription.
+
+---
+
+## 📞 Getting Help
+
+### Support Resources
+
+1. **This User Guide**: Comprehensive information for all features
+2. **Error Messages**: Pay attention to specific error descriptions
+3. **System Status**: Check if Azure services are operational
+4. **Administrator**: Contact your system administrator for account issues
+
+### Reporting Issues
+
+When reporting problems, include:
+- **What you were trying to do**
+- **What happened instead**
+- **Error messages (exact text)**
+- **File type and size**
+- **Browser and operating system**
+- **Steps to reproduce the issue**
+
+---
+
+## 🎯 Tips for Success
+
+### Getting the Best Transcriptions
+
+1. **Audio Quality Matters**
+   - Use good microphones
+   - Record in quiet environments
+   - Ensure clear speech
+   - Avoid speaker overlap
+
+2. **File Preparation**
+   - Convert to WAV for best results
+   - Trim unnecessary silence
+   - Normalize audio levels
+   - Remove background music if possible
+
+3. **Settings Optimization**
+   - Choose correct language
+   - Set appropriate speaker count
+   - Enable relevant features only
+   - Use appropriate profanity filter
+
+4. **Workflow Efficiency**
+   - Process multiple files in batches
+   - Use consistent naming conventions
+   - Download transcripts promptly
+   - Keep originals as backups
+
+### Privacy Best Practices
+
+1. **Account Security**
+   - Use strong, unique passwords
+   - Log out when finished
+   - Don't share login credentials
+   - Review account regularly
+
+2. **Data Management**
+   - Export data periodically
+   - Delete unnecessary transcriptions
+   - Review privacy settings
+   - Understand data retention
+
+---
+
+**Welcome to Azure Speech Transcription! We hope this guide helps you make the most of our service. For the best experience, keep your audio quality high and your data organized.** 🎉

app_core.py

@@ -0,0 +1,1133 @@
+import os
+import time
+import uuid
+import json
+import requests
+import subprocess
+import asyncio
+import threading
+import hashlib
+import re
+from datetime import datetime, timedelta
+from typing import Optional, Dict, List, Tuple
+from dataclasses import dataclass, asdict
+from concurrent.futures import ThreadPoolExecutor
+import sqlite3
+from contextlib import contextmanager
+from dotenv import load_dotenv
+from azure.storage.blob import BlobServiceClient
+import tempfile
+import shutil
+
+# Load Environment
+load_dotenv()
+
+def _require_env_var(varname):
+    value = os.environ.get(varname)
+    if not value or value.strip() == "" or "your" in value.lower():
+        raise ValueError(f"Environment variable {varname} is missing or invalid. Check your .env file.")
+    return value
+
+# Environment variables
+AZURE_SPEECH_KEY = _require_env_var("AZURE_SPEECH_KEY")
+AZURE_SPEECH_KEY_ENDPOINT = _require_env_var("AZURE_SPEECH_KEY_ENDPOINT").rstrip('/')
+AZURE_REGION = _require_env_var("AZURE_REGION")
+AZURE_BLOB_CONNECTION = _require_env_var("AZURE_BLOB_CONNECTION")
+AZURE_CONTAINER = _require_env_var("AZURE_CONTAINER")
+AZURE_BLOB_SAS_TOKEN = _require_env_var("AZURE_BLOB_SAS_TOKEN")
+ALLOWED_LANGS = json.loads(os.environ.get("ALLOWED_LANGS", "{}"))
+API_VERSION = os.environ.get("API_VERSION", "v3.2")
+
+# Directories
+UPLOAD_DIR = "uploads"
+DB_DIR = "database"
+os.makedirs(UPLOAD_DIR, exist_ok=True)
+os.makedirs(DB_DIR, exist_ok=True)
+
+AUDIO_FORMATS = [
+    "wav", "mp3", "ogg", "opus", "flac", "wma", "aac", "alaw", "mulaw", "amr", "webm", "speex"
+]
+
+@dataclass
+class User:
+    user_id: str
+    email: str
+    username: str
+    password_hash: str
+    created_at: str
+    last_login: Optional[str] = None
+    is_active: bool = True
+    gdpr_consent: bool = False
+    data_retention_agreed: bool = False
+    marketing_consent: bool = False
+
+@dataclass
+class TranscriptionJob:
+    job_id: str
+    user_id: str  # Changed from user_session to user_id for proper authentication
+    original_filename: str
+    audio_url: str
+    language: str
+    status: str  # pending, processing, completed, failed
+    created_at: str
+    completed_at: Optional[str] = None
+    transcript_text: Optional[str] = None
+    transcript_url: Optional[str] = None
+    error_message: Optional[str] = None
+    azure_trans_id: Optional[str] = None
+    settings: Optional[Dict] = None
+
+class AuthManager:
+    """Handle user authentication and PDPA compliance"""
+    
+    @staticmethod
+    def hash_password(password: str) -> str:
+        """Hash password using SHA-256 with salt"""
+        salt = "azure_speech_transcription_salt_2024"  # In production, use environment variable
+        return hashlib.sha256((password + salt).encode()).hexdigest()
+    
+    @staticmethod
+    def verify_password(password: str, password_hash: str) -> bool:
+        """Verify password against hash"""
+        return AuthManager.hash_password(password) == password_hash
+    
+    @staticmethod
+    def validate_email(email: str) -> bool:
+        """Validate email format"""
+        pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
+        return re.match(pattern, email) is not None
+    
+    @staticmethod
+    def validate_username(username: str) -> bool:
+        """Validate username format"""
+        # Username: 3-30 characters, alphanumeric and underscore only
+        pattern = r'^[a-zA-Z0-9_]{3,30}$'
+        return re.match(pattern, username) is not None
+    
+    @staticmethod
+    def validate_password(password: str) -> Tuple[bool, str]:
+        """Validate password strength"""
+        if len(password) < 8:
+            return False, "Password must be at least 8 characters long"
+        if not re.search(r'[A-Z]', password):
+            return False, "Password must contain at least one uppercase letter"
+        if not re.search(r'[a-z]', password):
+            return False, "Password must contain at least one lowercase letter"
+        if not re.search(r'\d', password):
+            return False, "Password must contain at least one number"
+        return True, "Password is valid"
+
+class DatabaseManager:
+    def __init__(self, db_path: str = None):
+        self.db_path = db_path or os.path.join(DB_DIR, "transcriptions.db")
+        self.blob_service = BlobServiceClient.from_connection_string(AZURE_BLOB_CONNECTION)
+        self.db_blob_name = "shared/database/transcriptions.db"  # Shared database location
+        self._lock = threading.Lock()
+        self._last_backup_time = 0
+        self._backup_interval = 30  # Backup every 30 seconds at most
+        
+        # Download existing database from blob storage or create new one
+        self.init_database()
+    
+    def _download_db_from_blob(self):
+        """Download database from Azure Blob Storage if it exists"""
+        try:
+            blob_client = self.blob_service.get_blob_client(container=AZURE_CONTAINER, blob=self.db_blob_name)
+            
+            # Check if blob exists
+            if blob_client.exists():
+                print("📥 Downloading existing shared database from Azure Blob Storage...")
+                
+                # Create temporary file
+                with tempfile.NamedTemporaryFile(delete=False) as temp_file:
+                    temp_path = temp_file.name
+                
+                # Download blob to temporary file
+                with open(temp_path, "wb") as download_file:
+                    download_file.write(blob_client.download_blob().readall())
+                
+                # Move to final location
+                os.makedirs(os.path.dirname(self.db_path), exist_ok=True)
+                shutil.move(temp_path, self.db_path)
+                
+                print("✅ Shared database downloaded successfully")
+                return True
+            else:
+                print("📝 No existing shared database found in blob storage, will create new one")
+                return False
+                
+        except Exception as e:
+            print(f"⚠️ Warning: Could not download shared database from blob storage: {e}")
+            print("📝 Will create new local database")
+            return False
+    
+    def _upload_db_to_blob(self):
+        """Upload database to Azure Blob Storage with rate limiting"""
+        try:
+            current_time = time.time()
+            if current_time - self._last_backup_time < self._backup_interval:
+                return  # Skip backup if too recent
+            
+            if not os.path.exists(self.db_path):
+                return
+            
+            blob_client = self.blob_service.get_blob_client(container=AZURE_CONTAINER, blob=self.db_blob_name)
+            
+            with open(self.db_path, "rb") as data:
+                blob_client.upload_blob(data, overwrite=True)
+            
+            self._last_backup_time = current_time
+            
+        except Exception as e:
+            print(f"⚠️ Warning: Could not upload shared database to blob storage: {e}")
+    
+    @contextmanager
+    def get_connection(self):
+        with self._lock:
+            conn = sqlite3.connect(self.db_path, timeout=30.0)
+            conn.row_factory = sqlite3.Row
+            try:
+                yield conn
+            finally:
+                conn.close()
+                # Auto-backup after any database operation (rate limited)
+                threading.Thread(target=self._upload_db_to_blob, daemon=True).start()
+    
+    def init_database(self):
+        # Try to download existing database first
+        self._download_db_from_blob()
+        
+        # Initialize database structure
+        with self.get_connection() as conn:
+            # Users table
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS users (
+                    user_id TEXT PRIMARY KEY,
+                    email TEXT UNIQUE NOT NULL,
+                    username TEXT UNIQUE NOT NULL,
+                    password_hash TEXT NOT NULL,
+                    created_at TEXT NOT NULL,
+                    last_login TEXT,
+                    is_active BOOLEAN DEFAULT 1,
+                    gdpr_consent BOOLEAN DEFAULT 0,
+                    data_retention_agreed BOOLEAN DEFAULT 0,
+                    marketing_consent BOOLEAN DEFAULT 0
+                )
+            """)
+            
+            # Transcriptions table (updated to use user_id instead of user_session)
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS transcriptions (
+                    job_id TEXT PRIMARY KEY,
+                    user_id TEXT NOT NULL,
+                    original_filename TEXT NOT NULL,
+                    audio_url TEXT,
+                    language TEXT NOT NULL,
+                    status TEXT NOT NULL,
+                    created_at TEXT NOT NULL,
+                    completed_at TEXT,
+                    transcript_text TEXT,
+                    transcript_url TEXT,
+                    error_message TEXT,
+                    azure_trans_id TEXT,
+                    settings TEXT,
+                    FOREIGN KEY (user_id) REFERENCES users (user_id)
+                )
+            """)
+            
+            # Create indexes
+            conn.execute("CREATE INDEX IF NOT EXISTS idx_users_email ON users(email)")
+            conn.execute("CREATE INDEX IF NOT EXISTS idx_users_username ON users(username)")
+            conn.execute("CREATE INDEX IF NOT EXISTS idx_transcriptions_user_id ON transcriptions(user_id)")
+            conn.execute("CREATE INDEX IF NOT EXISTS idx_transcriptions_status ON transcriptions(status)")
+            conn.execute("CREATE INDEX IF NOT EXISTS idx_transcriptions_created_at ON transcriptions(created_at DESC)")
+            conn.execute("CREATE INDEX IF NOT EXISTS idx_transcriptions_user_created ON transcriptions(user_id, created_at DESC)")
+            
+            conn.commit()
+    
+    # User management methods
+    def create_user(self, email: str, username: str, password: str, gdpr_consent: bool = True, 
+                   data_retention_agreed: bool = True, marketing_consent: bool = False) -> Tuple[bool, str, Optional[str]]:
+        """Create new user account"""
+        try:
+            # Validate inputs
+            if not AuthManager.validate_email(email):
+                return False, "Invalid email format", None
+            
+            if not AuthManager.validate_username(username):
+                return False, "Username must be 3-30 characters, alphanumeric and underscore only", None
+            
+            is_valid, message = AuthManager.validate_password(password)
+            if not is_valid:
+                return False, message, None
+            
+            if not gdpr_consent:
+                return False, "GDPR consent is required to create an account", None
+            
+            if not data_retention_agreed:
+                return False, "Data retention agreement is required", None
+            
+            user_id = str(uuid.uuid4())
+            password_hash = AuthManager.hash_password(password)
+            
+            with self.get_connection() as conn:
+                # Check if email or username already exists
+                existing = conn.execute(
+                    "SELECT email, username FROM users WHERE email = ? OR username = ?",
+                    (email, username)
+                ).fetchone()
+                
+                if existing:
+                    if existing['email'] == email:
+                        return False, "Email already registered", None
+                    else:
+                        return False, "Username already taken", None
+                
+                # Create user
+                user = User(
+                    user_id=user_id,
+                    email=email,
+                    username=username,
+                    password_hash=password_hash,
+                    created_at=datetime.now().isoformat(),
+                    gdpr_consent=gdpr_consent,
+                    data_retention_agreed=data_retention_agreed,
+                    marketing_consent=marketing_consent
+                )
+                
+                conn.execute("""
+                    INSERT INTO users 
+                    (user_id, email, username, password_hash, created_at, is_active, 
+                     gdpr_consent, data_retention_agreed, marketing_consent)
+                    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+                """, (
+                    user.user_id, user.email, user.username, user.password_hash,
+                    user.created_at, user.is_active, user.gdpr_consent,
+                    user.data_retention_agreed, user.marketing_consent
+                ))
+                conn.commit()
+                
+                print(f"👤 New user registered: {username} ({email})")
+                return True, "Account created successfully", user_id
+                
+        except Exception as e:
+            print(f"❌ Error creating user: {str(e)}")
+            return False, f"Registration failed: {str(e)}", None
+    
+    def authenticate_user(self, login: str, password: str) -> Tuple[bool, str, Optional[User]]:
+        """Authenticate user by email or username"""
+        try:
+            with self.get_connection() as conn:
+                # Find user by email or username
+                user_row = conn.execute("""
+                    SELECT * FROM users 
+                    WHERE (email = ? OR username = ?) AND is_active = 1
+                """, (login, login)).fetchone()
+                
+                if not user_row:
+                    return False, "Invalid credentials", None
+                
+                # Verify password
+                if not AuthManager.verify_password(password, user_row['password_hash']):
+                    return False, "Invalid credentials", None
+                
+                # Update last login
+                conn.execute(
+                    "UPDATE users SET last_login = ? WHERE user_id = ?",
+                    (datetime.now().isoformat(), user_row['user_id'])
+                )
+                conn.commit()
+                
+                # Convert to User object
+                user = User(
+                    user_id=user_row['user_id'],
+                    email=user_row['email'],
+                    username=user_row['username'],
+                    password_hash=user_row['password_hash'],
+                    created_at=user_row['created_at'],
+                    last_login=datetime.now().isoformat(),
+                    is_active=bool(user_row['is_active']),
+                    gdpr_consent=bool(user_row['gdpr_consent']),
+                    data_retention_agreed=bool(user_row['data_retention_agreed']),
+                    marketing_consent=bool(user_row['marketing_consent'])
+                )
+                
+                print(f"🔐 User logged in: {user.username} ({user.email})")
+                return True, "Login successful", user
+                
+        except Exception as e:
+            print(f"❌ Authentication error: {str(e)}")
+            return False, f"Login failed: {str(e)}", None
+    
+    def get_user_by_id(self, user_id: str) -> Optional[User]:
+        """Get user by ID"""
+        try:
+            with self.get_connection() as conn:
+                user_row = conn.execute(
+                    "SELECT * FROM users WHERE user_id = ? AND is_active = 1",
+                    (user_id,)
+                ).fetchone()
+                
+                if user_row:
+                    return User(
+                        user_id=user_row['user_id'],
+                        email=user_row['email'],
+                        username=user_row['username'],
+                        password_hash=user_row['password_hash'],
+                        created_at=user_row['created_at'],
+                        last_login=user_row['last_login'],
+                        is_active=bool(user_row['is_active']),
+                        gdpr_consent=bool(user_row['gdpr_consent']),
+                        data_retention_agreed=bool(user_row['data_retention_agreed']),
+                        marketing_consent=bool(user_row['marketing_consent'])
+                    )
+        except Exception as e:
+            print(f"❌ Error getting user: {str(e)}")
+        return None
+    
+    def update_user_consent(self, user_id: str, marketing_consent: bool) -> bool:
+        """Update user marketing consent"""
+        try:
+            with self.get_connection() as conn:
+                conn.execute(
+                    "UPDATE users SET marketing_consent = ? WHERE user_id = ?",
+                    (marketing_consent, user_id)
+                )
+                conn.commit()
+                return True
+        except Exception as e:
+            print(f"❌ Error updating consent: {str(e)}")
+            return False
+    
+    def delete_user_account(self, user_id: str) -> bool:
+        """Delete user account and all associated data (GDPR compliance)"""
+        try:
+            with self.get_connection() as conn:
+                # Delete all transcriptions
+                conn.execute("DELETE FROM transcriptions WHERE user_id = ?", (user_id,))
+                # Deactivate user (for audit trail) rather than delete
+                conn.execute(
+                    "UPDATE users SET is_active = 0, email = ?, username = ? WHERE user_id = ?",
+                    (f"deleted_{user_id}@deleted.com", f"deleted_{user_id}", user_id)
+                )
+                conn.commit()
+                print(f"🗑️ User account deleted: {user_id}")
+                return True
+        except Exception as e:
+            print(f"❌ Error deleting user account: {str(e)}")
+            return False
+    
+    # Transcription methods (updated for authenticated users)
+    def save_job(self, job: TranscriptionJob):
+        with self.get_connection() as conn:
+            conn.execute("""
+                INSERT OR REPLACE INTO transcriptions 
+                (job_id, user_id, original_filename, audio_url, language, status, 
+                 created_at, completed_at, transcript_text, transcript_url, error_message, 
+                 azure_trans_id, settings)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """, (
+                job.job_id, job.user_id, job.original_filename, job.audio_url,
+                job.language, job.status, job.created_at, job.completed_at,
+                job.transcript_text, job.transcript_url, job.error_message,
+                job.azure_trans_id, json.dumps(job.settings) if job.settings else None
+            ))
+            conn.commit()
+    
+    def get_job(self, job_id: str) -> Optional[TranscriptionJob]:
+        with self.get_connection() as conn:
+            row = conn.execute(
+                "SELECT * FROM transcriptions WHERE job_id = ?", (job_id,)
+            ).fetchone()
+            if row:
+                return self._row_to_job(row)
+        return None
+    
+    def get_user_jobs(self, user_id: str, limit: int = 50) -> List[TranscriptionJob]:
+        """Get all jobs for a specific user - PDPA compliant"""
+        with self.get_connection() as conn:
+            rows = conn.execute("""
+                SELECT * FROM transcriptions 
+                WHERE user_id = ? 
+                ORDER BY created_at DESC 
+                LIMIT ?
+            """, (user_id, limit)).fetchall()
+            return [self._row_to_job(row) for row in rows]
+    
+    def get_user_jobs_paginated(self, user_id: str, offset: int = 0, limit: int = 20) -> List[TranscriptionJob]:
+        """Get paginated jobs for a specific user"""
+        with self.get_connection() as conn:
+            rows = conn.execute("""
+                SELECT * FROM transcriptions 
+                WHERE user_id = ? 
+                ORDER BY created_at DESC 
+                LIMIT ? OFFSET ?
+            """, (user_id, limit, offset)).fetchall()
+            return [self._row_to_job(row) for row in rows]
+    
+    def get_user_job_count(self, user_id: str) -> int:
+        """Get total job count for a user"""
+        with self.get_connection() as conn:
+            result = conn.execute("""
+                SELECT COUNT(*) FROM transcriptions 
+                WHERE user_id = ?
+            """, (user_id,)).fetchone()
+            return result[0] if result else 0
+    
+    def get_pending_jobs(self) -> List[TranscriptionJob]:
+        """Get pending jobs across all users for background processing"""
+        with self.get_connection() as conn:
+            rows = conn.execute(
+                "SELECT * FROM transcriptions WHERE status IN ('pending', 'processing')"
+            ).fetchall()
+            return [self._row_to_job(row) for row in rows]
+    
+    def get_user_stats(self, user_id: str) -> Dict:
+        """Get statistics for a specific user"""
+        with self.get_connection() as conn:
+            stats = {}
+            
+            # Total jobs
+            result = conn.execute("""
+                SELECT COUNT(*) FROM transcriptions WHERE user_id = ?
+            """, (user_id,)).fetchone()
+            stats['total_jobs'] = result[0] if result else 0
+            
+            # Jobs by status
+            result = conn.execute("""
+                SELECT status, COUNT(*) FROM transcriptions 
+                WHERE user_id = ? 
+                GROUP BY status
+            """, (user_id,)).fetchall()
+            stats['by_status'] = {row[0]: row[1] for row in result}
+            
+            # Recent activity (last 7 days)
+            week_ago = (datetime.now() - timedelta(days=7)).isoformat()
+            result = conn.execute("""
+                SELECT COUNT(*) FROM transcriptions 
+                WHERE user_id = ? AND created_at >= ?
+            """, (user_id, week_ago)).fetchone()
+            stats['recent_jobs'] = result[0] if result else 0
+            
+            return stats
+    
+    def export_user_data(self, user_id: str) -> Dict:
+        """Export all user data for GDPR compliance"""
+        try:
+            with self.get_connection() as conn:
+                # Get user info
+                user_row = conn.execute(
+                    "SELECT * FROM users WHERE user_id = ?", (user_id,)
+                ).fetchone()
+                
+                # Get all transcriptions
+                transcription_rows = conn.execute(
+                    "SELECT * FROM transcriptions WHERE user_id = ?", (user_id,)
+                ).fetchall()
+                
+                export_data = {
+                    "export_date": datetime.now().isoformat(),
+                    "user_info": dict(user_row) if user_row else {},
+                    "transcriptions": [dict(row) for row in transcription_rows],
+                    "statistics": self.get_user_stats(user_id)
+                }
+                
+                return export_data
+                
+        except Exception as e:
+            print(f"❌ Error exporting user data: {str(e)}")
+            return {}
+    
+    def _row_to_job(self, row) -> TranscriptionJob:
+        settings = json.loads(row['settings']) if row['settings'] else None
+        return TranscriptionJob(
+            job_id=row['job_id'],
+            user_id=row['user_id'],
+            original_filename=row['original_filename'],
+            audio_url=row['audio_url'],
+            language=row['language'],
+            status=row['status'],
+            created_at=row['created_at'],
+            completed_at=row['completed_at'],
+            transcript_text=row['transcript_text'],
+            transcript_url=row['transcript_url'],
+            error_message=row['error_message'],
+            azure_trans_id=row['azure_trans_id'],
+            settings=settings
+        )
+
+class TranscriptionManager:
+    def __init__(self):
+        self.db = DatabaseManager()
+        self.executor = ThreadPoolExecutor(max_workers=5)
+        self.blob_service = BlobServiceClient.from_connection_string(AZURE_BLOB_CONNECTION)
+        self._job_status_cache = {}  # Cache to track status changes
+        
+        # Start background worker
+        self.running = True
+        self.worker_thread = threading.Thread(target=self._background_worker, daemon=True)
+        self.worker_thread.start()
+    
+    def _get_user_blob_path(self, user_id: str, blob_type: str, filename: str) -> str:
+        """Generate user-specific blob path for PDPA compliance"""
+        # Create user-specific folder structure: users/{user_id}/{type}/{filename}
+        return f"users/{user_id}/{blob_type}/{filename}"
+    
+    def _log_status_change(self, job_id: str, old_status: str, new_status: str, filename: str = "", user_id: str = ""):
+        """Only log when status actually changes"""
+        cache_key = f"{job_id}_{old_status}_{new_status}"
+        if cache_key not in self._job_status_cache:
+            self._job_status_cache[cache_key] = True
+            user_display = f"[{user_id[:8]}...]" if user_id else ""
+            if filename:
+                print(f"🔄 {user_display} Job {job_id[:8]}... ({filename}): {old_status} → {new_status}")
+            else:
+                print(f"🔄 {user_display} Job {job_id[:8]}...: {old_status} → {new_status}")
+    
+    def _background_worker(self):
+        """Background worker to process pending transcriptions - minimal logging"""
+        iteration_count = 0
+        while self.running:
+            try:
+                pending_jobs = self.db.get_pending_jobs()
+                
+                # Only log if there are jobs to process
+                if pending_jobs and iteration_count % 6 == 0:  # Log every minute (6 * 10 seconds)
+                    active_jobs = len([j for j in pending_jobs if j.status == 'processing'])
+                    queued_jobs = len([j for j in pending_jobs if j.status == 'pending'])
+                    if active_jobs > 0 or queued_jobs > 0:
+                        print(f"📊 Background worker: {active_jobs} processing, {queued_jobs} queued")
+                
+                for job in pending_jobs:
+                    if job.status == 'pending':
+                        self.executor.submit(self._process_transcription_job, job.job_id)
+                    elif job.status == 'processing' and job.azure_trans_id:
+                        self.executor.submit(self._check_transcription_status, job.job_id)
+                
+                time.sleep(10)  # Check every 10 seconds
+                iteration_count += 1
+                
+            except Exception as e:
+                print(f"❌ Background worker error: {e}")
+                time.sleep(30)
+    
+    def submit_transcription(
+        self, 
+        file_bytes: bytes, 
+        original_filename: str,
+        user_id: str,  # Now requires authenticated user_id
+        language: str,
+        settings: Dict
+    ) -> str:
+        """Submit a new transcription job for authenticated user"""
+        job_id = str(uuid.uuid4())
+        
+        print(f"🚀 [{user_id[:8]}...] New transcription: {original_filename} ({len(file_bytes):,} bytes)")
+        
+        # Create job record
+        job = TranscriptionJob(
+            job_id=job_id,
+            user_id=user_id,
+            original_filename=original_filename,
+            audio_url="",  # Will be set after upload
+            language=language,
+            status="pending",
+            created_at=datetime.now().isoformat(),
+            settings=settings
+        )
+        
+        # Save job to database
+        self.db.save_job(job)
+        
+        # Submit file processing to thread pool
+        self.executor.submit(self._prepare_audio_file, job_id, file_bytes, original_filename, settings)
+        
+        return job_id
+    
+    def _prepare_audio_file(self, job_id: str, file_bytes: bytes, original_filename: str, settings: Dict):
+        """Prepare audio file and upload to user-specific blob storage path"""
+        try:
+            job = self.db.get_job(job_id)
+            if not job:
+                return
+            
+            user_id = job.user_id
+            
+            # Save original file
+            src_ext = original_filename.split('.')[-1].lower() if '.' in original_filename else "bin"
+            upload_path = os.path.join(UPLOAD_DIR, f"{job_id}_original.{src_ext}")
+            
+            with open(upload_path, "wb") as f:
+                f.write(file_bytes)
+            
+            # Determine if conversion is needed
+            audio_format = settings.get('audio_format', 'wav')
+            
+            # Check if file is already in target format and specs
+            if src_ext == audio_format and audio_format == 'wav':
+                # Check if it's already 16kHz mono (Azure Speech preferred format)
+                try:
+                    probe_cmd = [
+                        'ffprobe', '-v', 'quiet', '-print_format', 'json', 
+                        '-show_streams', upload_path
+                    ]
+                    result = subprocess.run(probe_cmd, capture_output=True, text=True, timeout=30)
+                    
+                    if result.returncode == 0:
+                        import json
+                        probe_data = json.loads(result.stdout)
+                        audio_stream = probe_data.get('streams', [{}])[0]
+                        
+                        sample_rate = int(audio_stream.get('sample_rate', 0))
+                        channels = int(audio_stream.get('channels', 0))
+                        
+                        # If already optimal format, use as-is
+                        if sample_rate == 16000 and channels == 1:
+                            out_path = upload_path  # Use original file
+                        else:
+                            print(f"🔄 [{user_id[:8]}...] Converting {original_filename} to 16kHz mono")
+                            out_path = os.path.join(UPLOAD_DIR, f"{job_id}_converted.{audio_format}")
+                            self._convert_to_audio(upload_path, out_path, audio_format)
+                    else:
+                        out_path = os.path.join(UPLOAD_DIR, f"{job_id}_converted.{audio_format}")
+                        self._convert_to_audio(upload_path, out_path, audio_format)
+                        
+                except Exception as e:
+                    print(f"⚠️ [{user_id[:8]}...] Audio probing failed for {original_filename}: {e}")
+                    out_path = os.path.join(UPLOAD_DIR, f"{job_id}_converted.{audio_format}")
+                    self._convert_to_audio(upload_path, out_path, audio_format)
+            else:
+                # Different format, need conversion
+                print(f"🔄 [{user_id[:8]}...] Converting {original_filename}: {src_ext} → {audio_format}")
+                out_path = os.path.join(UPLOAD_DIR, f"{job_id}_converted.{audio_format}")
+                
+                try:
+                    self._convert_to_audio(upload_path, out_path, audio_format)
+                except Exception as e:
+                    print(f"❌ [{user_id[:8]}...] Audio conversion failed for {original_filename}: {str(e)}")
+                    job.status = "failed"
+                    job.error_message = f"Audio conversion failed: {str(e)}"
+                    job.completed_at = datetime.now().isoformat()
+                    self.db.save_job(job)
+                    
+                    # Clean up files
+                    try:
+                        os.remove(upload_path)
+                    except:
+                        pass
+                    return
+            
+            # Upload to user-specific blob storage paths
+            try:
+                # Upload the processed audio file to user's audio folder
+                audio_blob_name = self._get_user_blob_path(user_id, "audio", f"{job_id}.{audio_format}")
+                audio_url = self._upload_blob(out_path, audio_blob_name)
+                
+                # Upload original file to user's originals folder
+                orig_blob_name = self._get_user_blob_path(user_id, "originals", f"{job_id}_{original_filename}")
+                self._upload_blob(upload_path if out_path == upload_path else upload_path, orig_blob_name)
+                
+                print(f"☁️ [{user_id[:8]}...] {original_filename} uploaded to user-specific blob storage")
+                
+                # Update job with audio URL
+                job.audio_url = audio_url
+                job.status = "pending"
+                self.db.save_job(job)
+                
+            except Exception as e:
+                print(f"❌ [{user_id[:8]}...] Blob upload failed for {original_filename}: {str(e)}")
+                job.status = "failed"
+                job.error_message = f"Blob storage upload failed: {str(e)}"
+                job.completed_at = datetime.now().isoformat()
+                self.db.save_job(job)
+                
+            # Clean up local files
+            try:
+                if os.path.exists(upload_path):
+                    os.remove(upload_path)
+                if out_path != upload_path and os.path.exists(out_path):
+                    os.remove(out_path)
+            except Exception as e:
+                print(f"⚠️ [{user_id[:8]}...] Warning: Could not clean up local files for {original_filename}: {e}")
+                
+        except Exception as e:
+            print(f"❌ File preparation error for {original_filename}: {e}")
+            job = self.db.get_job(job_id)
+            if job:
+                job.status = "failed"
+                job.error_message = f"File preparation failed: {str(e)}"
+                job.completed_at = datetime.now().isoformat()
+                self.db.save_job(job)
+    
+    def _process_transcription_job(self, job_id: str):
+        """Process a transcription job - minimal logging"""
+        try:
+            job = self.db.get_job(job_id)
+            if not job or job.status != 'pending' or not job.audio_url:
+                return
+            
+            old_status = job.status
+            # Update status to processing
+            job.status = "processing"
+            self.db.save_job(job)
+            
+            self._log_status_change(job_id, old_status, job.status, job.original_filename, job.user_id)
+            
+            # Create Azure transcription
+            settings = job.settings or {}
+            azure_trans_id = self._create_transcription(
+                job.audio_url,
+                job.language,
+                settings.get('diarization_enabled', False),
+                settings.get('speakers', 2),
+                settings.get('profanity', 'masked'),
+                settings.get('punctuation', 'automatic'),
+                settings.get('timestamps', True),
+                settings.get('lexical', False),
+                settings.get('language_id_enabled', False),
+                settings.get('candidate_locales', None)
+            )
+            
+            # Update job with Azure transcription ID
+            job.azure_trans_id = azure_trans_id
+            self.db.save_job(job)
+            
+        except Exception as e:
+            print(f"❌ Transcription submission failed for job {job_id[:8]}...: {str(e)}")
+            job = self.db.get_job(job_id)
+            if job:
+                old_status = job.status
+                job.status = "failed"
+                job.error_message = f"Transcription submission failed: {str(e)}"
+                job.completed_at = datetime.now().isoformat()
+                self.db.save_job(job)
+                self._log_status_change(job_id, old_status, job.status, job.original_filename, job.user_id)
+    
+    def _check_transcription_status(self, job_id: str):
+        """Check status of Azure transcription - minimal logging"""
+        try:
+            job = self.db.get_job(job_id)
+            if not job or job.status != 'processing' or not job.azure_trans_id:
+                return
+            
+            # Check Azure transcription status
+            url = f"{AZURE_SPEECH_KEY_ENDPOINT}/speechtotext/{API_VERSION}/transcriptions/{job.azure_trans_id}"
+            headers = {"Ocp-Apim-Subscription-Key": AZURE_SPEECH_KEY}
+            
+            r = requests.get(url, headers=headers)
+            data = r.json()
+            
+            if data.get("status") == "Succeeded":
+                # Get transcription result
+                content_url = self._get_transcription_result_url(job.azure_trans_id)
+                if content_url:
+                    transcript = self._fetch_transcript(content_url)
+                    
+                    # Save transcript to user-specific blob storage
+                    transcript_blob_name = self._get_user_blob_path(job.user_id, "transcripts", f"{job_id}.txt")
+                    transcript_path = os.path.join(UPLOAD_DIR, f"{job_id}_transcript.txt")
+                    
+                    with open(transcript_path, "w", encoding="utf-8") as f:
+                        f.write(transcript)
+                    
+                    transcript_url = self._upload_blob(transcript_path, transcript_blob_name)
+                    
+                    # Update job
+                    old_status = job.status
+                    job.status = "completed"
+                    job.transcript_text = transcript
+                    job.transcript_url = transcript_url
+                    job.completed_at = datetime.now().isoformat()
+                    self.db.save_job(job)
+                    
+                    self._log_status_change(job_id, old_status, job.status, job.original_filename, job.user_id)
+                    print(f"✅ [{job.user_id[:8]}...] Transcription completed: {job.original_filename}")
+                    
+                    # Clean up
+                    try:
+                        os.remove(transcript_path)
+                    except:
+                        pass
+                        
+            elif data.get("status") in ("Failed", "FailedWithPartialResults"):
+                error_message = ""
+                if "properties" in data and "error" in data["properties"]:
+                    error_message = data["properties"]["error"].get("message", "")
+                elif "error" in data:
+                    error_message = data["error"].get("message", "")
+                
+                old_status = job.status
+                job.status = "failed"
+                job.error_message = f"Azure transcription failed: {error_message}"
+                job.completed_at = datetime.now().isoformat()
+                self.db.save_job(job)
+                
+                self._log_status_change(job_id, old_status, job.status, job.original_filename, job.user_id)
+                print(f"❌ [{job.user_id[:8]}...] Transcription failed: {job.original_filename} - {error_message}")
+                
+        except Exception as e:
+            print(f"❌ Status check failed for job {job_id[:8]}...: {str(e)}")
+            job = self.db.get_job(job_id)
+            if job:
+                old_status = job.status
+                job.status = "failed"
+                job.error_message = f"Status check failed: {str(e)}"
+                job.completed_at = datetime.now().isoformat()
+                self.db.save_job(job)
+                self._log_status_change(job_id, old_status, job.status, job.original_filename, job.user_id)
+    
+    def get_job_status(self, job_id: str) -> Optional[TranscriptionJob]:
+        """Get current job status"""
+        return self.db.get_job(job_id)
+    
+    def get_user_history(self, user_id: str, limit: int = 50) -> List[TranscriptionJob]:
+        """Get user's transcription history - PDPA compliant"""
+        return self.db.get_user_jobs(user_id, limit)
+    
+    def get_user_history_paginated(self, user_id: str, offset: int = 0, limit: int = 20) -> List[TranscriptionJob]:
+        """Get paginated user history for large datasets"""
+        return self.db.get_user_jobs_paginated(user_id, offset, limit)
+    
+    def get_user_stats(self, user_id: str) -> Dict:
+        """Get user statistics"""
+        return self.db.get_user_stats(user_id)
+    
+    def download_transcript(self, job_id: str, user_id: str) -> Optional[str]:
+        """Download transcript content - with user verification for PDPA compliance"""
+        job = self.db.get_job(job_id)
+        if job and job.user_id == user_id and job.transcript_text:
+            return job.transcript_text
+        return None
+    
+    # Authentication methods
+    def register_user(self, email: str, username: str, password: str, gdpr_consent: bool = True,
+                     data_retention_agreed: bool = True, marketing_consent: bool = False) -> Tuple[bool, str, Optional[str]]:
+        """Register new user"""
+        return self.db.create_user(email, username, password, gdpr_consent, data_retention_agreed, marketing_consent)
+    
+    def login_user(self, login: str, password: str) -> Tuple[bool, str, Optional[User]]:
+        """Login user"""
+        return self.db.authenticate_user(login, password)
+    
+    def get_user(self, user_id: str) -> Optional[User]:
+        """Get user by ID"""
+        return self.db.get_user_by_id(user_id)
+    
+    def update_user_consent(self, user_id: str, marketing_consent: bool) -> bool:
+        """Update user marketing consent"""
+        return self.db.update_user_consent(user_id, marketing_consent)
+    
+    def export_user_data(self, user_id: str) -> Dict:
+        """Export all user data for GDPR compliance"""
+        return self.db.export_user_data(user_id)
+    
+    def delete_user_account(self, user_id: str) -> bool:
+        """Delete user account and all data"""
+        return self.db.delete_user_account(user_id)
+    
+    # Helper methods remain the same
+    def _convert_to_audio(self, input_path, output_path, audio_format="wav"):
+        """Convert audio/video file to specified audio format - minimal logging"""
+        os.makedirs(os.path.dirname(output_path), exist_ok=True)
+        
+        if audio_format in {"wav", "alaw", "mulaw"}:
+            cmd = ["ffmpeg", "-y", "-i", input_path, "-ar", "16000", "-ac", "1", output_path]
+        else:
+            cmd = ["ffmpeg", "-y", "-i", input_path, output_path]
+        
+        try:
+            result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=300, text=True)
+            
+            if result.returncode != 0:
+                raise Exception(f"FFmpeg conversion failed: {result.stderr}")
+                
+            if not os.path.exists(output_path) or os.path.getsize(output_path) == 0:
+                raise Exception(f"Output file was not created or is empty: {output_path}")
+            
+        except subprocess.TimeoutExpired:
+            raise Exception(f"FFmpeg conversion timed out after 5 minutes")
+        except Exception as e:
+            if "FFmpeg conversion failed" in str(e):
+                raise
+            else:
+                raise Exception(f"FFmpeg error: {str(e)}")
+    
+    def _upload_blob(self, local_file, blob_name):
+        blob_client = self.blob_service.get_blob_client(container=AZURE_CONTAINER, blob=blob_name)
+        with open(local_file, "rb") as data:
+            blob_client.upload_blob(data, overwrite=True)
+        sas = AZURE_BLOB_SAS_TOKEN.lstrip("?")
+        return f"{blob_client.url}?{sas}"
+    
+    def _create_transcription(self, audio_url, language, diarization_enabled, speakers, 
+                            profanity, punctuation, timestamps, lexical, 
+                            language_id_enabled=False, candidate_locales=None):
+        url = f"{AZURE_SPEECH_KEY_ENDPOINT}/speechtotext/{API_VERSION}/transcriptions"
+        headers = {
+            "Ocp-Apim-Subscription-Key": AZURE_SPEECH_KEY,
+            "Content-Type": "application/json"
+        }
+
+        properties = {
+            "profanityFilterMode": profanity,
+            "punctuationMode": punctuation,
+            "wordLevelTimestampsEnabled": timestamps,
+            "displayFormWordLevelTimestampsEnabled": timestamps,
+            "lexical": lexical
+        }
+        if diarization_enabled:
+            properties["diarizationEnabled"] = True
+            properties["diarization"] = {
+                "speakers": {
+                    "minCount": 1,
+                    "maxCount": int(speakers)
+                }
+            }
+        if language_id_enabled and candidate_locales:
+            properties["languageIdentification"] = {
+                "mode": "continuous",
+                "candidateLocales": candidate_locales
+            }
+        
+        properties = {k: v for k, v in properties.items() if v is not None}
+        body = {
+            "displayName": f"Transcription_{uuid.uuid4()}",
+            "description": "Batch speech-to-text with advanced options",
+            "locale": language,
+            "contentUrls": [audio_url],
+            "properties": properties,
+            "customProperties": {}
+        }
+        r = requests.post(url, headers=headers, json=body)
+        r.raise_for_status()
+        trans_id = r.headers["Location"].split("/")[-1].split("?")[0]
+        return trans_id
+    
+    def _get_transcription_result_url(self, trans_id):
+        url = f"{AZURE_SPEECH_KEY_ENDPOINT}/speechtotext/{API_VERSION}/transcriptions/{trans_id}"
+        headers = {"Ocp-Apim-Subscription-Key": AZURE_SPEECH_KEY}
+        
+        r = requests.get(url, headers=headers)
+        data = r.json()
+        
+        if data.get("status") == "Succeeded":
+            files_url = None
+            if "links" in data and "files" in data["links"]:
+                files_url = data["links"]["files"]
+            if files_url:
+                r2 = requests.get(files_url, headers=headers)
+                file_list = r2.json().get("values", [])
+                for f in file_list:
+                    if f.get("kind", "").lower() == "transcription":
+                        return f["links"]["contentUrl"]
+        return None
+    
+    def _fetch_transcript(self, content_url):
+        """Enhanced transcript fetching with improved timestamp handling"""
+        r = requests.get(content_url)
+        try:
+            j = r.json()
+            out = []
+            
+            def get_text(phrase):
+                if 'nBest' in phrase and phrase['nBest']:
+                    return phrase['nBest'][0].get('display', '') or phrase.get('display', '')
+                return phrase.get('display', '')
+
+            def safe_offset(val):
+                try:
+                    return int(val)
+                except (ValueError, TypeError):
+                    return None
+
+            def format_time(seconds):
+                """Format seconds into HH:MM:SS format"""
+                try:
+                    td = timedelta(seconds=int(seconds))
+                    hours, remainder = divmod(td.total_seconds(), 3600)
+                    minutes, seconds = divmod(remainder, 60)
+                    return f"{int(hours):02d}:{int(minutes):02d}:{int(seconds):02d}"
+                except:
+                    return "00:00:00"
+
+            # Check if this is a diarization result or regular transcription
+            if 'recognizedPhrases' in j:
+                for phrase in j['recognizedPhrases']:
+                    speaker_id = phrase.get('speaker', 0)
+                    text = get_text(phrase)
+                    
+                    if not text.strip():
+                        continue
+                    
+                    # Try to get timestamp from multiple possible locations
+                    timestamp_seconds = None
+                    
+                    if 'offset' in phrase and phrase['offset'] is not None:
+                        offset_100ns = safe_offset(phrase['offset'])
+                        if offset_100ns is not None:
+                            timestamp_seconds = offset_100ns / 10_000_000
+                    
+                    if timestamp_seconds is None and 'words' in phrase and phrase['words']:
+                        first_word = phrase['words'][0]
+                        if 'offset' in first_word and first_word['offset'] is not None:
+                            offset_100ns = safe_offset(first_word['offset'])
+                            if offset_100ns is not None:
+                                timestamp_seconds = offset_100ns / 10_000_000
+                    
+                    if timestamp_seconds is None and 'offsetInTicks' in phrase:
+                        offset_ticks = safe_offset(phrase['offsetInTicks'])
+                        if offset_ticks is not None:
+                            timestamp_seconds = offset_ticks / 10_000_000
+                    
+                    # Format output based on whether we have speaker diarization and timestamps
+                    if timestamp_seconds is not None:
+                        time_str = format_time(timestamp_seconds)
+                        if 'speaker' in phrase:
+                            out.append(f"[{time_str}] Speaker {speaker_id}: {text}")
+                        else:
+                            out.append(f"[{time_str}] {text}")
+                    else:
+                        if 'speaker' in phrase:
+                            out.append(f"Speaker {speaker_id}: {text}")
+                        else:
+                            out.append(text)
+                
+                if out:
+                    return '\n\n'.join(out)
+            
+            # Fallback: handle combined results or other formats
+            if 'combinedRecognizedPhrases' in j:
+                combined_results = []
+                for combined_phrase in j['combinedRecognizedPhrases']:
+                    text = combined_phrase.get('display', '')
+                    if text.strip():
+                        combined_results.append(text)
+                
+                if combined_results:
+                    return '\n\n'.join(combined_results)
+            
+            # Last resort: return raw JSON for debugging
+            return json.dumps(j, ensure_ascii=False, indent=2)
+            
+        except Exception as e:
+            return f"Unable to parse transcription result: {str(e)}\n\nRaw response: {r.text[:1000]}..."
+
+# Global transcription manager instance
+transcription_manager = TranscriptionManager()
+
+# Backward compatibility functions
+def allowed_file(filename):
+    """Check if file extension is supported"""
+    if not filename or filename in ["upload.unknown", ""]:
+        return True  # Let FFmpeg handle unknown formats
+    
+    if '.' not in filename:
+        return True  # No extension, let FFmpeg try
+    
+    ext = filename.rsplit('.', 1)[1].lower()
+    supported_extensions = set(AUDIO_FORMATS) | {
+        'mp4', 'mov', 'avi', 'mkv', 'webm', 'm4a', '3gp', 'f4v', 
+        'wmv', 'asf', 'rm', 'rmvb', 'flv', 'mpg', 'mpeg', 'mts', 'vob'
+    }
+    
+    return ext in supported_extensions

gradio_app.py

@@ -0,0 +1,1471 @@
+import gradio as gr
+import time
+import json
+import os
+import subprocess
+from datetime import datetime, timedelta
+from typing import List, Tuple, Optional
+from app_core import (
+    ALLOWED_LANGS, AUDIO_FORMATS, transcription_manager, 
+    allowed_file, User
+)
+
+def format_status(status):
+    """Convert status to user-friendly format"""
+    status_map = {
+        'pending': '⏳ Queued',
+        'processing': '🔄 Processing',
+        'completed': '✅ Done',
+        'failed': '❌ Failed'
+    }
+    return status_map.get(status, status)
+
+def format_processing_time(created_at, completed_at=None):
+    """Calculate and format processing time"""
+    try:
+        start_time = datetime.fromisoformat(created_at)
+        if completed_at:
+            end_time = datetime.fromisoformat(completed_at)
+            duration = end_time - start_time
+        else:
+            duration = datetime.now() - start_time
+        
+        total_seconds = int(duration.total_seconds())
+        if total_seconds < 60:
+            return f"{total_seconds}s"
+        elif total_seconds < 3600:
+            minutes = total_seconds // 60
+            seconds = total_seconds % 60
+            return f"{minutes}m {seconds}s"
+        else:
+            hours = total_seconds // 3600
+            minutes = (total_seconds % 3600) // 60
+            return f"{hours}h {minutes}m"
+    except:
+        return "Unknown"
+
+def get_user_stats_display(user: User):
+    """Get user statistics for display"""
+    if not user:
+        return "👤 Please log in to view statistics"
+    
+    try:
+        stats = transcription_manager.get_user_stats(user.user_id)
+        
+        total = stats.get('total_jobs', 0)
+        recent = stats.get('recent_jobs', 0)
+        by_status = stats.get('by_status', {})
+        
+        completed = by_status.get('completed', 0)
+        processing = by_status.get('processing', 0)
+        pending = by_status.get('pending', 0)
+        failed = by_status.get('failed', 0)
+        
+        stats_text = f"👤 {user.username} | 📊 Total: {total} | ✅ Completed: {completed}"
+        if processing > 0:
+            stats_text += f" | 🔄 Processing: {processing}"
+        if pending > 0:
+            stats_text += f" | ⏳ Pending: {pending}"
+        if failed > 0:
+            stats_text += f" | ❌ Failed: {failed}"
+        if recent > 0:
+            stats_text += f" | 📅 Last 7 days: {recent}"
+            
+        return stats_text
+        
+    except Exception as e:
+        return f"👤 {user.username} | Stats error: {str(e)}"
+
+# Authentication Functions
+def register_user(email, username, password, confirm_password, gdpr_consent, data_retention_consent, marketing_consent):
+    """Register new user account"""
+    try:
+        print(f"📝 Registration attempt for: {username} ({email})")
+        
+        # Validate inputs
+        if not email or not username or not password:
+            return "❌ All fields are required", gr.update(visible=False)
+        
+        if password != confirm_password:
+            return "❌ Passwords do not match", gr.update(visible=False)
+        
+        if not gdpr_consent:
+            return "❌ GDPR consent is required to create an account", gr.update(visible=False)
+        
+        if not data_retention_consent:
+            return "❌ Data retention agreement is required", gr.update(visible=False)
+        
+        # Attempt registration
+        success, message, user_id = transcription_manager.register_user(
+            email, username, password, gdpr_consent, data_retention_consent, marketing_consent
+        )
+        
+        print(f"📝 Registration result: success={success}, message={message}")
+        
+        if success:
+            print(f"✅ User registered successfully: {username}")
+            return f"✅ {message}! Please log in with your credentials.", gr.update(visible=True)
+        else:
+            print(f"❌ Registration failed: {message}")
+            return f"❌ {message}", gr.update(visible=False)
+            
+    except Exception as e:
+        print(f"❌ Registration error: {str(e)}")
+        return f"❌ Registration error: {str(e)}", gr.update(visible=False)
+
+def login_user(login, password):
+    """Login user"""
+    try:
+        print(f"🔐 Login attempt for: {login}")
+        
+        if not login or not password:
+            return "❌ Please enter both username/email and password", None, gr.update(visible=True), gr.update(visible=False), "👤 Please log in to view your statistics..."
+        
+        success, message, user = transcription_manager.login_user(login, password)
+        print(f"🔐 Login result: success={success}, message={message}")
+        
+        if success and user:
+            print(f"✅ User logged in successfully: {user.username}")
+            stats_display = get_user_stats_display(user)
+            return f"✅ Welcome back, {user.username}!", user, gr.update(visible=False), gr.update(visible=True), stats_display
+        else:
+            print(f"❌ Login failed: {message}")
+            return f"❌ {message}", None, gr.update(visible=True), gr.update(visible=False), "👤 Please log in to view your statistics..."
+            
+    except Exception as e:
+        print(f"❌ Login error: {str(e)}")
+        return f"❌ Login error: {str(e)}", None, gr.update(visible=True), gr.update(visible=False), "👤 Please log in to view your statistics..."
+
+def logout_user():
+    """Logout user"""
+    print("👋 User logged out")
+    return None, "👋 You have been logged out. Please log in to continue.", gr.update(visible=True), gr.update(visible=False), "👤 Please log in to view your statistics..."
+
+# Transcription Functions (require authentication)
+def submit_transcription(file, language, audio_format, diarization_enabled, speakers, 
+                        profanity, punctuation, timestamps, lexical, user):
+    """Submit transcription job - requires authenticated user"""
+    if not user:
+        return (
+            "❌ Please log in to submit transcriptions",
+            "",
+            gr.update(visible=False),
+            "",
+            {},
+            gr.update(visible=False),
+            gr.update()
+        )
+    
+    if file is None:
+        return (
+            "Please upload an audio or video file first.",
+            "",
+            gr.update(visible=False),
+            "",
+            {},
+            gr.update(visible=False),
+            gr.update()
+        )
+    
+    try:
+        # Get file data
+        try:
+            if isinstance(file, str):
+                if os.path.exists(file):
+                    with open(file, 'rb') as f:
+                        file_bytes = f.read()
+                    original_filename = os.path.basename(file)
+                else:
+                    return (
+                        "File not found. Please try uploading again.",
+                        "",
+                        gr.update(visible=False),
+                        "",
+                        {},
+                        gr.update(visible=False),
+                        gr.update()
+                    )
+            else:
+                file_path = str(file)
+                if os.path.exists(file_path):
+                    with open(file_path, 'rb') as f:
+                        file_bytes = f.read()
+                    original_filename = os.path.basename(file_path)
+                else:
+                    return (
+                        "Unable to process file. Please try again.",
+                        "",
+                        gr.update(visible=False),
+                        "",
+                        {},
+                        gr.update(visible=False),
+                        gr.update()
+                    )
+        except Exception as e:
+            return (
+                f"Error reading file: {str(e)}",
+                "",
+                gr.update(visible=False),
+                "",
+                {},
+                gr.update(visible=False),
+                gr.update()
+            )
+        
+        # Validate file
+        file_extension = original_filename.split('.')[-1].lower() if '.' in original_filename else ""
+        supported_extensions = set(AUDIO_FORMATS) | {
+            'mp4', 'mov', 'avi', 'mkv', 'webm', 'm4a', '3gp', 'f4v', 
+            'wmv', 'asf', 'rm', 'rmvb', 'flv', 'mpg', 'mpeg', 'mts', 'vob'
+        }
+        
+        if file_extension not in supported_extensions and file_extension != "":
+            return (
+                f"Unsupported file format: .{file_extension}",
+                "",
+                gr.update(visible=False),
+                "",
+                {},
+                gr.update(visible=False),
+                gr.update()
+            )
+        
+        # Basic file size check
+        if len(file_bytes) > 500 * 1024 * 1024:  # 500MB limit
+            return (
+                "File too large. Please upload files smaller than 500MB.",
+                "",
+                gr.update(visible=False),
+                "",
+                {},
+                gr.update(visible=False),
+                gr.update()
+            )
+        
+        # Prepare settings
+        settings = {
+            'audio_format': audio_format,
+            'diarization_enabled': diarization_enabled,
+            'speakers': speakers,
+            'profanity': profanity,
+            'punctuation': punctuation,
+            'timestamps': timestamps,
+            'lexical': lexical
+        }
+        
+        # Submit job (logging happens in app_core)
+        job_id = transcription_manager.submit_transcription(
+            file_bytes, original_filename, user.user_id, language, settings
+        )
+        
+        # Update job state
+        job_state = {
+            'current_job_id': job_id,
+            'start_time': datetime.now().isoformat(),
+            'auto_refresh_active': True,
+            'last_status': 'pending'
+        }
+        
+        # Get updated user stats
+        stats_display = get_user_stats_display(user)
+        
+        return (
+            f"🚀 Transcription started for: {original_filename}\n📡 Auto-refreshing every 10 seconds...",
+            "",
+            gr.update(visible=False),
+            f"Job ID: {job_id}",
+            job_state,
+            gr.update(visible=True, value="🔄 Auto-refresh active"),
+            stats_display
+        )
+        
+    except Exception as e:
+        print(f"❌ Error submitting transcription: {str(e)}")
+        return (
+            f"Error: {str(e)}",
+            "",
+            gr.update(visible=False),
+            "",
+            {},
+            gr.update(visible=False),
+            gr.update()
+        )
+
+def check_current_job_status(job_state, user):
+    """Check status of current job"""
+    if not user:
+        return (
+            "❌ Please log in to check status", 
+            "", 
+            gr.update(visible=False), 
+            "",
+            gr.update(visible=False),
+            gr.update()
+        )
+    
+    if not job_state or 'current_job_id' not in job_state:
+        return (
+            "No active job", 
+            "", 
+            gr.update(visible=False), 
+            "",
+            gr.update(visible=False),
+            gr.update()
+        )
+    
+    job_id = job_state['current_job_id']
+    
+    try:
+        job = transcription_manager.get_job_status(job_id)
+        if not job or job.user_id != user.user_id:
+            return (
+                "Job not found or access denied", 
+                "", 
+                gr.update(visible=False), 
+                "",
+                gr.update(visible=False),
+                gr.update()
+            )
+        
+        # Calculate processing time
+        processing_time = format_processing_time(job.created_at, job.completed_at)
+        
+        # Only log status changes to reduce spam
+        last_status = job_state.get('last_status', '')
+        if job.status != last_status:
+            print(f"🔄 [{user.username}] Job status change: {last_status} → {job.status} ({job.original_filename})")
+            job_state['last_status'] = job.status
+        
+        # Get updated user stats
+        stats_display = get_user_stats_display(user)
+        
+        # Check for completed status AND transcript availability
+        if job.status == 'completed' and job.transcript_text and job.transcript_text.strip():
+            # Job is complete and transcript is available, stop auto-refresh
+            job_state['auto_refresh_active'] = False
+            # Create downloadable file
+            transcript_file = create_transcript_file(job.transcript_text, job_id)
+            return (
+                f"✅ Transcription completed in {processing_time}",
+                job.transcript_text,
+                gr.update(visible=True, value=transcript_file),
+                f"Processed: {job.original_filename}",
+                gr.update(visible=False),  # Hide auto-refresh status
+                stats_display
+            )
+        elif job.status == 'failed':
+            # Job failed, stop auto-refresh
+            job_state['auto_refresh_active'] = False
+            return (
+                f"❌ Transcription failed after {processing_time}",
+                "",
+                gr.update(visible=False),
+                f"Error: {job.error_message[:100]}..." if job.error_message else "Unknown error",
+                gr.update(visible=False),
+                stats_display
+            )
+        elif job.status == 'processing':
+            # Still processing, continue auto-refresh
+            auto_refresh_active = job_state.get('auto_refresh_active', False)
+            return (
+                f"🔄 Processing... ({processing_time} elapsed)\n📡 Auto-refreshing every 10 seconds...",
+                "",
+                gr.update(visible=False),
+                f"Converting and analyzing: {job.original_filename}",
+                gr.update(visible=True, value="🔄 Auto-refresh active") if auto_refresh_active else gr.update(visible=False),
+                stats_display
+            )
+        elif job.status == 'completed' and (not job.transcript_text or not job.transcript_text.strip()):
+            # Job marked as completed but transcript not yet available - keep refreshing
+            auto_refresh_active = job_state.get('auto_refresh_active', False)
+            return (
+                f"🔄 Finalizing transcript... ({processing_time} elapsed)\n📡 Auto-refreshing every 10 seconds...",
+                "",
+                gr.update(visible=False),
+                f"Retrieving results: {job.original_filename}",
+                gr.update(visible=True, value="🔄 Auto-refresh active") if auto_refresh_active else gr.update(visible=False),
+                stats_display
+            )
+        else:  # pending
+            # Still pending, continue auto-refresh
+            auto_refresh_active = job_state.get('auto_refresh_active', False)
+            return (
+                f"⏳ Queued for processing... ({processing_time} waiting)\n📡 Auto-refreshing every 10 seconds...",
+                "",
+                gr.update(visible=False),
+                f"Waiting: {job.original_filename}",
+                gr.update(visible=True, value="🔄 Auto-refresh active") if auto_refresh_active else gr.update(visible=False),
+                stats_display
+            )
+        
+    except Exception as e:
+        print(f"❌ Error checking job status: {str(e)}")
+        return (
+            f"Error checking status: {str(e)}", 
+            "", 
+            gr.update(visible=False), 
+            "",
+            gr.update(visible=False),
+            gr.update()
+        )
+
+def should_auto_refresh(job_state, user):
+    """Check if auto-refresh should be active"""
+    if not user or not job_state or not job_state.get('auto_refresh_active', False):
+        return False
+    
+    if 'current_job_id' not in job_state:
+        return False
+    
+    job_id = job_state['current_job_id']
+    job = transcription_manager.get_job_status(job_id)
+    
+    if not job or job.user_id != user.user_id:
+        return False
+    
+    # Continue auto-refresh until job is completed AND transcript is available, or job failed
+    if job.status == 'failed':
+        return False
+    elif job.status == 'completed' and job.transcript_text and job.transcript_text.strip():
+        return False
+    else:
+        return True
+
+def auto_refresh_status(job_state, user):
+    """Auto-refresh function that only runs when needed"""
+    if should_auto_refresh(job_state, user):
+        return check_current_job_status(job_state, user)
+    else:
+        return (
+            gr.update(),  # No change to status_display
+            gr.update(),  # No change to transcript_output
+            gr.update(),  # No change to download_file
+            gr.update(),  # No change to job_info
+            gr.update(visible=False),  # Hide auto-refresh indicator
+            gr.update()   # No change to user stats
+        )
+
+def stop_auto_refresh(job_state, user):
+    """Manually stop auto-refresh"""
+    if job_state:
+        job_state['auto_refresh_active'] = False
+        if user:
+            print(f"⏹️ [{user.username}] Auto-refresh stopped by user")
+    return gr.update(visible=False)
+
+# History Functions
+def get_user_history_table(user, show_all_user_transcriptions=False):
+    """Get user history as a formatted table - PDPA compliant"""
+    if not user:
+        return []
+    
+    try:
+        if show_all_user_transcriptions:
+            # Show ALL transcriptions for current user
+            jobs = transcription_manager.get_user_history(user.user_id, limit=100)
+        else:
+            # Show recent transcriptions for current user
+            jobs = transcription_manager.get_user_history(user.user_id, limit=20)
+        
+        if not jobs:
+            return []
+        
+        # Create table data
+        table_data = []
+        
+        for job in jobs:
+            # Format datetime
+            try:
+                created_time = datetime.fromisoformat(job.created_at)
+                formatted_date = created_time.strftime("%Y-%m-%d %H:%M")
+            except:
+                formatted_date = job.created_at[:16]
+            
+            # Status with emoji
+            status_display = format_status(job.status)
+            
+            # Processing time
+            time_display = format_processing_time(job.created_at, job.completed_at)
+            
+            # Job ID display (shortened for table)
+            job_id_display = job.job_id[:8] + "..." if len(job.job_id) > 8 else job.job_id
+            
+            # Language
+            language_display = ALLOWED_LANGS.get(job.language, job.language)
+            
+            # Create download status
+            if job.status == 'completed' and job.transcript_text:
+                download_link = f"📄 Available"
+            elif job.status == 'processing':
+                download_link = "🔄 Processing..."
+            elif job.status == 'pending':
+                download_link = "⏳ Queued..."
+            elif job.status == 'failed':
+                download_link = "❌ Failed"
+            else:
+                download_link = "⚠️ Unknown"
+            
+            table_data.append([
+                formatted_date,
+                job.original_filename,
+                language_display,
+                status_display,
+                time_display,
+                job_id_display,
+                download_link
+            ])
+        
+        return table_data
+        
+    except Exception as e:
+        print(f"❌ Error loading user history: {str(e)}")
+        return []
+
+def refresh_history_and_downloads(user, show_all_user_transcriptions=False):
+    """Refresh history table and create download files"""
+    if not user:
+        return (
+            [],
+            gr.update(visible=False), gr.update(visible=False), gr.update(visible=False),
+            gr.update(visible=False), gr.update(visible=False), gr.update(visible=False),
+            gr.update(visible=False), gr.update(visible=False), gr.update(visible=False),
+            gr.update(visible=False),
+            gr.update()
+        )
+    
+    try:
+        if show_all_user_transcriptions:
+            jobs = transcription_manager.get_user_history(user.user_id, limit=100)
+        else:
+            jobs = transcription_manager.get_user_history(user.user_id, limit=20)
+        
+        # Get table data
+        table_data = get_user_history_table(user, show_all_user_transcriptions)
+        
+        # Create download files for completed jobs
+        download_updates = []
+        completed_jobs = [job for job in jobs if job.status == 'completed' and job.transcript_text]
+        
+        for i in range(10):  # We have 10 download file components
+            if i < len(completed_jobs):
+                job = completed_jobs[i]
+                # Create transcript file
+                transcript_file = create_transcript_file(job.transcript_text, job.job_id)
+                
+                # Create label with filename and job info
+                label = f"📄 {job.original_filename} ({job.created_at[:10]})"
+                
+                download_updates.append(
+                    gr.update(visible=True, value=transcript_file, label=label)
+                )
+            else:
+                download_updates.append(gr.update(visible=False))
+        
+        # Get updated user stats
+        stats_display = get_user_stats_display(user)
+        
+        return [table_data] + download_updates + [stats_display]
+        
+    except Exception as e:
+        print(f"❌ Error refreshing user history: {str(e)}")
+        return (
+            [],
+            gr.update(visible=False), gr.update(visible=False), gr.update(visible=False),
+            gr.update(visible=False), gr.update(visible=False), gr.update(visible=False),
+            gr.update(visible=False), gr.update(visible=False), gr.update(visible=False),
+            gr.update(visible=False),
+            gr.update()
+        )
+
+def on_history_refresh_click(user, show_all_user_transcriptions):
+    """Manual history refresh"""
+    if user:
+        print(f"🔄 [{user.username}] User refreshed history (show_all: {show_all_user_transcriptions})")
+    return refresh_history_and_downloads(user, show_all_user_transcriptions)
+
+def on_history_tab_select(user):
+    """Auto-refresh history when history tab is selected"""
+    if user:
+        print(f"📚 [{user.username}] History tab opened, refreshing data...")
+    return refresh_history_and_downloads(user, show_all_user_transcriptions=False)
+
+# PDPA Compliance Functions
+def export_user_data(user):
+    """Export user data for GDPR compliance"""
+    if not user:
+        return "❌ Please log in to export your data", gr.update(visible=False)
+    
+    try:
+        export_data = transcription_manager.export_user_data(user.user_id)
+        
+        # Create export file
+        os.makedirs("temp", exist_ok=True)
+        filename = f"temp/user_data_export_{user.user_id}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+        
+        with open(filename, "w", encoding="utf-8") as f:
+            json.dump(export_data, f, indent=2, ensure_ascii=False)
+        
+        print(f"📦 [{user.username}] Data export created")
+        return "✅ Your data has been exported successfully", gr.update(visible=True, value=filename, label="Download Your Data Export")
+        
+    except Exception as e:
+        print(f"❌ Error exporting user data: {str(e)}")
+        return f"❌ Export failed: {str(e)}", gr.update(visible=False)
+
+def update_marketing_consent(user, marketing_consent):
+    """Update user's marketing consent"""
+    if not user:
+        return "❌ Please log in to update consent"
+    
+    try:
+        success = transcription_manager.update_user_consent(user.user_id, marketing_consent)
+        if success:
+            user.marketing_consent = marketing_consent
+            print(f"📧 [{user.username}] Marketing consent updated: {marketing_consent}")
+            return f"✅ Marketing consent updated successfully"
+        else:
+            return "❌ Failed to update consent"
+    except Exception as e:
+        return f"❌ Error: {str(e)}"
+
+def delete_user_account(user, confirmation_text):
+    """Delete user account and all data"""
+    if not user:
+        return "❌ Please log in to delete account", None, gr.update(visible=True), gr.update(visible=False)
+    
+    if confirmation_text != "DELETE MY ACCOUNT":
+        return "❌ Please type 'DELETE MY ACCOUNT' to confirm", user, gr.update(visible=False), gr.update(visible=True)
+    
+    try:
+        success = transcription_manager.delete_user_account(user.user_id)
+        if success:
+            print(f"🗑️ [{user.username}] Account deleted successfully")
+            return "✅ Your account and all data have been permanently deleted", None, gr.update(visible=True), gr.update(visible=False)
+        else:
+            return "❌ Failed to delete account", user, gr.update(visible=False), gr.update(visible=True)
+    except Exception as e:
+        return f"❌ Error: {str(e)}", user, gr.update(visible=False), gr.update(visible=True)
+
+def on_user_login(user):
+    """Update UI components when user logs in"""
+    if user:
+        return gr.update(value=user.marketing_consent)
+    else:
+        return gr.update(value=False)
+
+def check_system_status():
+    """Check if the system is properly initialized"""
+    try:
+        # Test database connection
+        if transcription_manager and transcription_manager.db:
+            # Try a simple database operation
+            test_stats = transcription_manager.db.get_user_stats("test_user_id")
+            print("✅ System initialization successful")
+            return "👤 Please log in to view your statistics..."
+        else:
+            print("❌ System initialization failed - transcription manager not available")
+            return "❌ System initialization failed - please check configuration"
+    except Exception as e:
+        print(f"❌ System initialization error: {str(e)}")
+        return f"❌ System error: {str(e)}"
+
+def create_transcript_file(transcript_text, job_id):
+    """Create a downloadable transcript file"""
+    os.makedirs("temp", exist_ok=True)
+    filename = f"temp/transcript_{job_id}.txt"
+    with open(filename, "w", encoding="utf-8") as f:
+        f.write(transcript_text)
+    return filename
+
+# Enhanced CSS with authentication styling
+enhanced_css = """
+/* Main container styling */
+.gradio-container {
+    background: linear-gradient(135deg, #f8f9fa 0%, #e9ecef 100%);
+    font-family: 'Segoe UI', system-ui, sans-serif;
+    color: #212529;
+}
+
+/* Card styling */
+.gr-box {
+    background: white;
+    border: 1px solid #dee2e6;
+    border-radius: 12px;
+    box-shadow: 0 2px 8px rgba(0,0,0,0.08);
+    padding: 20px;
+    margin: 10px 0;
+}
+
+/* Button styling */
+.gr-button {
+    background: linear-gradient(135deg, #007bff, #0056b3);
+    border: none;
+    border-radius: 8px;
+    color: white;
+    font-weight: 500;
+    padding: 12px 24px;
+    transition: all 0.2s ease;
+    box-shadow: 0 2px 4px rgba(0,123,255,0.2);
+}
+
+.gr-button:hover {
+    background: linear-gradient(135deg, #0056b3, #004085);
+    transform: translateY(-1px);
+    box-shadow: 0 4px 8px rgba(0,123,255,0.3);
+}
+
+.gr-button[variant="secondary"] {
+    background: linear-gradient(135deg, #6c757d, #495057);
+}
+
+.gr-button[variant="secondary"]:hover {
+    background: linear-gradient(135deg, #495057, #343a40);
+}
+
+/* Login/Register button styling */
+.auth-button {
+    background: linear-gradient(135deg, #28a745, #1e7e34);
+    min-width: 120px;
+}
+
+.auth-button:hover {
+    background: linear-gradient(135deg, #1e7e34, #155724);
+}
+
+.danger-button {
+    background: linear-gradient(135deg, #dc3545, #c82333);
+}
+
+.danger-button:hover {
+    background: linear-gradient(135deg, #c82333, #a71e2a);
+}
+
+/* Input styling */
+.gr-textbox, .gr-dropdown, .gr-file {
+    border: 2px solid #e9ecef;
+    border-radius: 8px;
+    background: white;
+    color: #212529;
+    transition: border-color 0.2s ease;
+}
+
+.gr-textbox:focus, .gr-dropdown:focus {
+    border-color: #007bff;
+    box-shadow: 0 0 0 3px rgba(0,123,255,0.1);
+}
+
+/* Status styling */
+.status-display {
+    background: linear-gradient(135deg, #e3f2fd, #bbdefb);
+    border-left: 4px solid #2196f3;
+    padding: 15px;
+    border-radius: 0 8px 8px 0;
+    margin: 10px 0;
+}
+
+.success-status {
+    background: linear-gradient(135deg, #e8f5e8, #c8e6c9);
+    border-left-color: #4caf50;
+}
+
+.error-status {
+    background: linear-gradient(135deg, #ffebee, #ffcdd2);
+    border-left-color: #f44336;
+}
+
+/* Auto-refresh indicator styling */
+.auto-refresh-indicator {
+    background: linear-gradient(135deg, #fff3cd, #ffeaa7);
+    border: 1px solid #ffeaa7;
+    border-radius: 6px;
+    padding: 8px 12px;
+    font-size: 12px;
+    color: #856404;
+    text-align: center;
+    animation: pulse 2s infinite;
+}
+
+@keyframes pulse {
+    0% { opacity: 1; }
+    50% { opacity: 0.7; }
+    100% { opacity: 1; }
+}
+
+/* User stats styling */
+.user-stats {
+    background: linear-gradient(135deg, #e8f5e8, #c8e6c9);
+    border: 1px solid #c8e6c9;
+    border-radius: 6px;
+    padding: 8px 12px;
+    font-size: 12px;
+    color: #2e7d32;
+    text-align: center;
+    font-weight: 500;
+}
+
+/* Authentication form styling */
+.auth-form {
+    background: white;
+    border: 2px solid #007bff;
+    border-radius: 12px;
+    padding: 25px;
+    box-shadow: 0 4px 12px rgba(0,123,255,0.15);
+}
+
+/* Privacy notice styling */
+.privacy-notice {
+    background: linear-gradient(135deg, #e3f2fd, #bbdefb);
+    border: 1px solid #2196f3;
+    border-radius: 8px;
+    padding: 15px;
+    font-size: 14px;
+    color: #1976d2;
+    margin: 10px 0;
+}
+
+/* PDPA section styling */
+.pdpa-section {
+    background: linear-gradient(135deg, #fff3cd, #ffeaa7);
+    border: 1px solid #ffc107;
+    border-radius: 8px;
+    padding: 15px;
+    margin: 10px 0;
+}
+
+/* History table styling */
+.history-table {
+    background: white;
+    border: 1px solid #dee2e6;
+    border-radius: 8px;
+    font-size: 14px;
+}
+
+.history-table thead th {
+    background: linear-gradient(135deg, #f8f9fa, #e9ecef);
+    color: #495057;
+    font-weight: 600;
+    padding: 12px;
+    border-bottom: 2px solid #dee2e6;
+}
+
+.history-table tbody tr {
+    cursor: pointer;
+    transition: background-color 0.2s ease;
+}
+
+.history-table tbody tr:hover {
+    background: linear-gradient(135deg, #f8f9fa, #e9ecef);
+}
+
+.history-table tbody tr:nth-child(even) {
+    background: #f8f9fa;
+}
+
+.history-table tbody tr:nth-child(even):hover {
+    background: linear-gradient(135deg, #e9ecef, #dee2e6);
+}
+
+.history-table tbody td {
+    padding: 10px;
+    border-bottom: 1px solid #dee2e6;
+    vertical-align: middle;
+}
+
+/* Tab styling */
+.tab-nav {
+    background: white;
+    border-bottom: 2px solid #dee2e6;
+    border-radius: 8px 8px 0 0;
+}
+
+/* Header styling */
+.main-header {
+    background: white;
+    border: 1px solid #dee2e6;
+    border-radius: 12px;
+    padding: 25px;
+    text-align: center;
+    margin-bottom: 20px;
+    box-shadow: 0 2px 8px rgba(0,0,0,0.05);
+}
+
+.main-header h1 {
+    color: #007bff;
+    margin-bottom: 10px;
+    font-size: 2.2em;
+    font-weight: 600;
+}
+
+.main-header p {
+    color: #6c757d;
+    font-size: 1.1em;
+    margin: 0;
+}
+"""
+
+# Create the main interface
+with gr.Blocks(
+    theme=gr.themes.Soft(
+        primary_hue="blue",
+        secondary_hue="gray",
+        neutral_hue="gray",
+        font=["system-ui", "sans-serif"]
+    ),
+    css=enhanced_css,
+    title="🎙️ Azure Speech Transcription - Secure & PDPA Compliant"
+) as demo:
+    
+    # Global state
+    current_user = gr.State(None)
+    job_state = gr.State({})
+    
+    # Header
+    with gr.Row():
+        gr.HTML("""
+        <div class="main-header">
+            <h1>🎙️ Azure Speech Transcription</h1>
+            <p>Secure, PDPA-compliant transcription service with user authentication and privacy protection</p>
+        </div>
+        """)
+    
+    # User stats display
+    user_stats_display = gr.Textbox(
+        label="",
+        lines=1,
+        interactive=False,
+        show_label=False,
+        placeholder="👤 Please log in to view your statistics...",
+        elem_classes=["user-stats"]
+    )
+    
+    # Authentication Section
+    with gr.Column(visible=True, elem_classes=["auth-form"]) as auth_section:
+        gr.Markdown("## 🔐 Authentication Required")
+        gr.Markdown("Please log in or create an account to use the transcription service.")
+        
+        with gr.Tabs() as auth_tabs:
+            # Login Tab
+            with gr.Tab("🔑 Login") as login_tab:
+                with gr.Column():
+                    login_email = gr.Textbox(
+                        label="Email or Username",
+                        placeholder="Enter your email or username"
+                    )
+                    login_password = gr.Textbox(
+                        label="Password",
+                        type="password",
+                        placeholder="Enter your password"
+                    )
+                    
+                    with gr.Row():
+                        login_btn = gr.Button("🔑 Login", variant="primary", elem_classes=["auth-button"])
+                    
+                    login_status = gr.Textbox(
+                        label="",
+                        show_label=False,
+                        interactive=False,
+                        placeholder="Enter your credentials and click Login"
+                    )
+            
+            # Register Tab  
+            with gr.Tab("📝 Register") as register_tab:
+                with gr.Column():
+                    reg_email = gr.Textbox(
+                        label="Email",
+                        placeholder="Enter your email address"
+                    )
+                    reg_username = gr.Textbox(
+                        label="Username",
+                        placeholder="Choose a username (3-30 characters, alphanumeric and underscore)"
+                    )
+                    reg_password = gr.Textbox(
+                        label="Password",
+                        type="password",
+                        placeholder="Create a strong password (min 8 chars, mixed case, numbers)"
+                    )
+                    reg_confirm_password = gr.Textbox(
+                        label="Confirm Password",
+                        type="password",
+                        placeholder="Confirm your password"
+                    )
+                    
+                    gr.Markdown("### 📋 Privacy & Data Consent")
+                    
+                    with gr.Column(elem_classes=["privacy-notice"]):
+                        gr.Markdown("""
+                        **Privacy Notice**: By creating an account, you acknowledge that:
+                        - Your data will be stored securely in user-separated Azure Blob Storage
+                        - Transcriptions are processed using Azure Speech Services
+                        - You can export or delete your data at any time
+                        - We comply with GDPR and data protection regulations
+                        """)
+                    
+                    gdpr_consent = gr.Checkbox(
+                        label="I consent to the processing of my personal data as described in the Privacy Notice (Required)",
+                        value=False
+                    )
+                    data_retention_consent = gr.Checkbox(
+                        label="I agree to data retention for transcription service functionality (Required)",
+                        value=False
+                    )
+                    marketing_consent = gr.Checkbox(
+                        label="I consent to receiving marketing communications (Optional)",
+                        value=False
+                    )
+                    
+                    with gr.Row():
+                        register_btn = gr.Button("📝 Create Account", variant="primary", elem_classes=["auth-button"])
+                    
+                    register_status = gr.Textbox(
+                        label="",
+                        show_label=False,
+                        interactive=False,
+                        placeholder="Fill out the form and agree to the required consents to create your account"
+                    )
+                    
+                    login_after_register = gr.Button(
+                        "🔑 Go to Login",
+                        visible=False,
+                        variant="secondary"
+                    )
+    
+    # Main Application (visible only when logged in)
+    with gr.Column(visible=False) as main_app:
+        
+        # Logout button
+        with gr.Row():
+            with gr.Column(scale=3):
+                pass
+            with gr.Column(scale=1):
+                logout_btn = gr.Button("👋 Logout", variant="secondary")
+        
+        # Main transcription interface
+        with gr.Tab("🎙️ Transcribe"):
+            with gr.Row():
+                # Left column - Input settings
+                with gr.Column(scale=1):
+                    gr.Markdown("### 📁 Upload File")
+                    
+                    file_upload = gr.File(
+                        label="Audio or Video File",
+                        type="filepath",
+                        file_types=[
+                            ".wav", ".mp3", ".ogg", ".opus", ".flac", ".wma", ".aac", 
+                            ".m4a", ".amr", ".webm", ".speex",
+                            ".mp4", ".mov", ".avi", ".mkv", ".wmv", ".flv", ".3gp"
+                        ]
+                    )
+                    
+                    with gr.Row():
+                        language = gr.Dropdown(
+                            choices=[(v, k) for k, v in ALLOWED_LANGS.items()],
+                            label="Language",
+                            value="en-US"
+                        )
+                        audio_format = gr.Dropdown(
+                            choices=AUDIO_FORMATS,
+                            value="wav",
+                            label="Output Format"
+                        )
+                    
+                    gr.Markdown("### ⚙️ Settings")
+                    
+                    with gr.Row():
+                        diarization_enabled = gr.Checkbox(
+                            label="Speaker Identification",
+                            value=True
+                        )
+                        speakers = gr.Slider(
+                            minimum=1,
+                            maximum=10,
+                            step=1,
+                            value=2,
+                            label="Max Speakers"
+                        )
+                    
+                    with gr.Row():
+                        timestamps = gr.Checkbox(
+                            label="Timestamps",
+                            value=True
+                        )
+                        profanity = gr.Dropdown(
+                            choices=["masked", "removed", "raw"],
+                            value="masked",
+                            label="Profanity Filter"
+                        )
+                    
+                    with gr.Row():
+                        punctuation = gr.Dropdown(
+                            choices=["automatic", "dictated", "none"],
+                            value="automatic",
+                            label="Punctuation"
+                        )
+                        lexical = gr.Checkbox(
+                            label="Lexical Form",
+                            value=False
+                        )
+                    
+                    submit_btn = gr.Button(
+                        "🚀 Start Transcription",
+                        variant="primary",
+                        size="lg"
+                    )
+                
+                # Right column - Results
+                with gr.Column(scale=1):
+                    gr.Markdown("### 📊 Status")
+                    
+                    # Auto-refresh indicator
+                    auto_refresh_status_display = gr.Textbox(
+                        label="",
+                        lines=1,
+                        interactive=False,
+                        show_label=False,
+                        visible=False,
+                        elem_classes=["auto-refresh-indicator"]
+                    )
+                    
+                    status_display = gr.Textbox(
+                        label="",
+                        lines=3,
+                        interactive=False,
+                        show_label=False,
+                        placeholder="Upload a file and click 'Start Transcription' to begin...\nStatus will auto-refresh every 10 seconds during processing.\nYour data is stored in your private user folder for PDPA compliance."
+                    )
+                    
+                    job_info = gr.Textbox(
+                        label="",
+                        lines=1,
+                        interactive=False,
+                        show_label=False,
+                        placeholder=""
+                    )
+                    
+                    with gr.Row():
+                        refresh_btn = gr.Button(
+                            "🔄 Check Status",
+                            variant="secondary"
+                        )
+                        stop_refresh_btn = gr.Button(
+                            "⏹️ Stop Auto-Refresh",
+                            variant="secondary"
+                        )
+                    
+                    gr.Markdown("### 📄 Results")
+                    
+                    transcript_output = gr.Textbox(
+                        label="Transcript",
+                        lines=12,
+                        interactive=False,
+                        placeholder="Your transcript with speaker identification and precise timestamps (HH:MM:SS) will appear here..."
+                    )
+                    
+                    download_file = gr.File(
+                        label="Download",
+                        interactive=False,
+                        visible=False
+                    )
+        
+        # History tab
+        with gr.Tab("📚 My History"):
+            gr.Markdown("### 📋 Your Transcription History & Downloads")
+            gr.Markdown("*View your personal transcription history and download completed transcripts (PDPA compliant - only your data)*")
+            
+            with gr.Row():
+                refresh_history_btn = gr.Button(
+                    "🔄 Refresh My History & Downloads",
+                    variant="primary"
+                )
+                show_all_user_checkbox = gr.Checkbox(
+                    label="Show All My Transcriptions (not just recent 20)",
+                    value=False
+                )
+            
+            history_table = gr.Dataframe(
+                headers=["Date", "Filename", "Language", "Status", "Duration", "Job ID", "Download"],
+                datatype=["str", "str", "str", "str", "str", "str", "str"],
+                col_count=(7, "fixed"),
+                row_count=(15, "dynamic"),
+                wrap=True,
+                interactive=False,
+                elem_classes=["history-table"]
+            )
+            
+            # Download Files Section
+            gr.Markdown("### 📥 Download Your Completed Transcripts")
+            gr.Markdown("*Your available transcript downloads will appear below after refreshing*")
+            
+            # Container for dynamic download files
+            with gr.Column():
+                download_file_1 = gr.File(label="", visible=False, interactive=False)
+                download_file_2 = gr.File(label="", visible=False, interactive=False)
+                download_file_3 = gr.File(label="", visible=False, interactive=False)
+                download_file_4 = gr.File(label="", visible=False, interactive=False)
+                download_file_5 = gr.File(label="", visible=False, interactive=False)
+                download_file_6 = gr.File(label="", visible=False, interactive=False)
+                download_file_7 = gr.File(label="", visible=False, interactive=False)
+                download_file_8 = gr.File(label="", visible=False, interactive=False)
+                download_file_9 = gr.File(label="", visible=False, interactive=False)
+                download_file_10 = gr.File(label="", visible=False, interactive=False)
+        
+        # PDPA Compliance Tab
+        with gr.Tab("🔒 Privacy & Data"):
+            gr.Markdown("### 🔒 GDPR & Data Protection")
+            gr.Markdown("Manage your personal data and privacy settings in compliance with data protection regulations.")
+            
+            with gr.Column(elem_classes=["pdpa-section"]):
+                gr.Markdown("#### 📊 Data Export")
+                gr.Markdown("Download all your personal data including transcriptions, account info, and usage statistics.")
+                
+                export_btn = gr.Button("📦 Export My Data", variant="primary")
+                export_status = gr.Textbox(
+                    label="",
+                    show_label=False,
+                    interactive=False,
+                    placeholder="Click 'Export My Data' to download your complete data archive"
+                )
+                export_file = gr.File(
+                    label="Your Data Export",
+                    visible=False,
+                    interactive=False
+                )
+            
+            with gr.Column(elem_classes=["pdpa-section"]):
+                gr.Markdown("#### 📧 Marketing Consent")
+                gr.Markdown("Update your preferences for receiving marketing communications.")
+                
+                marketing_consent_checkbox = gr.Checkbox(
+                    label="I consent to receiving marketing communications",
+                    value=False
+                )
+                update_consent_btn = gr.Button("✅ Update Consent", variant="secondary")
+                consent_status = gr.Textbox(
+                    label="",
+                    show_label=False,
+                    interactive=False,
+                    placeholder="Update your marketing consent preferences"
+                )
+            
+            with gr.Column(elem_classes=["pdpa-section"]):
+                gr.Markdown("#### ⚠️ Account Deletion")
+                gr.Markdown("""
+                **Warning**: This action is irreversible and will permanently delete:
+                - Your user account and profile
+                - All transcription history and files
+                - All data stored in Azure Blob Storage
+                - Usage statistics and preferences
+                """)
+                
+                deletion_confirmation = gr.Textbox(
+                    label="Type 'DELETE MY ACCOUNT' to confirm",
+                    placeholder="Type the exact phrase to confirm account deletion"
+                )
+                delete_account_btn = gr.Button(
+                    "🗑️ Delete My Account",
+                    variant="stop",
+                    elem_classes=["danger-button"]
+                )
+                deletion_status = gr.Textbox(
+                    label="",
+                    show_label=False,
+                    interactive=False,
+                    placeholder="Account deletion requires confirmation text"
+                )
+    
+    # Auto-refresh timer
+    timer = gr.Timer(10.0)
+    
+    # Event handlers
+    
+    # Authentication events
+    login_btn.click(
+        login_user,
+        inputs=[login_email, login_password],
+        outputs=[login_status, current_user, auth_section, main_app, user_stats_display]
+    ).then(
+        on_user_login,
+        inputs=[current_user],
+        outputs=[marketing_consent_checkbox]
+    ).then(
+        lambda user: ("", "") if user else (gr.update(), gr.update()),  # Clear login fields on success
+        inputs=[current_user],
+        outputs=[login_email, login_password]
+    )
+    
+    register_btn.click(
+        register_user,
+        inputs=[reg_email, reg_username, reg_password, reg_confirm_password, 
+                gdpr_consent, data_retention_consent, marketing_consent],
+        outputs=[register_status, login_after_register]
+    ).then(
+        lambda status: ("", "", "", "", False, False, False) if "✅" in status else (gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update()),
+        inputs=[register_status],
+        outputs=[reg_email, reg_username, reg_password, reg_confirm_password, gdpr_consent, data_retention_consent, marketing_consent]
+    )
+    
+    login_after_register.click(
+        lambda: (gr.update(selected=0), ""),  # Switch to login tab (index 0) and clear status
+        outputs=[auth_tabs, register_status]
+    )
+    
+    logout_btn.click(
+        logout_user,
+        outputs=[current_user, login_status, auth_section, main_app, user_stats_display]
+    )
+    
+    # Transcription events
+    submit_btn.click(
+        submit_transcription,
+        inputs=[
+            file_upload, language, audio_format, diarization_enabled,
+            speakers, profanity, punctuation, timestamps, lexical, current_user
+        ],
+        outputs=[status_display, transcript_output, download_file, job_info, job_state, auto_refresh_status_display, user_stats_display]
+    )
+    
+    refresh_btn.click(
+        lambda job_state, user: (
+            print("🔄 User manually checked status") if user else None,
+            check_current_job_status(job_state, user)
+        )[1],
+        inputs=[job_state, current_user],
+        outputs=[status_display, transcript_output, download_file, job_info, auto_refresh_status_display, user_stats_display]
+    )
+    
+    stop_refresh_btn.click(
+        stop_auto_refresh,
+        inputs=[job_state, current_user],
+        outputs=[auto_refresh_status_display]
+    )
+    
+    # Auto-refresh timer event
+    timer.tick(
+        auto_refresh_status,
+        inputs=[job_state, current_user],
+        outputs=[status_display, transcript_output, download_file, job_info, auto_refresh_status_display, user_stats_display]
+    )
+    
+    # History events
+    refresh_history_btn.click(
+        on_history_refresh_click,
+        inputs=[current_user, show_all_user_checkbox],
+        outputs=[
+            history_table,
+            download_file_1, download_file_2, download_file_3, download_file_4, download_file_5,
+            download_file_6, download_file_7, download_file_8, download_file_9, download_file_10,
+            user_stats_display
+        ]
+    )
+    
+    show_all_user_checkbox.change(
+        lambda user, show_all: (
+            print(f"👁️ User toggled show all personal transcriptions: {show_all}") if user else None,
+            refresh_history_and_downloads(user, show_all)
+        )[1],
+        inputs=[current_user, show_all_user_checkbox],
+        outputs=[
+            history_table,
+            download_file_1, download_file_2, download_file_3, download_file_4, download_file_5,
+            download_file_6, download_file_7, download_file_8, download_file_9, download_file_10,
+            user_stats_display
+        ]
+    )
+    
+    # PDPA compliance events
+    export_btn.click(
+        export_user_data,
+        inputs=[current_user],
+        outputs=[export_status, export_file]
+    )
+    
+    update_consent_btn.click(
+        update_marketing_consent,
+        inputs=[current_user, marketing_consent_checkbox],
+        outputs=[consent_status]
+    )
+    
+    delete_account_btn.click(
+        delete_user_account,
+        inputs=[current_user, deletion_confirmation],
+        outputs=[deletion_status, current_user, auth_section, main_app]
+    )
+    
+    # Auto-hide/show speakers slider
+    diarization_enabled.change(
+        lambda enabled: gr.update(visible=enabled),
+        inputs=[diarization_enabled],
+        outputs=[speakers]
+    )
+    
+    # Load user stats on app start and verify system is ready
+    demo.load(
+        lambda: (
+            print("🚀 PDPA-Compliant Azure Speech Transcription Service Started..."),
+            check_system_status()
+        )[1],
+        outputs=[user_stats_display]
+    )
+
+# Info section
+with demo:
+    gr.HTML("""
+    <div style="background: white; border: 1px solid #dee2e6; border-radius: 12px; padding: 20px; margin-top: 20px; color: #212529;">
+        <h3 style="color: #007bff; margin-top: 0;">📋 How to Use</h3>
+        <ol style="line-height: 1.6;">
+            <li><strong>Register/Login:</strong> Create an account or log in with existing credentials</li>
+            <li><strong>Upload:</strong> Select your audio or video file</li>
+            <li><strong>Configure:</strong> Choose language and enable speaker identification</li>
+            <li><strong>Start:</strong> Click "Start Transcription" - status will auto-update every 10 seconds</li>
+            <li><strong>Download:</strong> Get your transcript with speaker identification and timestamps</li>
+            <li><strong>Manage:</strong> Use Privacy & Data tab to export or delete your data</li>
+        </ol>
+        
+        <h3 style="color: #007bff;">🎵 Supported Formats</h3>
+        <p><strong>Audio:</strong> WAV, MP3, OGG, OPUS, FLAC, WMA, AAC, M4A, AMR, WebM, Speex</p>
+        <p><strong>Video:</strong> MP4, MOV, AVI, MKV, WMV, FLV, 3GP</p>
+        
+        <h3 style="color: #007bff;">🔒 Security & Privacy Features</h3>
+        <ul style="line-height: 1.6;">
+            <li><strong>✅ User Authentication:</strong> Secure registration and login system</li>
+            <li><strong>✅ Password Security:</strong> Strong password requirements and secure hashing</li>
+            <li><strong>✅ User-Separated Storage:</strong> Each user has isolated folders in Azure Blob Storage</li>
+            <li><strong>✅ GDPR Compliance:</strong> Full data export and account deletion capabilities</li>
+            <li><strong>✅ Consent Management:</strong> Granular consent controls for data processing</li>
+            <li><strong>✅ Privacy by Design:</strong> Users can only access their own data</li>
+            <li><strong>✅ Audit Trail:</strong> Comprehensive logging for compliance and security</li>
+            <li><strong>✅ Data Retention:</strong> Clear data retention policies and user control</li>
+        </ul>
+        
+        <h3 style="color: #007bff;">🎯 Enhanced Features</h3>
+        <ul style="line-height: 1.6;">
+            <li><strong>Enhanced Timestamps:</strong> Precise timing for each speaker segment (HH:MM:SS format)</li>
+            <li><strong>Better Speaker Diarization:</strong> Improved speaker identification with timestamps</li>
+            <li><strong>Personal Statistics:</strong> Real-time usage tracking and analytics</li>
+            <li><strong>Complete History:</strong> View all your transcriptions or recent ones</li>
+            <li><strong>Direct Downloads:</strong> Easy access to completed transcriptions</li>
+            <li><strong>Data Export:</strong> Download all your data in JSON format</li>
+            <li><strong>Account Management:</strong> Full control over your account and data</li>
+        </ul>
+        
+        <h3 style="color: #007bff;">💡 Tips</h3>
+        <ul style="line-height: 1.6;">
+            <li>Use a strong password with mixed case letters, numbers, and symbols</li>
+            <li>WAV files process fastest for transcription</li>
+            <li>Enable speaker identification for meetings and interviews</li>
+            <li>Auto-refresh continues until transcript is fully retrieved</li>
+            <li>Visit Privacy & Data tab to manage your data and consent preferences</li>
+            <li>You can export all your data or delete your account at any time</li>
+            <li>All your files are stored in your private, secure user folder</li>
+            <li>Your data is protected according to GDPR and privacy regulations</li>
+        </ul>
+    </div>
+    """)
+
+if __name__ == "__main__":
+    print("🚀 Starting Secure PDPA-Compliant Azure Speech Transcription Service...")
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7861,
+        share=False,
+        show_error=True
+    )

requirements.txt

@@ -0,0 +1,3 @@
+gradio 
+python-dotenv
+azure-storage-blob