#!/usr/bin/env python3
"""
Rotary Phone Audio Handler with Web Interface
Detects handset pickup, plays custom sound, records audio, and provides web UI
"""

import pyaudio
import wave
import time
import RPi.GPIO as GPIO
from datetime import datetime
import os
import numpy as np
import threading
from flask import Flask, render_template, request, send_file, jsonify, redirect, url_for
from werkzeug.utils import secure_filename
import json
import sys
import zlib
import shutil

# Load configuration
def load_system_config():
    """Load system configuration from config.json"""
    config_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'config.json')

    # Check if config exists, otherwise use example
    if not os.path.exists(config_path):
        example_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'config.example.json')
        if os.path.exists(example_path):
            print(f"Config file not found. Please copy {example_path} to {config_path}")
            print("Command: cp config.example.json config.json")
            sys.exit(1)
        else:
            print("ERROR: No configuration file found!")
            sys.exit(1)

    with open(config_path, 'r') as f:
        return json.load(f)

# Load system configuration
SYS_CONFIG = load_system_config()

# GPIO Configuration
HOOK_PIN = SYS_CONFIG['gpio']['hook_pin']
HOOK_PRESSED = GPIO.LOW if SYS_CONFIG['gpio']['hook_pressed_state'] == 'LOW' else GPIO.HIGH

# Extra Button Configuration
EXTRA_BUTTON_ENABLED = SYS_CONFIG['gpio'].get('extra_button_enabled', False)
EXTRA_BUTTON_PIN = SYS_CONFIG['gpio'].get('extra_button_pin', 27)
EXTRA_BUTTON_PRESSED = GPIO.LOW if SYS_CONFIG['gpio'].get('extra_button_pressed_state', 'LOW') == 'LOW' else GPIO.HIGH

# Audio settings
AUDIO_DEVICE_INDEX = SYS_CONFIG['audio']['device_index']
CHUNK = SYS_CONFIG['audio']['chunk_size']
FORMAT = pyaudio.paInt16  # Fixed format
CHANNELS = SYS_CONFIG['audio']['channels']
RATE = SYS_CONFIG['audio']['sample_rate']
RECORD_SECONDS = SYS_CONFIG['audio']['max_record_seconds']

# Directories
SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
BASE_DIR = os.path.join(SCRIPT_DIR, SYS_CONFIG['paths']['base_dir']) if SYS_CONFIG['paths']['base_dir'].startswith('.') else SYS_CONFIG['paths']['base_dir']
BASE_DIR = os.path.abspath(BASE_DIR)
OUTPUT_DIR = os.path.join(BASE_DIR, SYS_CONFIG['paths']['recordings_dir'])
SOUNDS_DIR = os.path.join(BASE_DIR, SYS_CONFIG['paths']['sounds_dir'])
USER_CONFIG_FILE = os.path.join(BASE_DIR, "user_config.json")  # Runtime user settings
DIALTONE_FILE = os.path.join(SOUNDS_DIR, "dialtone.wav")

# Backup Configuration
BACKUP_CONFIG = SYS_CONFIG.get('backup', {})
BACKUP_ENABLED = BACKUP_CONFIG.get('enabled', False)
BACKUP_USB_PATHS = BACKUP_CONFIG.get('usb_paths', [])
BACKUP_VERIFY_CRC = BACKUP_CONFIG.get('verify_crc', True)
BACKUP_ON_WRITE = BACKUP_CONFIG.get('backup_on_write', True)

# Web server settings
WEB_PORT = SYS_CONFIG['web']['port']

# Flask app
app = Flask(__name__)
app.config['MAX_CONTENT_LENGTH'] = SYS_CONFIG['web']['max_upload_size_mb'] * 1024 * 1024

# Backup and CRC Functions
def calculate_crc32(filepath):
    """Calculate CRC32 checksum of a file"""
    try:
        with open(filepath, 'rb') as f:
            checksum = 0
            while chunk := f.read(65536):  # Read in 64KB chunks
                checksum = zlib.crc32(chunk, checksum)
            return checksum & 0xFFFFFFFF
    except Exception as e:
        print(f"Error calculating CRC for {filepath}: {e}")
        return None

def backup_file_to_usb(source_file, relative_path):
    """
    Backup a file to all configured USB drives with CRC verification

    Args:
        source_file: Full path to source file
        relative_path: Relative path from base dir (e.g., 'recordings/file.wav')

    Returns:
        dict: Status of each USB backup attempt
    """
    if not BACKUP_ENABLED or not BACKUP_ON_WRITE:
        return {"enabled": False}

    if not os.path.exists(source_file):
        return {"error": f"Source file not found: {source_file}"}

    # Calculate source CRC if verification is enabled
    source_crc = None
    if BACKUP_VERIFY_CRC:
        source_crc = calculate_crc32(source_file)
        if source_crc is None:
            return {"error": "Failed to calculate source CRC"}

    results = {}

    for usb_path in BACKUP_USB_PATHS:
        usb_name = os.path.basename(usb_path)

        # Check if USB is mounted
        if not os.path.exists(usb_path) or not os.path.ismount(usb_path):
            results[usb_name] = {"status": "not_mounted", "path": usb_path}
            continue

        try:
            # Create backup directory structure
            backup_dir = os.path.join(usb_path, "wedding-phone-backup")
            dest_dir = os.path.join(backup_dir, os.path.dirname(relative_path))
            os.makedirs(dest_dir, exist_ok=True)

            # Copy file
            dest_file = os.path.join(backup_dir, relative_path)
            shutil.copy2(source_file, dest_file)

            # Verify CRC if enabled
            if BACKUP_VERIFY_CRC:
                dest_crc = calculate_crc32(dest_file)
                if dest_crc != source_crc:
                    results[usb_name] = {
                        "status": "crc_mismatch",
                        "path": dest_file,
                        "source_crc": hex(source_crc),
                        "dest_crc": hex(dest_crc) if dest_crc else None
                    }
                    # Delete corrupted backup
                    try:
                        os.remove(dest_file)
                    except:
                        pass
                    continue

            results[usb_name] = {
                "status": "success",
                "path": dest_file,
                "crc": hex(source_crc) if source_crc else None
            }

        except Exception as e:
            results[usb_name] = {"status": "error", "error": str(e)}

    return results

def get_usb_backup_status():
    """Get status of all configured USB backup drives"""
    status = {
        "enabled": BACKUP_ENABLED,
        "verify_crc": BACKUP_VERIFY_CRC,
        "backup_on_write": BACKUP_ON_WRITE,
        "drives": []
    }

    for usb_path in BACKUP_USB_PATHS:
        drive_info = {
            "path": usb_path,
            "name": os.path.basename(usb_path),
            "mounted": os.path.exists(usb_path) and os.path.ismount(usb_path),
            "writable": False,
            "free_space": None
        }

        if drive_info["mounted"]:
            try:
                # Check if writable
                test_file = os.path.join(usb_path, ".wedding_phone_test")
                with open(test_file, 'w') as f:
                    f.write("test")
                os.remove(test_file)
                drive_info["writable"] = True

                # Get free space
                stat = os.statvfs(usb_path)
                drive_info["free_space"] = stat.f_bavail * stat.f_frsize
                drive_info["free_space_mb"] = drive_info["free_space"] / (1024 * 1024)

            except Exception as e:
                drive_info["error"] = str(e)

        status["drives"].append(drive_info)

    return status

class RotaryPhone:
    def __init__(self):
        self.audio = pyaudio.PyAudio()
        self.recording = False
        self.phone_status = "on_hook"
        self.current_recording = None

        # Setup GPIO
        GPIO.setmode(GPIO.BCM)
        GPIO.setup(HOOK_PIN, GPIO.IN, pull_up_down=GPIO.PUD_UP)

        # Setup extra button if enabled
        if EXTRA_BUTTON_ENABLED:
            GPIO.setup(EXTRA_BUTTON_PIN, GPIO.IN, pull_up_down=GPIO.PUD_UP)
            self.extra_button_playing = False

        # Create directories
        os.makedirs(OUTPUT_DIR, exist_ok=True)
        os.makedirs(SOUNDS_DIR, exist_ok=True)

        # Initialize configuration
        self.config = self.load_config()

        # Generate default dial tone if none exists
        if not os.path.exists(DIALTONE_FILE):
            self.generate_default_dialtone()

    def load_config(self):
        """Load user runtime configuration from JSON file"""
        default_config = {
            "active_greeting": SYS_CONFIG['system']['active_greeting'],
            "extra_button_sound": SYS_CONFIG['system'].get('extra_button_sound', 'button_sound.wav'),
            "greetings": [],
            "volume": SYS_CONFIG['system']['volume'],
            "greeting_delay": SYS_CONFIG['system'].get('greeting_delay_seconds', 0)
        }

        if os.path.exists(USER_CONFIG_FILE):
            try:
                with open(USER_CONFIG_FILE, 'r') as f:
                    config = json.load(f)
                    # Ensure required keys exist
                    if "volume" not in config:
                        config["volume"] = SYS_CONFIG['system']['volume']
                    if "greeting_delay" not in config:
                        config["greeting_delay"] = SYS_CONFIG['system'].get('greeting_delay_seconds', 0)
                    return config
            except:
                pass

        return default_config

    def save_config(self):
        """Save user runtime configuration to JSON file"""
        with open(USER_CONFIG_FILE, 'w') as f:
            json.dump(self.config, f, indent=2)

    def get_active_greeting_path(self):
        """Get the full path to the active greeting file"""
        active = self.config.get("active_greeting", "dialtone.wav")
        return os.path.join(SOUNDS_DIR, active)

    def set_active_greeting(self, filename):
        """Set which greeting message to play"""
        self.config["active_greeting"] = filename
        self.save_config()

    def get_extra_button_sound_path(self):
        """Get the full path to the extra button sound file"""
        sound = self.config.get("extra_button_sound", "button_sound.wav")
        return os.path.join(SOUNDS_DIR, sound)

    def set_extra_button_sound(self, filename):
        """Set which sound plays for extra button"""
        self.config["extra_button_sound"] = filename
        self.save_config()

    def set_volume(self, volume):
        """Set playback volume (0-100)"""
        volume = max(0, min(100, int(volume)))  # Clamp between 0-100
        self.config["volume"] = volume
        self.save_config()
        return volume

    def get_volume(self):
        """Get current volume setting"""
        return self.config.get("volume", 70)

    def set_greeting_delay(self, delay):
        """Set greeting delay in seconds (0-10)"""
        delay = max(0, min(10, int(delay)))  # Clamp between 0-10
        self.config["greeting_delay"] = delay
        self.save_config()
        return delay

    def get_greeting_delay(self):
        """Get current greeting delay"""
        return self.config.get("greeting_delay", 0)
    
    def generate_default_dialtone(self):
        """Generate a classic dial tone (350Hz + 440Hz) and save as default"""
        print("Generating default dial tone...")
        duration = 3
        sample_rate = 44100
        t = np.linspace(0, duration, int(sample_rate * duration), False)
        
        # Generate two frequencies and combine them
        tone1 = np.sin(2 * np.pi * 350 * t)
        tone2 = np.sin(2 * np.pi * 440 * t)
        tone = (tone1 + tone2) / 2
        
        # Convert to 16-bit PCM
        tone = (tone * 32767).astype(np.int16)
        
        # Save as WAV file
        wf = wave.open(DIALTONE_FILE, 'wb')
        wf.setnchannels(1)
        wf.setsampwidth(2)  # 16-bit
        wf.setframerate(sample_rate)
        wf.writeframes(tone.tobytes())
        wf.close()
        print(f"Default dial tone saved to {DIALTONE_FILE}")
    
    def play_sound_file(self, filepath, check_hook_status=True):
        """Play a WAV file with volume control

        Args:
            filepath: Path to WAV file
            check_hook_status: If True, only play while off-hook (for greeting).
                             If False, play completely regardless of hook (for button)
        """
        if not os.path.exists(filepath):
            print(f"Sound file not found: {filepath}")
            return False

        print(f"Playing sound: {filepath}")

        try:
            wf = wave.open(filepath, 'rb')

            # Use configured audio device
            stream = self.audio.open(
                format=self.audio.get_format_from_width(wf.getsampwidth()),
                channels=wf.getnchannels(),
                rate=wf.getframerate(),
                output=True,
                output_device_index=AUDIO_DEVICE_INDEX,
                frames_per_buffer=CHUNK
            )

            # Get volume multiplier (0.0 to 1.0)
            volume = self.get_volume() / 100.0

            # Play the sound with volume control
            data = wf.readframes(CHUNK)
            while data:
                # For greeting sounds, stop immediately if handset is hung up
                if check_hook_status and GPIO.input(HOOK_PIN) != HOOK_PRESSED:
                    print("Handset hung up, stopping playback immediately")
                    break

                # Apply volume by converting to numpy array and scaling
                if volume < 1.0:
                    audio_data = np.frombuffer(data, dtype=np.int16)
                    audio_data = (audio_data * volume).astype(np.int16)
                    data = audio_data.tobytes()

                stream.write(data)
                data = wf.readframes(CHUNK)

            stream.stop_stream()
            stream.close()
            wf.close()
            print("Sound playback finished")
            return True

        except Exception as e:
            print(f"Error playing sound: {e}")
            return False
    
    def record_audio(self):
        """Record audio from the microphone"""
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        filename = os.path.join(OUTPUT_DIR, f"recording_{timestamp}.wav")
        self.current_recording = filename

        print(f"Recording to {filename}")

        MIN_RECORDING_DURATION = 1.0  # Minimum 1 second to save recording

        try:
            # Use configured audio device
            stream = self.audio.open(
                format=FORMAT,
                channels=CHANNELS,
                rate=RATE,
                input=True,
                input_device_index=AUDIO_DEVICE_INDEX,
                frames_per_buffer=CHUNK
            )

            frames = []
            self.recording = True

            # Record until handset is hung up or max time reached
            start_time = time.time()
            while self.recording and (time.time() - start_time) < RECORD_SECONDS:
                # Check if handset is still off hook - immediate detection
                if GPIO.input(HOOK_PIN) != HOOK_PRESSED:
                    print("Handset hung up, stopping recording immediately")
                    break

                try:
                    data = stream.read(CHUNK, exception_on_overflow=False)
                    frames.append(data)
                except Exception as e:
                    print(f"Error reading audio: {e}")
                    break

            stream.stop_stream()
            stream.close()

            # Calculate recording duration
            duration = len(frames) * CHUNK / RATE if frames else 0

            # Only save if recording is long enough
            if frames and duration >= MIN_RECORDING_DURATION:
                wf = wave.open(filename, 'wb')
                wf.setnchannels(CHANNELS)
                wf.setsampwidth(self.audio.get_sample_size(FORMAT))
                wf.setframerate(RATE)
                wf.writeframes(b''.join(frames))
                wf.close()
                print(f"Recording saved: {filename} ({duration:.1f}s)")

                # Backup to USB drives if enabled
                if BACKUP_ENABLED:
                    relative_path = os.path.join(SYS_CONFIG['paths']['recordings_dir'], os.path.basename(filename))
                    backup_results = backup_file_to_usb(filename, relative_path)
                    print(f"Backup results: {backup_results}")
            else:
                # Delete aborted/too short recording
                if os.path.exists(filename):
                    os.remove(filename)
                print(f"Recording aborted or too short ({duration:.1f}s), not saved")

        except Exception as e:
            print(f"Recording error: {e}")
            # Clean up failed recording file
            if os.path.exists(filename):
                try:
                    os.remove(filename)
                    print(f"Cleaned up failed recording: {filename}")
                except:
                    pass

        self.recording = False
        self.current_recording = None
    
    def get_status(self):
        """Get current phone status"""
        return {
            "status": self.phone_status,
            "recording": self.recording,
            "current_recording": self.current_recording,
            "extra_button_playing": self.extra_button_playing if EXTRA_BUTTON_ENABLED else False
        }
    
    def play_extra_button_sound(self):
        """Play sound when extra button is pressed (only during recording)"""
        if not EXTRA_BUTTON_ENABLED:
            return

        # Only play if currently recording
        if not self.recording:
            print("Extra button ignored - not recording")
            return

        button_sound = self.get_extra_button_sound_path()
        if not os.path.exists(button_sound):
            print(f"Extra button sound not found: {button_sound}")
            return

        print(f"\n=== Extra button pressed ===")
        self.extra_button_playing = True

        try:
            # Use a separate PyAudio instance for playback during recording
            # This allows simultaneous input (recording) and output (button sound)
            audio_playback = pyaudio.PyAudio()

            wf = wave.open(button_sound, 'rb')

            stream = audio_playback.open(
                format=audio_playback.get_format_from_width(wf.getsampwidth()),
                channels=wf.getnchannels(),
                rate=wf.getframerate(),
                output=True,
                output_device_index=AUDIO_DEVICE_INDEX,
                frames_per_buffer=CHUNK
            )

            # Get volume multiplier
            volume = self.get_volume() / 100.0

            # Play the sound
            data = wf.readframes(CHUNK)
            while data:
                # Apply volume
                if volume < 1.0:
                    audio_data = np.frombuffer(data, dtype=np.int16)
                    audio_data = (audio_data * volume).astype(np.int16)
                    data = audio_data.tobytes()

                stream.write(data)
                data = wf.readframes(CHUNK)

            stream.stop_stream()
            stream.close()
            wf.close()
            audio_playback.terminate()

            print("Extra button sound playback finished")

        except Exception as e:
            print(f"Error playing button sound: {e}")
        finally:
            self.extra_button_playing = False

    def phone_loop(self):
        """Main phone handling loop"""
        print("Rotary Phone System Started")
        print(f"Hook pin: GPIO {HOOK_PIN}")
        if EXTRA_BUTTON_ENABLED:
            print(f"Extra button: GPIO {EXTRA_BUTTON_PIN}")
        print(f"Recordings will be saved to: {OUTPUT_DIR}")

        try:
            while True:
                # Check extra button first (higher priority)
                if EXTRA_BUTTON_ENABLED and GPIO.input(EXTRA_BUTTON_PIN) == EXTRA_BUTTON_PRESSED:
                    if not self.extra_button_playing:
                        # Play extra button sound in a separate thread to not block
                        button_thread = threading.Thread(target=self.play_extra_button_sound, daemon=True)
                        button_thread.start()
                        time.sleep(0.5)  # Debounce

                # Wait for handset pickup
                if GPIO.input(HOOK_PIN) == HOOK_PRESSED and self.phone_status == "on_hook":
                    self.phone_status = "off_hook"
                    print("\n=== Handset picked up ===")

                    # Apply greeting delay if configured
                    greeting_delay = self.get_greeting_delay()
                    if greeting_delay > 0:
                        print(f"Waiting {greeting_delay} seconds before greeting...")
                        time.sleep(greeting_delay)

                    # Play active greeting message
                    greeting_file = self.get_active_greeting_path()
                    self.play_sound_file(greeting_file)

                    # Start recording
                    if self.phone_status == "off_hook":  # Still off hook after sound
                        self.record_audio()

                    self.phone_status = "on_hook"

                time.sleep(0.1)
                
        except KeyboardInterrupt:
            print("\nShutting down phone system...")
        finally:
            self.cleanup()
    
    def cleanup(self):
        """Clean up resources"""
        self.audio.terminate()
        GPIO.cleanup()
        print("Cleanup complete")

# Global phone instance
phone = RotaryPhone()

# Flask Routes
@app.route('/')
def index():
    """Main page"""
    recordings = get_recordings()
    greetings = get_greetings()
    status = phone.get_status()
    active_greeting = phone.config.get("active_greeting", "dialtone.wav")
    extra_button_sound = phone.config.get("extra_button_sound", "button_sound.wav")
    volume = phone.get_volume()
    greeting_delay = phone.get_greeting_delay()

    return render_template('index.html',
                         recordings=recordings,
                         greetings=greetings,
                         active_greeting=active_greeting,
                         extra_button_sound=extra_button_sound,
                         extra_button_enabled=EXTRA_BUTTON_ENABLED,
                         status=status,
                         volume=volume,
                         greeting_delay=greeting_delay)

@app.route('/api/status')
def api_status():
    """API endpoint for phone status"""
    return jsonify(phone.get_status())

@app.route('/api/recordings')
def api_recordings():
    """API endpoint for recordings list"""
    return jsonify(get_recordings())

@app.route('/api/greetings')
def api_greetings():
    """API endpoint for greetings list"""
    return jsonify(get_greetings())

@app.route('/api/volume', methods=['GET'])
def api_get_volume():
    """Get current volume setting"""
    return jsonify({"volume": phone.get_volume()})

@app.route('/api/volume', methods=['POST'])
def api_set_volume():
    """Set volume level"""
    data = request.get_json()
    volume = data.get('volume', 70)
    new_volume = phone.set_volume(volume)
    return jsonify({"success": True, "volume": new_volume})

@app.route('/api/greeting_delay', methods=['GET'])
def api_get_greeting_delay():
    """Get current greeting delay setting"""
    return jsonify({"delay": phone.get_greeting_delay()})

@app.route('/api/greeting_delay', methods=['POST'])
def api_set_greeting_delay():
    """Set greeting delay in seconds"""
    data = request.get_json()
    delay = data.get('delay', 0)
    new_delay = phone.set_greeting_delay(delay)
    return jsonify({"success": True, "delay": new_delay})

@app.route('/api/backup/status', methods=['GET'])
def api_backup_status():
    """Get USB backup drive status"""
    return jsonify(get_usb_backup_status())

@app.route('/api/backup/test', methods=['POST'])
def api_backup_test():
    """Test backup to all USB drives"""
    try:
        # Create a test file
        test_file = os.path.join(OUTPUT_DIR, ".backup_test.txt")
        with open(test_file, 'w') as f:
            f.write(f"Backup test at {datetime.now()}")

        # Try to backup
        results = backup_file_to_usb(test_file, os.path.join(SYS_CONFIG['paths']['recordings_dir'], ".backup_test.txt"))

        # Clean up test file
        try:
            os.remove(test_file)
        except:
            pass

        return jsonify({"success": True, "results": results})
    except Exception as e:
        return jsonify({"success": False, "error": str(e)}), 500

@app.route('/upload_greeting', methods=['POST'])
def upload_greeting():
    """Upload a new greeting message"""
    if 'soundfile' not in request.files:
        return jsonify({"error": "No file provided"}), 400

    file = request.files['soundfile']

    if file.filename == '':
        return jsonify({"error": "No file selected"}), 400

    if file and file.filename.lower().endswith('.wav'):
        filename = secure_filename(file.filename)

        # Ensure unique filename
        counter = 1
        base_name = os.path.splitext(filename)[0]
        while os.path.exists(os.path.join(SOUNDS_DIR, filename)):
            filename = f"{base_name}_{counter}.wav"
            counter += 1

        filepath = os.path.join(SOUNDS_DIR, filename)
        file.save(filepath)

        # Backup to USB drives if enabled
        if BACKUP_ENABLED:
            relative_path = os.path.join(SYS_CONFIG['paths']['sounds_dir'], filename)
            backup_results = backup_file_to_usb(filepath, relative_path)
            print(f"Greeting backup results: {backup_results}")

        return jsonify({"success": True, "message": f"Greeting '{filename}' uploaded successfully", "filename": filename})

    return jsonify({"error": "Only WAV files are supported"}), 400

@app.route('/set_active_greeting', methods=['POST'])
def set_active_greeting():
    """Set which greeting to play"""
    data = request.get_json()
    filename = data.get('filename')

    if not filename:
        return jsonify({"error": "No filename provided"}), 400

    filepath = os.path.join(SOUNDS_DIR, filename)
    if not os.path.exists(filepath):
        return jsonify({"error": "Greeting file not found"}), 404

    phone.set_active_greeting(filename)
    return jsonify({"success": True, "message": f"Active greeting set to '{filename}'"})

@app.route('/set_extra_button_sound', methods=['POST'])
def set_extra_button_sound():
    """Set which sound plays for extra button"""
    data = request.get_json()
    filename = data.get('filename')

    if not filename:
        return jsonify({"error": "No filename provided"}), 400

    filepath = os.path.join(SOUNDS_DIR, filename)
    if not os.path.exists(filepath):
        return jsonify({"error": "Sound file not found"}), 404

    phone.set_extra_button_sound(filename)
    return jsonify({"success": True, "message": f"Extra button sound set to '{filename}'"})

@app.route('/delete_greeting/<filename>', methods=['POST'])
def delete_greeting(filename):
    """Delete a greeting file"""
    filename = secure_filename(filename)
    filepath = os.path.join(SOUNDS_DIR, filename)

    # Don't delete the active greeting
    if filename == phone.config.get("active_greeting"):
        return jsonify({"error": "Cannot delete the active greeting. Please select a different greeting first."}), 400

    if os.path.exists(filepath):
        os.remove(filepath)
        return jsonify({"success": True})

    return jsonify({"error": "File not found"}), 404

@app.route('/play_audio/<audio_type>/<filename>')
def play_audio(audio_type, filename):
    """Serve audio file for web playback"""
    filename = secure_filename(filename)

    if audio_type == 'recording':
        filepath = os.path.join(OUTPUT_DIR, filename)
    elif audio_type == 'greeting':
        filepath = os.path.join(SOUNDS_DIR, filename)
    else:
        return "Invalid audio type", 400

    if os.path.exists(filepath):
        return send_file(filepath, mimetype='audio/wav')
    return "File not found", 404

@app.route('/download/<filename>')
def download_recording(filename):
    """Download a recording"""
    filepath = os.path.join(OUTPUT_DIR, secure_filename(filename))
    if os.path.exists(filepath):
        return send_file(filepath, as_attachment=True)
    return "File not found", 404

@app.route('/delete/<filename>', methods=['POST'])
def delete_recording(filename):
    """Delete a recording"""
    filepath = os.path.join(OUTPUT_DIR, secure_filename(filename))
    if os.path.exists(filepath):
        os.remove(filepath)
        return jsonify({"success": True})
    return jsonify({"error": "File not found"}), 404

@app.route('/restore_default_sound', methods=['POST'])
def restore_default_sound():
    """Restore default dial tone"""
    if os.path.exists(DIALTONE_FILE):
        os.remove(DIALTONE_FILE)
    phone.generate_default_dialtone()
    phone.set_active_greeting("dialtone.wav")
    return jsonify({"success": True, "message": "Default dial tone restored"})

def get_greetings():
    """Get list of all greeting sound files"""
    greetings = []
    if os.path.exists(SOUNDS_DIR):
        for filename in sorted(os.listdir(SOUNDS_DIR)):
            if filename.endswith('.wav'):
                filepath = os.path.join(SOUNDS_DIR, filename)
                stat = os.stat(filepath)

                # Get duration from WAV file
                try:
                    wf = wave.open(filepath, 'rb')
                    frames = wf.getnframes()
                    rate = wf.getframerate()
                    duration = frames / float(rate)
                    wf.close()
                except:
                    duration = 0

                greetings.append({
                    "filename": filename,
                    "size": stat.st_size,
                    "size_mb": stat.st_size / (1024 * 1024),
                    "date": datetime.fromtimestamp(stat.st_mtime).strftime('%Y-%m-%d %H:%M:%S'),
                    "duration": duration,
                    "is_active": filename == phone.config.get("active_greeting", "dialtone.wav"),
                    "is_button_sound": filename == phone.config.get("extra_button_sound", "button_sound.wav")
                })
    return greetings

def get_recordings():
    """Get list of all recordings with metadata"""
    recordings = []
    if os.path.exists(OUTPUT_DIR):
        for filename in sorted(os.listdir(OUTPUT_DIR), reverse=True):
            if filename.endswith('.wav'):
                filepath = os.path.join(OUTPUT_DIR, filename)
                stat = os.stat(filepath)
                
                # Get duration from WAV file
                try:
                    wf = wave.open(filepath, 'rb')
                    frames = wf.getnframes()
                    rate = wf.getframerate()
                    duration = frames / float(rate)
                    wf.close()
                except:
                    duration = 0
                
                recordings.append({
                    "filename": filename,
                    "size": stat.st_size,
                    "size_mb": stat.st_size / (1024 * 1024),
                    "date": datetime.fromtimestamp(stat.st_mtime).strftime('%Y-%m-%d %H:%M:%S'),
                    "duration": duration
                })
    return recordings

def get_local_ip():
    """Get local IP address"""
    import socket
    try:
        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        s.connect(("8.8.8.8", 80))
        ip = s.getsockname()[0]
        s.close()
        return ip
    except:
        return "127.0.0.1"

def main():
    """Main entry point for the wedding phone application"""
    # Create templates directory and HTML template
    script_dir = os.path.dirname(os.path.abspath(__file__))
    templates_dir = os.path.join(script_dir, 'templates')
    os.makedirs(templates_dir, exist_ok=True)

    # Create the HTML template if it doesn't exist
    template_file = os.path.join(templates_dir, 'index.html')
    if not os.path.exists(template_file):
        print(f"Creating template at {template_file}")
        with open(template_file, 'w') as f:
            f.write('''<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Rotary Phone Control Panel</title>
    <style>
        * {
            margin: 0;
            padding: 0;
            box-sizing: border-box;
        }
        
        body {
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
            min-height: 100vh;
            padding: 20px;
        }
        
        .container {
            max-width: 1200px;
            margin: 0 auto;
        }
        
        .header {
            text-align: center;
            color: white;
            margin-bottom: 30px;
        }
        
        .header h1 {
            font-size: 2.5em;
            margin-bottom: 10px;
            text-shadow: 2px 2px 4px rgba(0,0,0,0.3);
        }
        
        .header p {
            font-size: 1.1em;
            opacity: 0.9;
        }
        
        .card {
            background: white;
            border-radius: 15px;
            padding: 25px;
            margin-bottom: 20px;
            box-shadow: 0 10px 30px rgba(0,0,0,0.3);
        }
        
        .status-card {
            display: flex;
            align-items: center;
            justify-content: space-between;
        }
        
        .status-indicator {
            display: flex;
            align-items: center;
            gap: 10px;
        }
        
        .status-dot {
            width: 20px;
            height: 20px;
            border-radius: 50%;
            animation: pulse 2s infinite;
        }
        
        .status-dot.on-hook {
            background: #10b981;
        }
        
        .status-dot.off-hook {
            background: #ef4444;
        }
        
        .status-dot.recording {
            background: #f59e0b;
        }
        
        @keyframes pulse {
            0%, 100% { opacity: 1; }
            50% { opacity: 0.5; }
        }
        
        .card h2 {
            color: #333;
            margin-bottom: 20px;
            font-size: 1.5em;
            border-bottom: 2px solid #667eea;
            padding-bottom: 10px;
        }
        
        .upload-section {
            border: 2px dashed #667eea;
            border-radius: 10px;
            padding: 30px;
            text-align: center;
            margin-bottom: 20px;
            background: #f8f9fa;
        }
        
        .upload-section input[type="file"] {
            display: none;
        }
        
        .upload-label {
            display: inline-block;
            padding: 12px 30px;
            background: #667eea;
            color: white;
            border-radius: 8px;
            cursor: pointer;
            font-weight: 600;
            transition: background 0.3s;
        }
        
        .upload-label:hover {
            background: #5568d3;
        }
        
        .btn {
            padding: 10px 20px;
            border: none;
            border-radius: 8px;
            cursor: pointer;
            font-weight: 600;
            transition: all 0.3s;
            font-size: 0.95em;
        }
        
        .btn-primary {
            background: #667eea;
            color: white;
        }
        
        .btn-primary:hover {
            background: #5568d3;
            transform: translateY(-2px);
        }
        
        .btn-success {
            background: #10b981;
            color: white;
        }
        
        .btn-success:hover {
            background: #059669;
        }
        
        .btn-danger {
            background: #ef4444;
            color: white;
        }
        
        .btn-danger:hover {
            background: #dc2626;
        }
        
        .btn-secondary {
            background: #6b7280;
            color: white;
        }
        
        .btn-secondary:hover {
            background: #4b5563;
        }
        
        .recordings-grid {
            display: grid;
            gap: 15px;
        }
        
        .recording-item {
            display: flex;
            align-items: center;
            justify-content: space-between;
            padding: 15px;
            background: #f8f9fa;
            border-radius: 10px;
            transition: all 0.3s;
        }
        
        .recording-item:hover {
            background: #e9ecef;
            transform: translateX(5px);
        }
        
        .recording-info {
            flex-grow: 1;
        }
        
        .recording-info h3 {
            color: #333;
            font-size: 1em;
            margin-bottom: 5px;
        }
        
        .recording-meta {
            color: #6b7280;
            font-size: 0.85em;
        }
        
        .recording-actions {
            display: flex;
            gap: 10px;
        }
        
        .no-recordings {
            text-align: center;
            padding: 40px;
            color: #6b7280;
        }
        
        .alert {
            padding: 15px;
            border-radius: 8px;
            margin-bottom: 20px;
        }
        
        .alert-success {
            background: #d1fae5;
            color: #065f46;
            border-left: 4px solid #10b981;
        }
        
        .alert-error {
            background: #fee2e2;
            color: #991b1b;
            border-left: 4px solid #ef4444;
        }
        
        .alert-info {
            background: #dbeafe;
            color: #1e40af;
            border-left: 4px solid #3b82f6;
        }
        
        .filename-display {
            font-family: 'Courier New', monospace;
            background: #e9ecef;
            padding: 5px 10px;
            border-radius: 5px;
            margin-top: 10px;
            font-size: 0.9em;
        }
        
        .stats {
            display: grid;
            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
            gap: 15px;
            margin-top: 20px;
        }
        
        .stat-box {
            background: #667eea;
            color: white;
            padding: 20px;
            border-radius: 10px;
            text-align: center;
        }
        
        .stat-value {
            font-size: 2em;
            font-weight: bold;
            margin-bottom: 5px;
        }
        
        .stat-label {
            font-size: 0.9em;
            opacity: 0.9;
        }
        
        .button-group {
            display: flex;
            gap: 10px;
            margin-top: 15px;
        }

        .active-greeting {
            border: 2px solid #667eea;
            background: #f0f4ff !important;
        }

        .active-greeting:hover {
            background: #e5edff !important;
        }

        /* Audio player modal */
        .audio-modal {
            display: none;
            position: fixed;
            z-index: 1000;
            left: 0;
            top: 0;
            width: 100%;
            height: 100%;
            background: rgba(0, 0, 0, 0.7);
            align-items: center;
            justify-content: center;
        }

        .audio-modal.show {
            display: flex;
        }

        .audio-modal-content {
            background: white;
            padding: 30px;
            border-radius: 15px;
            box-shadow: 0 10px 40px rgba(0, 0, 0, 0.5);
            max-width: 500px;
            width: 90%;
        }

        .audio-modal-header {
            display: flex;
            justify-content: space-between;
            align-items: center;
            margin-bottom: 20px;
        }

        .audio-modal-header h3 {
            margin: 0;
            color: #333;
        }

        .close-modal {
            font-size: 28px;
            font-weight: bold;
            color: #6b7280;
            cursor: pointer;
            border: none;
            background: none;
            padding: 0;
            width: 30px;
            height: 30px;
            line-height: 1;
        }

        .close-modal:hover {
            color: #333;
        }

        .audio-player-container {
            text-align: center;
        }

        .audio-player-container audio {
            width: 100%;
            margin-top: 20px;
        }

        .audio-filename {
            font-family: 'Courier New', monospace;
            background: #f8f9fa;
            padding: 10px;
            border-radius: 5px;
            margin-bottom: 10px;
            word-break: break-all;
        }

        /* Volume slider */
        input[type="range"] {
            -webkit-appearance: none;
            appearance: none;
            cursor: pointer;
        }

        input[type="range"]::-webkit-slider-thumb {
            -webkit-appearance: none;
            appearance: none;
            width: 20px;
            height: 20px;
            border-radius: 50%;
            background: #667eea;
            cursor: pointer;
            box-shadow: 0 2px 5px rgba(0,0,0,0.2);
            transition: all 0.2s;
        }

        input[type="range"]::-webkit-slider-thumb:hover {
            background: #5568d3;
            transform: scale(1.2);
        }

        input[type="range"]::-moz-range-thumb {
            width: 20px;
            height: 20px;
            border-radius: 50%;
            background: #667eea;
            cursor: pointer;
            border: none;
            box-shadow: 0 2px 5px rgba(0,0,0,0.2);
            transition: all 0.2s;
        }

        input[type="range"]::-moz-range-thumb:hover {
            background: #5568d3;
            transform: scale(1.2);
        }
    </style>
</head>
<body>
    <div class="container">
        <div class="header">
            <h1>📞 Rotary Phone Control Panel</h1>
            <p>Manage your vintage phone system</p>
        </div>
        
        <div id="alert-container"></div>
        
        <!-- Status Card -->
        <div class="card status-card">
            <div>
                <h2>Phone Status</h2>
                <div class="status-indicator">
                    <div class="status-dot {{ 'recording' if status.recording else ('off-hook' if status.status == 'off_hook' else 'on-hook') }}" id="status-dot"></div>
                    <span id="status-text">
                        {% if status.recording %}
                            🔴 Recording in progress...
                        {% elif status.status == 'off_hook' %}
                            📞 Handset off hook
                        {% else %}
                            ✅ Ready (handset on hook)
                        {% endif %}
                    </span>
                </div>
                {% if status.current_recording %}
                <p style="margin-top: 10px; color: #6b7280; font-size: 0.9em;">
                    Recording to: {{ status.current_recording.split('/')[-1] }}
                </p>
                {% endif %}
                {% if extra_button_enabled %}
                <div id="button-status" style="margin-top: 10px; padding: 8px; border-radius: 5px; background: {{ '#fef3c7' if status.extra_button_playing else '#f3f4f6' }}; transition: background 0.3s;">
                    <span style="font-size: 0.9em;">
                        {% if status.extra_button_playing %}
                            🔘 Button sound playing...
                        {% else %}
                            🔘 Button ready
                        {% endif %}
                    </span>
                </div>
                {% endif %}
            </div>
            <button class="btn btn-secondary" onclick="refreshStatus()">🔄 Refresh</button>
        </div>

        <!-- Volume & Delay Control Card -->
        <div class="card">
            <h2>🔊 Volume & Delay Control</h2>

            <!-- Volume Control -->
            <div style="padding: 20px; border-bottom: 1px solid #e5e7eb;">
                <h3 style="margin: 0 0 15px 0; font-size: 1.1em; color: #333;">Volume</h3>
                <div style="display: flex; align-items: center; gap: 20px;">
                    <span style="font-size: 1.5em;">🔇</span>
                    <input type="range" id="volume-slider" min="0" max="100" value="{{ volume }}"
                           style="flex: 1; height: 8px; border-radius: 5px; outline: none; background: linear-gradient(to right, #667eea 0%, #667eea {{ volume }}%, #ddd {{ volume }}%, #ddd 100%);">
                    <span style="font-size: 1.5em;">🔊</span>
                    <span id="volume-display" style="font-weight: bold; min-width: 50px; text-align: center; font-size: 1.2em;">{{ volume }}%</span>
                </div>
                <p style="margin-top: 10px; color: #6b7280; font-size: 0.85em; text-align: center;">
                    Playback volume for greeting messages
                </p>
            </div>

            <!-- Greeting Delay Control -->
            <div style="padding: 20px;">
                <h3 style="margin: 0 0 15px 0; font-size: 1.1em; color: #333;">Greeting Delay</h3>
                <div style="display: flex; align-items: center; gap: 20px;">
                    <span style="font-size: 1.5em;">⏱️</span>
                    <input type="range" id="delay-slider" min="0" max="10" value="{{ greeting_delay }}"
                           style="flex: 1; height: 8px; border-radius: 5px; outline: none; background: linear-gradient(to right, #667eea 0%, #667eea {{ greeting_delay * 10 }}%, #ddd {{ greeting_delay * 10 }}%, #ddd 100%);">
                    <span style="font-size: 1.5em;">⏰</span>
                    <span id="delay-display" style="font-weight: bold; min-width: 50px; text-align: center; font-size: 1.2em;">{{ greeting_delay }}s</span>
                </div>
                <p style="margin-top: 10px; color: #6b7280; font-size: 0.85em; text-align: center;">
                    Delay before greeting plays after pickup (0-10 seconds)
                </p>
            </div>
        </div>

        <!-- Greeting Messages Card -->
        <div class="card">
            <h2>🎵 Greeting Messages</h2>

            <div class="alert alert-info">
                ℹ️ Active greeting: <strong>{{ active_greeting }}</strong>
                {% if extra_button_enabled %}
                <br>🔘 Extra button sound: <strong>{{ extra_button_sound }}</strong>
                {% endif %}
            </div>

            <div class="upload-section">
                <p style="margin-bottom: 15px; color: #6b7280;">
                    Upload WAV files to play when the handset is picked up
                </p>
                <form id="upload-form" enctype="multipart/form-data">
                    <label for="soundfile" class="upload-label">
                        📁 Choose WAV File(s)
                    </label>
                    <input type="file" id="soundfile" name="soundfile" accept=".wav" multiple onchange="handleFileSelect(this)">
                    <div id="filename-display" class="filename-display" style="display: none;"></div>
                </form>

                <div class="button-group">
                    <button class="btn btn-primary" onclick="uploadGreeting()" id="upload-btn" disabled>
                        ⬆️ Upload Greeting(s)
                    </button>
                    <button class="btn btn-secondary" onclick="restoreDefault()">
                        🔄 Generate Default Dial Tone
                    </button>
                </div>
            </div>

            <!-- Greetings List -->
            {% if greetings %}
            <h3 style="margin-top: 30px; margin-bottom: 15px; color: #333;">Available Greetings</h3>
            <div class="recordings-grid">
                {% for greeting in greetings %}
                <div class="recording-item {% if greeting.is_active %}active-greeting{% endif %}" id="greeting-{{ loop.index }}">
                    <div class="recording-info">
                        <h3>
                            {% if greeting.is_active %}⭐{% endif %}
                            {% if greeting.is_button_sound and extra_button_enabled %}🔘{% endif %}
                            {{ greeting.filename }}
                        </h3>
                        <div class="recording-meta">
                            📅 {{ greeting.date }} |
                            ⏱️ {{ "%.1f"|format(greeting.duration) }}s |
                            💾 {{ "%.2f"|format(greeting.size_mb) }} MB
                        </div>
                    </div>
                    <div class="recording-actions">
                        <button class="btn btn-success" onclick="playAudio('greeting', '{{ greeting.filename }}')">
                            ▶️ Play
                        </button>
                        {% if not greeting.is_active %}
                        <button class="btn btn-primary" onclick="setActiveGreeting('{{ greeting.filename }}')">
                            ⭐ Set Active
                        </button>
                        {% if extra_button_enabled and not greeting.is_button_sound %}
                        <button class="btn btn-primary" onclick="setExtraButtonSound('{{ greeting.filename }}')">
                            🔘 Set Button
                        </button>
                        {% endif %}
                        <button class="btn btn-danger" onclick="deleteGreeting('{{ greeting.filename }}', {{ loop.index }})">
                            🗑️ Delete
                        </button>
                        {% else %}
                        <button class="btn btn-secondary" disabled>
                            ✓ Active
                        </button>
                        {% if extra_button_enabled and not greeting.is_button_sound %}
                        <button class="btn btn-primary" onclick="setExtraButtonSound('{{ greeting.filename }}')">
                            🔘 Set Button
                        </button>
                        {% endif %}
                        {% endif %}
                    </div>
                </div>
                {% endfor %}
            </div>
            {% else %}
            <div class="no-recordings" style="margin-top: 20px;">
                <p style="font-size: 2em; margin-bottom: 10px;">🎵</p>
                <p>No greeting messages uploaded yet. Upload your first greeting!</p>
            </div>
            {% endif %}
        </div>

        <!-- USB Backup Card -->
        <div class="card">
            <h2>💾 USB Backup</h2>

            <div style="padding: 20px;">
                <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 15px;">
                    <div>
                        <p style="margin: 0; color: #6b7280; font-size: 0.9em;">
                            Automatic backup to USB drives with CRC verification
                        </p>
                    </div>
                    <button class="btn btn-primary" onclick="refreshBackupStatus()">🔄 Refresh</button>
                </div>

                <div id="backup-status-container">
                    <p style="text-align: center; color: #6b7280;">Loading backup status...</p>
                </div>

                <div style="margin-top: 20px; text-align: center;">
                    <button class="btn btn-success" onclick="testBackup()">
                        🧪 Test Backup
                    </button>
                </div>
            </div>
        </div>

        <!-- Recordings Card -->
        <div class="card">
            <h2>🎙️ Recordings</h2>
            
            {% if recordings %}
            <div class="stats">
                <div class="stat-box">
                    <div class="stat-value">{{ recordings|length }}</div>
                    <div class="stat-label">Total Recordings</div>
                </div>
                <div class="stat-box">
                    <div class="stat-value">{{ "%.1f"|format(recordings|sum(attribute='size_mb')) }} MB</div>
                    <div class="stat-label">Total Size</div>
                </div>
                <div class="stat-box">
                    <div class="stat-value">{{ "%.1f"|format(recordings|sum(attribute='duration')/60) }} min</div>
                    <div class="stat-label">Total Duration</div>
                </div>
            </div>
            
            <div class="recordings-grid" style="margin-top: 30px;">
                {% for recording in recordings %}
                <div class="recording-item" id="recording-{{ loop.index }}">
                    <div class="recording-info">
                        <h3>{{ recording.filename }}</h3>
                        <div class="recording-meta">
                            📅 {{ recording.date }} | 
                            ⏱️ {{ "%.1f"|format(recording.duration) }}s | 
                            💾 {{ "%.2f"|format(recording.size_mb) }} MB
                        </div>
                    </div>
                    <div class="recording-actions">
                        <button class="btn btn-success" onclick="playAudio('recording', '{{ recording.filename }}')">
                            ▶️ Play
                        </button>
                        <button class="btn btn-primary" onclick="downloadRecording('{{ recording.filename }}')">
                            ⬇️ Download
                        </button>
                        <button class="btn btn-danger" onclick="deleteRecording('{{ recording.filename }}', {{ loop.index }})">
                            🗑️ Delete
                        </button>
                    </div>
                </div>
                {% endfor %}
            </div>
            {% else %}
            <div class="no-recordings">
                <p style="font-size: 3em; margin-bottom: 10px;">📭</p>
                <p>No recordings yet. Pick up the phone to start recording!</p>
            </div>
            {% endif %}
        </div>
    </div>

    <!-- Audio Player Modal -->
    <div id="audio-modal" class="audio-modal" onclick="closeAudioModal(event)">
        <div class="audio-modal-content" onclick="event.stopPropagation()">
            <div class="audio-modal-header">
                <h3>🎵 Audio Player</h3>
                <button class="close-modal" onclick="closeAudioModal()">&times;</button>
            </div>
            <div class="audio-player-container">
                <div class="audio-filename" id="audio-filename"></div>
                <audio id="audio-player" controls autoplay>
                    Your browser does not support the audio element.
                </audio>
            </div>
        </div>
    </div>

    <script>
        let selectedFiles = null;
        let volumeUpdateTimer = null;
        let delayUpdateTimer = null;

        // Volume control
        const volumeSlider = document.getElementById('volume-slider');
        const volumeDisplay = document.getElementById('volume-display');

        volumeSlider.addEventListener('input', function() {
            const value = this.value;
            volumeDisplay.textContent = value + '%';

            // Update slider background gradient
            this.style.background = `linear-gradient(to right, #667eea 0%, #667eea ${value}%, #ddd ${value}%, #ddd 100%)`;

            // Debounce API call
            clearTimeout(volumeUpdateTimer);
            volumeUpdateTimer = setTimeout(() => {
                updateVolume(value);
            }, 300);
        });

        function updateVolume(volume) {
            fetch('/api/volume', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                },
                body: JSON.stringify({ volume: parseInt(volume) })
            })
            .then(response => response.json())
            .then(data => {
                if (data.success) {
                    console.log('Volume updated to ' + data.volume + '%');
                }
            })
            .catch(error => console.error('Error updating volume:', error));
        }

        // Greeting Delay control
        const delaySlider = document.getElementById('delay-slider');
        const delayDisplay = document.getElementById('delay-display');

        delaySlider.addEventListener('input', function() {
            const value = this.value;
            delayDisplay.textContent = value + 's';

            // Update slider background gradient (0-10 range = 0-100%)
            const percent = (value / 10) * 100;
            this.style.background = `linear-gradient(to right, #667eea 0%, #667eea ${percent}%, #ddd ${percent}%, #ddd 100%)`;

            // Debounce API call
            clearTimeout(delayUpdateTimer);
            delayUpdateTimer = setTimeout(() => {
                updateGreetingDelay(value);
            }, 300);
        });

        function updateGreetingDelay(delay) {
            fetch('/api/greeting_delay', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                },
                body: JSON.stringify({ delay: parseInt(delay) })
            })
            .then(response => response.json())
            .then(data => {
                if (data.success) {
                    console.log('Greeting delay updated to ' + data.delay + 's');
                }
            })
            .catch(error => console.error('Error updating delay:', error));
        }

        function handleFileSelect(input) {
            if (input.files && input.files.length > 0) {
                selectedFiles = input.files;
                const fileCount = selectedFiles.length;
                const displayText = fileCount === 1
                    ? '📄 ' + selectedFiles[0].name
                    : `📄 ${fileCount} files selected`;
                document.getElementById('filename-display').textContent = displayText;
                document.getElementById('filename-display').style.display = 'block';
                document.getElementById('upload-btn').disabled = false;
            }
        }

        async function uploadGreeting() {
            if (!selectedFiles || selectedFiles.length === 0) {
                showAlert('Please select file(s) first', 'error');
                return;
            }

            document.getElementById('upload-btn').disabled = true;
            document.getElementById('upload-btn').textContent = '⏳ Uploading...';

            let successCount = 0;
            let errorCount = 0;

            for (let i = 0; i < selectedFiles.length; i++) {
                const formData = new FormData();
                formData.append('soundfile', selectedFiles[i]);

                try {
                    const response = await fetch('/upload_greeting', {
                        method: 'POST',
                        body: formData
                    });
                    const data = await response.json();

                    if (data.success) {
                        successCount++;
                    } else {
                        errorCount++;
                    }
                } catch (error) {
                    errorCount++;
                }
            }

            if (errorCount === 0) {
                showAlert(`${successCount} greeting(s) uploaded successfully! ✓`, 'success');
            } else {
                showAlert(`${successCount} succeeded, ${errorCount} failed`, 'error');
            }

            setTimeout(() => location.reload(), 1500);
        }
        
        function restoreDefault() {
            if (confirm('Restore the default dial tone sound?')) {
                fetch('/restore_default_sound', { method: 'POST' })
                .then(response => response.json())
                .then(data => {
                    if (data.success) {
                        showAlert('Default dial tone restored! ✓', 'success');
                        setTimeout(() => location.reload(), 1500);
                    }
                })
                .catch(error => showAlert('Error: ' + error, 'error'));
            }
        }
        
        function downloadRecording(filename) {
            window.location.href = '/download/' + filename;
        }
        
        function deleteRecording(filename, index) {
            if (confirm('Delete this recording?')) {
                fetch('/delete/' + filename, { method: 'POST' })
                .then(response => response.json())
                .then(data => {
                    if (data.success) {
                        document.getElementById('recording-' + index).remove();
                        showAlert('Recording deleted! ✓', 'success');
                        setTimeout(() => location.reload(), 1500);
                    }
                })
                .catch(error => showAlert('Error: ' + error, 'error'));
            }
        }

        function playAudio(type, filename) {
            const modal = document.getElementById('audio-modal');
            const player = document.getElementById('audio-player');
            const filenameDisplay = document.getElementById('audio-filename');

            filenameDisplay.textContent = filename;
            player.src = '/play_audio/' + type + '/' + filename;
            modal.classList.add('show');
        }

        function closeAudioModal(event) {
            const modal = document.getElementById('audio-modal');
            const player = document.getElementById('audio-player');

            player.pause();
            player.src = '';
            modal.classList.remove('show');
        }

        function setActiveGreeting(filename) {
            fetch('/set_active_greeting', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                },
                body: JSON.stringify({ filename: filename })
            })
            .then(response => response.json())
            .then(data => {
                if (data.success) {
                    showAlert(`Greeting set to '${filename}'! ✓`, 'success');
                    setTimeout(() => location.reload(), 1500);
                } else {
                    showAlert('Error: ' + data.error, 'error');
                }
            })
            .catch(error => showAlert('Error: ' + error, 'error'));
        }

        function setExtraButtonSound(filename) {
            fetch('/set_extra_button_sound', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                },
                body: JSON.stringify({ filename: filename })
            })
            .then(response => response.json())
            .then(data => {
                if (data.success) {
                    showAlert(`Button sound set to '${filename}'! ✓`, 'success');
                    setTimeout(() => location.reload(), 1500);
                } else {
                    showAlert('Error: ' + data.error, 'error');
                }
            })
            .catch(error => showAlert('Error: ' + error, 'error'));
        }

        function deleteGreeting(filename, index) {
            if (confirm(`Delete greeting '${filename}'?`)) {
                fetch('/delete_greeting/' + filename, { method: 'POST' })
                .then(response => response.json())
                .then(data => {
                    if (data.success) {
                        document.getElementById('greeting-' + index).remove();
                        showAlert('Greeting deleted! ✓', 'success');
                        setTimeout(() => location.reload(), 1500);
                    } else {
                        showAlert('Error: ' + data.error, 'error');
                    }
                })
                .catch(error => showAlert('Error: ' + error, 'error'));
            }
        }
        
        function refreshStatus() {
            fetch('/api/status')
            .then(response => response.json())
            .then(data => {
                // Update status text
                const statusText = document.getElementById('status-text');
                const statusDot = document.getElementById('status-dot');

                if (data.recording) {
                    statusText.textContent = '🔴 Recording in progress...';
                    statusDot.className = 'status-dot recording';
                } else if (data.status === 'off_hook') {
                    statusText.textContent = '📞 Handset off hook';
                    statusDot.className = 'status-dot off-hook';
                } else {
                    statusText.textContent = '✅ Ready (handset on hook)';
                    statusDot.className = 'status-dot on-hook';
                }

                // Update extra button status
                const buttonStatus = document.getElementById('button-status');
                if (buttonStatus) {
                    if (data.extra_button_playing) {
                        buttonStatus.style.background = '#fef3c7';
                        buttonStatus.querySelector('span').textContent = '🔘 Button sound playing...';
                    } else {
                        buttonStatus.style.background = '#f3f4f6';
                        buttonStatus.querySelector('span').textContent = '🔘 Button ready';
                    }
                }
            })
            .catch(error => console.error('Error refreshing status:', error));
        }
        
        function showAlert(message, type) {
            const alertDiv = document.createElement('div');
            alertDiv.className = 'alert alert-' + type;
            alertDiv.textContent = message;

            const container = document.getElementById('alert-container');
            container.innerHTML = '';
            container.appendChild(alertDiv);

            setTimeout(() => {
                alertDiv.remove();
            }, 5000);
        }

        // USB Backup Functions
        function refreshBackupStatus() {
            fetch('/api/backup/status')
            .then(response => response.json())
            .then(data => {
                displayBackupStatus(data);
            })
            .catch(error => console.error('Error fetching backup status:', error));
        }

        function displayBackupStatus(data) {
            const container = document.getElementById('backup-status-container');

            if (!data.enabled) {
                container.innerHTML = `
                    <div class="alert alert-warning">
                        ⚠️ USB backup is disabled in configuration
                    </div>
                `;
                return;
            }

            let html = `
                <div style="margin-bottom: 15px;">
                    <p style="margin: 5px 0;"><strong>CRC Verification:</strong> ${data.verify_crc ? '✅ Enabled' : '❌ Disabled'}</p>
                    <p style="margin: 5px 0;"><strong>Backup on Write:</strong> ${data.backup_on_write ? '✅ Enabled' : '❌ Disabled'}</p>
                </div>
                <div style="display: grid; gap: 15px;">
            `;

            data.drives.forEach(drive => {
                let statusColor = '#dc2626'; // red
                let statusIcon = '❌';
                let statusText = 'Not Mounted';

                if (drive.mounted) {
                    if (drive.writable) {
                        statusColor = '#16a34a'; // green
                        statusIcon = '✅';
                        statusText = 'Ready';
                    } else {
                        statusColor = '#ea580c'; // orange
                        statusIcon = '⚠️';
                        statusText = 'Not Writable';
                    }
                }

                html += `
                    <div style="border: 2px solid ${statusColor}; border-radius: 8px; padding: 15px; background: ${statusColor}15;">
                        <div style="display: flex; justify-content: space-between; align-items: center;">
                            <div>
                                <p style="margin: 0; font-weight: bold; font-size: 1.1em;">${statusIcon} ${drive.name}</p>
                                <p style="margin: 5px 0 0 0; color: #6b7280; font-size: 0.85em;">${drive.path}</p>
                            </div>
                            <div style="text-align: right;">
                                <p style="margin: 0; font-weight: bold; color: ${statusColor};">${statusText}</p>
                                ${drive.free_space_mb ? `<p style="margin: 5px 0 0 0; color: #6b7280; font-size: 0.85em;">${drive.free_space_mb.toFixed(0)} MB free</p>` : ''}
                            </div>
                        </div>
                        ${drive.error ? `<p style="margin: 10px 0 0 0; color: #dc2626; font-size: 0.85em;">Error: ${drive.error}</p>` : ''}
                    </div>
                `;
            });

            html += '</div>';
            container.innerHTML = html;
        }

        function testBackup() {
            const btn = event.target;
            btn.disabled = true;
            btn.textContent = '🔄 Testing...';

            fetch('/api/backup/test', {
                method: 'POST'
            })
            .then(response => response.json())
            .then(data => {
                if (data.success) {
                    showAlert('Backup test completed. Check console for results.', 'success');
                    console.log('Backup test results:', data.results);
                } else {
                    showAlert('Backup test failed: ' + data.error, 'error');
                }
                btn.disabled = false;
                btn.textContent = '🧪 Test Backup';
                refreshBackupStatus();
            })
            .catch(error => {
                showAlert('Backup test error: ' + error, 'error');
                btn.disabled = false;
                btn.textContent = '🧪 Test Backup';
            });
        }

        // Load backup status on page load
        document.addEventListener('DOMContentLoaded', function() {
            refreshBackupStatus();
        });

        // Auto-refresh status every 5 seconds
        setInterval(() => {
            fetch('/api/status')
            .then(response => response.json())
            .then(data => {
                const statusDot = document.getElementById('status-dot');
                const statusText = document.getElementById('status-text');
                
                statusDot.className = 'status-dot';
                
                if (data.recording) {
                    statusDot.classList.add('recording');
                    statusText.textContent = '🔴 Recording in progress...';
                } else if (data.status === 'off_hook') {
                    statusDot.classList.add('off-hook');
                    statusText.textContent = '📞 Handset off hook';
                } else {
                    statusDot.classList.add('on-hook');
                    statusText.textContent = '✅ Ready (handset on hook)';
                }
            });
        }, 5000);
    </script>
</body>
</html>''')
    else:
        print(f"Template already exists at {template_file}")
    
    # Start phone handling in separate thread
    phone_thread = threading.Thread(target=phone.phone_loop, daemon=True)
    phone_thread.start()
    
    # Get and display local IP
    local_ip = get_local_ip()
    print("\n" + "="*60)
    print(f"Web Interface Available At:")
    print(f"  http://{local_ip}:{WEB_PORT}")
    print(f"  http://localhost:{WEB_PORT}")
    print("="*60 + "\n")
    
    # Start Flask web server
    app.run(host='0.0.0.0', port=WEB_PORT, debug=False, threaded=True)

if __name__ == "__main__":
    main()