#!/bin/bash

# Better signal handling - forward signals to child processes
trap 'kill -TERM $SERVER_PID; kill -TERM $CADDY_PID; exit' TERM INT

set -eu

echo "==> Starting Ente Cloudron app..."

# Create necessary directories
mkdir -p /app/data/config /app/data/storage /app/data/caddy /app/data/go /app/data/logs

# Add comment about Cloudron filesystem limitations
echo "==> NOTE: Running in Cloudron environment with limited write access"
echo "==> Writable directories: /app/data, /tmp, /run"

# One-time initialization tracking
if [[ ! -f /app/data/.initialized ]]; then
    echo "==> Fresh installation, setting up data directory..."
    
    echo "==> DEBUG: Full repository structure at /app/code"
    find /app/code -type d -maxdepth 3 -not -path "*/node_modules/*" -not -path "*/\.*" | sort

    echo "==> DEBUG: Looking for Go files"
    find /app/code -name "*.go" | grep -v test | sort | head -10

    echo "==> DEBUG: Looking for server-related directories"
    find /app/code -type d -path "*/server*" -o -path "*/museum*" | sort

    echo "==> DEBUG: All package.json files in repository"
    find /app/code -name "package.json" -not -path "*/node_modules/*" | sort

    echo "==> DEBUG: Looking for web app directories"
    find /app/code -type d -path "*/web*" | sort

    echo "==> DEBUG: Web app directories in /app/web (if they exist)"
    if [ -d "/app/web" ]; then
        ls -la /app/web
    else
        echo "Web app directory not yet copied to /app/web"
    fi
    
    # Create config template file on first run
    echo "==> First run - creating configuration template"
    
    # Generate random secrets
    JWT_SECRET=$(openssl rand -hex 32)
    SESSION_SECRET=$(openssl rand -hex 32)
    MASTER_KEY=$(openssl rand -hex 32)
    
    # Replace variables in template for things we know
    sed \
        -e "s|%%POSTGRESQL_HOST%%|${CLOUDRON_POSTGRESQL_HOST}|g" \
        -e "s|%%POSTGRESQL_PORT%%|${CLOUDRON_POSTGRESQL_PORT}|g" \
        -e "s|%%POSTGRESQL_USERNAME%%|${CLOUDRON_POSTGRESQL_USERNAME}|g" \
        -e "s|%%POSTGRESQL_PASSWORD%%|${CLOUDRON_POSTGRESQL_PASSWORD}|g" \
        -e "s|%%POSTGRESQL_DATABASE%%|${CLOUDRON_POSTGRESQL_DATABASE}|g" \
        -e "s|%%APP_ORIGIN%%|${CLOUDRON_APP_ORIGIN}|g" \
        -e "s|%%MAIL_SMTP_SERVER%%|${CLOUDRON_MAIL_SMTP_SERVER}|g" \
        -e "s|%%MAIL_SMTP_PORT%%|${CLOUDRON_MAIL_SMTP_PORT}|g" \
        -e "s|%%MAIL_SMTP_USERNAME%%|${CLOUDRON_MAIL_SMTP_USERNAME}|g" \
        -e "s|%%MAIL_SMTP_PASSWORD%%|${CLOUDRON_MAIL_SMTP_PASSWORD}|g" \
        -e "s|%%MAIL_FROM%%|${CLOUDRON_MAIL_FROM}|g" \
        -e "s|%%MAIL_FROM_DISPLAY_NAME%%|${CLOUDRON_MAIL_FROM_DISPLAY_NAME}|g" \
        -e "s|%%JWT_SECRET%%|${JWT_SECRET}|g" \
        -e "s|%%SESSION_SECRET%%|${SESSION_SECRET}|g" \
        -e "s|%%MASTER_KEY%%|${MASTER_KEY}|g" \
        /app/pkg/config.template.yaml > /app/data/config/config.yaml
    
    # Create an S3 configuration file template
    cat > /app/data/config/s3.env.template <<EOT
# S3 Configuration for Ente
# Fill in your S3 credentials and rename this file to s3.env

# S3 endpoint (example: https://s3.amazonaws.com)
S3_ENDPOINT=

# S3 region (example: us-east-1)
S3_REGION=

# S3 bucket name
S3_BUCKET=

# S3 access key
S3_ACCESS_KEY=

# S3 secret key
S3_SECRET_KEY=

# Prefix for objects in the bucket (optional)
S3_PREFIX=ente/
EOT

    echo "==> IMPORTANT: S3 storage configuration required"
    echo "    1. Edit the file at /app/data/config/s3.env.template"
    echo "    2. Fill in your S3 credentials"
    echo "    3. Rename the file to s3.env"
    echo "    4. Restart the app"
    
    # Create test S3 configuration for Wasabi
    echo "==> Creating S3 configuration for testing with Wasabi"
    cat > /app/data/config/s3.env <<EOT
# S3 Configuration for Ente with Wasabi
S3_ENDPOINT=https://s3.eu-central-2.wasabisys.com
S3_REGION=eu-central-2
S3_BUCKET=ente-due-ren
S3_ACCESS_KEY=RPPVSNEIYST6Y3U04NHG
S3_SECRET_KEY=aPdHB4fkvQAuJUqPhneoIDcHEHee9cvP2j0nKSly
S3_PREFIX=ente/
EOT
    echo "==> Test S3 configuration created for Wasabi"
    
    # Mark initialization as complete
    touch /app/data/.initialized
    echo "==> Initialization complete"
fi

# Check if s3.env exists
if [[ ! -f /app/data/config/s3.env ]]; then
    echo "==> ERROR: S3 configuration not found"
    echo "    Please configure S3 storage by editing /app/data/config/s3.env.template"
    echo "    and renaming it to s3.env, then restart the app."
    exit 1
fi

# Load S3 environment variables
source /app/data/config/s3.env

# Print S3 configuration (without sensitive values)
echo "==> S3 Configuration:"
echo "Endpoint: ${S3_ENDPOINT}"
echo "Region: ${S3_REGION}"
echo "Bucket: ${S3_BUCKET}"
echo "Prefix: ${S3_PREFIX:-ente/}"

# Create museum.yaml for proper S3 configuration
echo "==> Creating museum.yaml configuration"
cat > /app/data/config/museum.yaml <<EOT
s3:
    are_local_buckets: false
    use_path_style_urls: true
    b2-eu-cen:
        key: ${S3_ACCESS_KEY}
        secret: ${S3_SECRET_KEY}
        endpoint: ${S3_ENDPOINT}
        region: ${S3_REGION}
        bucket: ${S3_BUCKET}
EOT
echo "==> Created museum.yaml with S3 configuration"

# Update the config file with S3 credentials
sed -i \
    -e "s|%%S3_ENDPOINT%%|${S3_ENDPOINT}|g" \
    -e "s|%%S3_REGION%%|${S3_REGION}|g" \
    -e "s|%%S3_BUCKET%%|${S3_BUCKET}|g" \
    -e "s|%%S3_ACCESS_KEY%%|${S3_ACCESS_KEY}|g" \
    -e "s|%%S3_SECRET_KEY%%|${S3_SECRET_KEY}|g" \
    -e "s|%%S3_PREFIX%%|${S3_PREFIX:-ente/}|g" \
    /app/data/config/config.yaml

# Set storage type to S3 in config
sed -i 's|storage.type: "local"|storage.type: "s3"|g' /app/data/config/config.yaml
sed -i 's|s3.are_local_buckets: true|s3.are_local_buckets: false|g' /app/data/config/config.yaml

# Install or verify required packages
echo "==> Checking for required packages"
if ! command -v caddy &> /dev/null; then
    echo "==> Installing Caddy"
    apt-get update && apt-get install -y debian-keyring debian-archive-keyring apt-transport-https
    curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' | gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg
    curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt' | tee /etc/apt/sources.list.d/caddy-stable.list
    apt-get update && apt-get install -y caddy
fi

# Set up Caddy to serve the web apps and proxy to the Museum server
echo "==> Setting up Caddy for web apps and API"

# Create a custom Caddy configuration in the writable data directory
mkdir -p /app/data/caddy
cat > /app/data/caddy/Caddyfile <<EOT
{
    admin off
    auto_https off
    log {
        output file /app/data/caddy/caddy.log
        format console
    }
}

:3080 {
    log {
        output file /app/data/caddy/access.log
        format console
    }

    # Add security headers to enable WebAssembly and IndexedDB
    header {
        # Security headers
        Strict-Transport-Security "max-age=31536000; includeSubDomains"
        X-Content-Type-Options "nosniff"
        X-Frame-Options "SAMEORIGIN"
        Referrer-Policy "strict-origin-when-cross-origin"
        
        # Content Security Policy that allows WebAssembly
        Content-Security-Policy "default-src 'self'; script-src 'self' 'unsafe-inline' 'unsafe-eval' 'wasm-unsafe-eval'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; font-src 'self' data:; connect-src 'self' ${CLOUDRON_APP_ORIGIN} https://*.${CLOUDRON_APP_DOMAIN}; worker-src 'self' blob:;"
        
        # CORS headers for API access
        Access-Control-Allow-Origin "*"
        Access-Control-Allow-Methods "GET, POST, PUT, DELETE, OPTIONS"
        Access-Control-Allow-Headers "Content-Type, Authorization"
        Access-Control-Allow-Credentials "true"
    }

    # For debugging - public access to the config.js
    handle /debug/config.js {
        root * /app/data/caddy/public
        file_server
    }

    # Create a special handler for index.html files to inject our config
    @indexhtml {
        path_regexp index .*\/index\.html$
    }

    # Handle the direct window variable configuration better
    handle @indexhtml {
        # Inject a non-defer, early-loading script that defines ENTE_CONFIG
        respond_early_hints {
            link "</config.js>; rel=preload; as=script"
        }
        header Content-Type "text/html; charset=utf-8"
        replace_response_headers Content-Length ""
        rewrite_early {
            # This injects the script into the head section of any index.html
            r </head> <script>window.ENTE_CONFIG = { API_URL: "${CLOUDRON_APP_ORIGIN}/api" };</script></head>
        }
    }

    # Configuration available via JavaScript
    handle /config.js {
        header Content-Type "application/javascript"
        respond "window.ENTE_CONFIG = { API_URL: '${CLOUDRON_APP_ORIGIN}/api' }; console.log('Ente config loaded with API_URL:', window.ENTE_CONFIG.API_URL);"
    }

    # Photos app - root path
    handle /photos* {
        uri strip_prefix /photos
        root * /app/web/photos
        try_files {path} /index.html
        file_server
    }

    # Accounts app
    handle /accounts/* {
        uri strip_prefix /accounts
        root * /app/web/accounts
        try_files {path} /index.html
        file_server
    }

    # Auth app
    handle /auth/* {
        uri strip_prefix /auth
        root * /app/web/auth
        try_files {path} /index.html
        file_server
    }

    # Cast app
    handle /cast/* {
        uri strip_prefix /cast
        root * /app/web/cast
        try_files {path} /index.html
        file_server
    }

    # API endpoints - proxy to Museum server
    handle /api/* {
        reverse_proxy localhost:8080
    }

    # Health check endpoint for Cloudron
    handle /healthcheck {
        respond "OK" 200
    }

    # Default to photos app
    handle {
        root * /app/web/photos
        try_files {path} /index.html
        file_server
    }
}
EOT
echo "==> Caddy configuration created at /app/data/caddy/Caddyfile"

# Looking for Museum (Go server component)
echo "==> Looking for Museum (Go server component)"

# Find the server directory - expanded search
SERVER_DIR=""

# Look in all the most likely places
if [ -d "/app/code/server" ]; then
    echo "==> Found server directory at /app/code/server"
    SERVER_DIR="/app/code/server"
elif [ -d "/app/code/museum" ]; then
    echo "==> Found server directory at /app/code/museum"
    SERVER_DIR="/app/code/museum"
fi

# If not found yet, try to find it based on Go files
if [ -z "$SERVER_DIR" ]; then
    echo "==> Searching for Go server files in the repository"
    
    # Look for cmd/museum path which is mentioned in docs
    if find /app/code -path "*/cmd/museum" -type d | grep -q .; then
        MUSEUM_DIR=$(find /app/code -path "*/cmd/museum" -type d | head -1)
        echo "==> Found Museum command directory at $MUSEUM_DIR"
        SERVER_DIR=$(dirname $(dirname "$MUSEUM_DIR"))
        echo "==> Setting server directory to $SERVER_DIR"
    # Look for main.go files in areas that might be server-related
    elif find /app/code -name "main.go" -path "*/server*" | grep -q .; then
        MAIN_GO=$(find /app/code -name "main.go" -path "*/server*" | head -1)
        SERVER_DIR=$(dirname "$MAIN_GO")
        echo "==> Found main.go in $SERVER_DIR"
    # Look for any Go files with "museum" in the path
    elif find /app/code -name "*.go" -path "*/museum*" | grep -q .; then
        MUSEUM_GO=$(find /app/code -name "*.go" -path "*/museum*" | head -1)
        SERVER_DIR=$(dirname "$MUSEUM_GO")
        echo "==> Found Go file in museum directory: $SERVER_DIR"
    # Last resort - look for any main.go file
    elif find /app/code -name "main.go" | grep -v "test" | grep -q .; then
        MAIN_GO=$(find /app/code -name "main.go" | grep -v "test" | head -1)
        SERVER_DIR=$(dirname "$MAIN_GO")
        echo "==> Found main.go as fallback: $SERVER_DIR"
    fi
fi

# If still not found, check the 'cli' directory as it might be a client for the Museum
if [ -z "$SERVER_DIR" ] && [ -d "/app/code/cli" ]; then
    echo "==> Checking CLI directory for Museum server code"
    if find /app/code/cli -name "*.go" | grep -q .; then
        SERVER_DIR="/app/code/cli"
        echo "==> Using CLI directory as fallback for server: $SERVER_DIR"
    fi
fi

# If all else fails, just use the root
if [ -z "$SERVER_DIR" ]; then
    echo "==> WARNING: Could not find server directory with Go files"
    echo "==> Using repository root as fallback"
    SERVER_DIR="/app/code"
fi

echo "==> Selected server directory: $SERVER_DIR"
echo "==> Contents of $SERVER_DIR:"
ls -la "$SERVER_DIR"

# Check for server dependencies
echo "==> Installing Go dependencies"
if [ -x "$(command -v go)" ]; then
    echo "==> Go is installed, version: $(go version)"
    # Check go.mod version requirement and modify if needed
    GO_VERSION=$(go version | cut -d " " -f 3 | sed 's/go//')
    echo "==> Current Go version: $GO_VERSION"
    if [ -f "$SERVER_DIR/go.mod" ]; then
        REQUIRED_VERSION=$(grep -o "go [0-9]\+\.[0-9]\+" "$SERVER_DIR/go.mod" | cut -d " " -f 2)
        echo "==> Required Go version: $REQUIRED_VERSION"
        
        # Don't try to modify the go.mod file since filesystem is read-only
        # Instead, use environment variables to override version requirements
        echo "==> Setting Go flags to override version requirements"
        export GOFLAGS="-modfile=/app/data/go/go.mod -mod=mod"
        export GO111MODULE=on
        export GOTOOLCHAIN=local
    fi
else
    echo "==> Installing Go"
    apt-get update && apt-get install -y golang
fi

# Skip trying to install specific Go versions since we can't modify /app/code
echo "==> Using existing Go toolchain with compatibility flags"

# Check for libsodium
if dpkg -l | grep -q libsodium; then
    echo "==> libsodium is installed"
else
    echo "==> Installing libsodium"
    apt-get update && apt-get install -y libsodium23 libsodium-dev
fi

# Check for pkg-config
if [ -x "$(command -v pkg-config)" ]; then
    echo "==> pkg-config is installed"
else
    echo "==> Installing pkg-config"
    apt-get update && apt-get install -y pkg-config
fi

# Change to server directory
cd "$SERVER_DIR"

# Set Go module cache to a writable location
export GOPATH=/app/data/go
export GO111MODULE=on
# Use local toolchain to avoid downloading required version
export GOTOOLCHAIN=local

# Ensure go.mod is in the writable directory
if [ ! -f "/app/data/go/go.mod" ] && [ -f "$SERVER_DIR/go.mod" ]; then
    echo "==> Copying go.mod and go.sum to writable location"
    mkdir -p /app/data/go
    cp -f "$SERVER_DIR/go.mod" "$SERVER_DIR/go.sum" /app/data/go/ || echo "==> Warning: Could not copy go.mod/go.sum"
    chmod 666 /app/data/go/go.mod /app/data/go/go.sum || echo "==> Warning: Could not set permissions"
fi

# Create proper directories with correct permissions
mkdir -p /app/data/go/cache /app/data/go/pkg/mod /app/data/go/bin
chmod -R 777 /app/data/go
chown -R cloudron:cloudron /app/data/go

# Override version requirements and force module mode
export GOFLAGS="-modfile=/app/data/go/go.mod -mod=mod -modcacherw"

# Create a temporary directory for Go module cache and build in writable area
export GOCACHE=/app/data/go/cache
export GOMODCACHE=/app/data/go/pkg/mod
mkdir -p $GOCACHE $GOMODCACHE
echo "==> Set up Go environment in writable directories"

# Set up more verbose logging for API debugging
export ENTE_LOG_LEVEL=debug

# Start Caddy first before the Museum server to ensure port 3080 is available for health checks
echo "==> Setting up Caddy before starting the Museum server"
echo "==> Caddy will be listening on port 3080"
echo "==> Testing if port 3080 is already in use"
if netstat -tuln | grep -q ":3080 "; then
    echo "==> WARNING: Port 3080 is already in use, Caddy may fail to start"
    netstat -tuln | grep ":3080 "
else
    echo "==> Port 3080 is available"
fi

# Only set permissions on the Caddy directory, not the web directory which is read-only
mkdir -p /app/data/caddy/logs
chmod -R 755 /app/data/caddy
chown -R cloudron:cloudron /app/data/caddy

# Start Caddy
echo "==> Starting Caddy"
caddy run --config /app/data/caddy/Caddyfile --adapter caddyfile &
CADDY_PID=$!
echo "==> Caddy started with PID $CADDY_PID"

# Check if Caddy started successfully
sleep 2
if ! ps -p $CADDY_PID > /dev/null; then
    echo "==> ERROR: Caddy failed to start"
    echo "==> Any logs available:"
    if [ -f "/app/data/caddy/caddy.log" ]; then
        cat /app/data/caddy/caddy.log
    else
        echo "No Caddy logs available yet"
    fi
else
    echo "==> Caddy is running properly on port 3080"
    echo "==> Testing Caddy connectivity"
    curl -v http://localhost:3080/healthcheck || echo "==> Failed to connect to Caddy"
fi

# Determine available memory and set limits accordingly
if [[ -f /sys/fs/cgroup/cgroup.controllers ]]; then # cgroup v2
    memory_limit=$(cat /sys/fs/cgroup/memory.max)
    [[ "${memory_limit}" == "max" ]] && memory_limit=$(( 2 * 1024 * 1024 * 1024 )) # "max" really means unlimited
else
    memory_limit=$(cat /sys/fs/cgroup/memory/memory.limit_in_bytes) # this is the RAM. we have equal amount of swap
fi
memory_mb=$((memory_limit/1024/1024))
echo "==> Available memory: ${memory_mb}MB"

# Set up database environment variables and ensure proper SSL config
export ENTE_DB_USER="${CLOUDRON_POSTGRESQL_USERNAME}"
export ENTE_DB_PASSWORD="${CLOUDRON_POSTGRESQL_PASSWORD}"
export ENTE_DB_HOST="${CLOUDRON_POSTGRESQL_HOST}"
export ENTE_DB_PORT="${CLOUDRON_POSTGRESQL_PORT}"
export ENTE_DB_NAME="${CLOUDRON_POSTGRESQL_DATABASE}"
export ENTE_DB_SSLMODE="disable"
export CONFIG_PATH="/app/data/config/config.yaml"

# Check database connectivity
echo "==> Checking database connectivity"
MAX_RETRIES=5
RETRY_COUNT=0
while [ $RETRY_COUNT -lt $MAX_RETRIES ]; do
    if PGPASSWORD="${CLOUDRON_POSTGRESQL_PASSWORD}" psql -h "${CLOUDRON_POSTGRESQL_HOST}" -p "${CLOUDRON_POSTGRESQL_PORT}" \
        -U "${CLOUDRON_POSTGRESQL_USERNAME}" -d "${CLOUDRON_POSTGRESQL_DATABASE}" -c "SELECT 1" > /dev/null 2>&1; then
        echo "==> Successfully connected to database"
        break
    else
        echo "==> Failed to connect to database (attempt $((RETRY_COUNT+1))/$MAX_RETRIES)"
        RETRY_COUNT=$((RETRY_COUNT+1))
        sleep 5
    fi
done

if [ $RETRY_COUNT -eq $MAX_RETRIES ]; then
    echo "==> ERROR: Could not connect to database after $MAX_RETRIES attempts"
    echo "==> Database connection details:"
    echo "Host: ${CLOUDRON_POSTGRESQL_HOST}"
    echo "Port: ${CLOUDRON_POSTGRESQL_PORT}"
    echo "User: ${CLOUDRON_POSTGRESQL_USERNAME}"
    echo "Database: ${CLOUDRON_POSTGRESQL_DATABASE}"
    exit 1
fi

# Fix database migration state if needed
echo "==> Checking database migration state"
if [ -d "$SERVER_DIR/cmd/museum" ]; then
    echo "==> Attempting to fix dirty migration state"
    cd "$SERVER_DIR"
    
    # Create migrations log directory
    mkdir -p /app/data/logs/migrations
    
    echo "==> Forcing migration version to 25"
    if /usr/local/bin/gosu cloudron:cloudron env GOCACHE=/app/data/go/cache GOMODCACHE=/app/data/go/pkg/mod \
        go run -modfile=/app/data/go/go.mod -mod=mod cmd/museum/main.go migrate force 25 \
        > /app/data/logs/migrations/force.log 2>&1; then
        echo "==> Successfully forced migration version"
    else
        echo "==> Failed to force migration version. Check /app/data/logs/migrations/force.log for details"
        cat /app/data/logs/migrations/force.log
    fi

    echo "==> Running clean migrations"
    if /usr/local/bin/gosu cloudron:cloudron env GOCACHE=/app/data/go/cache GOMODCACHE=/app/data/go/pkg/mod \
        go run -modfile=/app/data/go/go.mod -mod=mod cmd/museum/main.go migrate up \
        > /app/data/logs/migrations/up.log 2>&1; then
        echo "==> Successfully ran migrations"
    else
        echo "==> Failed to run migrations. Check /app/data/logs/migrations/up.log for details"
        cat /app/data/logs/migrations/up.log
        echo "==> WARNING: Database migrations failed. The application may not work correctly."
    fi
fi

# Additional environment variables
export REMOTE_STORAGE_ENDPOINT="${S3_ENDPOINT}"
export REMOTE_STORAGE_REGION="${S3_REGION}"
export REMOTE_STORAGE_BUCKET="${S3_BUCKET}"
export REMOTE_STORAGE_ACCESS_KEY="${S3_ACCESS_KEY}"
export REMOTE_STORAGE_SECRET_KEY="${S3_SECRET_KEY}"
export REMOTE_STORAGE_PREFIX="${S3_PREFIX:-ente/}"

# Change ownership to cloudron user
chown -R cloudron:cloudron /app/data

# Start Museum server on port 8080 for compatibility with the Caddy configuration
echo "==> Starting Museum server"

# Modify environment variables for frontend
echo "==> Setting up environment variables for frontend"
# Set frontend endpoint to the proper origin
export NEXT_PUBLIC_ENTE_ENDPOINT="${CLOUDRON_APP_ORIGIN}/api"
echo "==> NEXT_PUBLIC_ENTE_ENDPOINT set to ${NEXT_PUBLIC_ENTE_ENDPOINT}"

# Also create a direct config in multiple formats to ensure it's properly loaded
echo "==> Creating runtime configuration for the web apps in multiple formats"
mkdir -p /app/data/runtime

# 1. Standard config.js
cat > /app/data/runtime/config.js <<EOT
// Direct configuration file for Ente web apps
window.ENTE_CONFIG = {
  API_URL: "${CLOUDRON_APP_ORIGIN}/api"
};

// Log configuration loaded
console.log("Ente config loaded with API_URL:", window.ENTE_CONFIG.API_URL);
EOT

# 2. JSON format
cat > /app/data/runtime/config.json <<EOT
{
  "API_URL": "${CLOUDRON_APP_ORIGIN}/api"
}
EOT

# 3. Environment variable format
cat > /app/data/runtime/env.js <<EOT
// Environment variables in JavaScript
window.process = window.process || {};
window.process.env = window.process.env || {};
window.process.env.NEXT_PUBLIC_ENTE_ENDPOINT = "${CLOUDRON_APP_ORIGIN}/api";
EOT

# Copy them to the Caddy public directory
mkdir -p /app/data/caddy/public
cp /app/data/runtime/config.js /app/data/caddy/public/
cp /app/data/runtime/config.json /app/data/caddy/public/
cp /app/data/runtime/env.js /app/data/caddy/public/

# Print the content of the config file for debugging
echo "==> Generated config.js content:"
cat /app/data/runtime/config.js

# First check for pre-built Museum binary
if find "$SERVER_DIR" -name "museum" -type f -executable | grep -q .; then
    MUSEUM_BIN=$(find "$SERVER_DIR" -name "museum" -type f -executable | head -1)
    echo "==> Found Museum binary at $MUSEUM_BIN"
    /usr/local/bin/gosu cloudron:cloudron "$MUSEUM_BIN" --port 8080 \
        --storage.s3.endpoint="${S3_ENDPOINT}" \
        --storage.s3.region="${S3_REGION}" \
        --storage.s3.bucket="${S3_BUCKET}" \
        --storage.s3.accessKey="${S3_ACCESS_KEY}" \
        --storage.s3.secretKey="${S3_SECRET_KEY}" \
        --storage.s3.prefix="${S3_PREFIX:-ente/}" \
        --storage.s3.forcePathStyle=true \
        --storage.s3.areLocalBuckets=false \
        --storage.type="s3" \
        --config.path="/app/data/config/museum.yaml" \
        --database.sslmode="disable" > /app/data/logs/museum-server.log 2>&1 &
    SERVER_PID=$!
    echo "==> Museum server started with PID $SERVER_PID"
# Next check for cmd/museum directory pattern
elif [ -d "$SERVER_DIR/cmd/museum" ]; then
    echo "==> Found Museum source in cmd/museum, running with go run"
    cd "$SERVER_DIR"
    
    # Instead of modifying go.mod, set environment variables for compatibility
    echo "==> Setting Go environment variables for compatibility"
    export GOFLAGS="-modfile=/app/data/go/go.mod -mod=mod -modcacherw"
    # Use local toolchain to avoid downloading required version
    export GOTOOLCHAIN=local
    
    # For Wasabi specific settings
    if [[ "${S3_ENDPOINT}" == *"wasabi"* ]]; then
        echo "==> Detected Wasabi S3 endpoint, adjusting settings"
        echo "==> Adding -mod=mod to go run to ignore version mismatch"
        cd "$SERVER_DIR" && \
        /usr/local/bin/gosu cloudron:cloudron env GOCACHE=/app/data/go/cache GOMODCACHE=/app/data/go/pkg/mod PORT=8080 GIN_MODE=release go run -modfile=/app/data/go/go.mod -mod=mod cmd/museum/main.go --port 8080 \
            --storage.s3.endpoint="${S3_ENDPOINT}" \
            --storage.s3.region="${S3_REGION}" \
            --storage.s3.bucket="${S3_BUCKET}" \
            --storage.s3.accessKey="${S3_ACCESS_KEY}" \
            --storage.s3.secretKey="${S3_SECRET_KEY}" \
            --storage.s3.prefix="${S3_PREFIX:-ente/}" \
            --storage.s3.forcePathStyle=true \
            --storage.s3.areLocalBuckets=false \
            --storage.type="s3" \
            --config.path="/app/data/config/museum.yaml" \
            --database.sslmode="disable" \
            --log.level=debug > /app/data/logs/museum-server.log 2>&1 &
    else
        cd "$SERVER_DIR" && \
        /usr/local/bin/gosu cloudron:cloudron env GOCACHE=/app/data/go/cache GOMODCACHE=/app/data/go/pkg/mod PORT=8080 GIN_MODE=release go run -modfile=/app/data/go/go.mod -mod=mod cmd/museum/main.go --port 8080 \
            --storage.s3.endpoint="${S3_ENDPOINT}" \
            --storage.s3.region="${S3_REGION}" \
            --storage.s3.bucket="${S3_BUCKET}" \
            --storage.s3.accessKey="${S3_ACCESS_KEY}" \
            --storage.s3.secretKey="${S3_SECRET_KEY}" \
            --storage.s3.prefix="${S3_PREFIX:-ente/}" \
            --storage.s3.forcePathStyle=true \
            --storage.s3.areLocalBuckets=false \
            --storage.type="s3" \
            --config.path="/app/data/config/museum.yaml" \
            --database.sslmode="disable" \
            --log.level=debug > /app/data/logs/museum-server.log 2>&1 &
    fi
    SERVER_PID=$!
    echo "==> Museum server started with PID $SERVER_PID"
    
    # Wait for the server to start
    echo "==> Waiting for Museum server to start..."
    sleep 5
    
    # Test if API is responding
    MAX_RETRIES=5
    RETRY_COUNT=0
    while [ $RETRY_COUNT -lt $MAX_RETRIES ]; do
        echo "==> Testing API connection (attempt $((RETRY_COUNT+1))/$MAX_RETRIES)"
        if curl -s http://localhost:8080/api/health > /dev/null; then
            echo "==> API is now responding"
            break
        else
            echo "==> API not responding yet, waiting..."
            RETRY_COUNT=$((RETRY_COUNT+1))
            sleep 5
            # Print recent log output
            echo "==> Recent server log output:"
            tail -n 20 /app/data/logs/museum-server.log || echo "==> No logs available yet"
        fi
    done
    
    if [ $RETRY_COUNT -eq $MAX_RETRIES ]; then
        echo "==> WARNING: API server did not respond after multiple attempts"
        echo "==> Checking server logs:"
        ps -p $SERVER_PID >/dev/null || echo "==> ERROR: Server process is not running!"
        tail -n 50 /app/data/logs/museum-server.log || echo "==> No logs available"
    fi

# Next try to find any main.go for the Museum
else
    # Fallback approach - find main.go files
    MAIN_FILES=$(find "$SERVER_DIR" -name "main.go" | grep -v "test" || echo "")
    if [ -n "$MAIN_FILES" ]; then
        MAIN_FILE=$(echo "$MAIN_FILES" | head -1)
        MAIN_DIR=$(dirname "$MAIN_FILE")
        echo "==> Using main.go file at $MAIN_FILE"
        cd "$MAIN_DIR"
        
        # Instead of trying to modify go.mod, set environment variables for compatibility
        echo "==> Setting Go environment variables for compatibility"
        export GOFLAGS="-modfile=/app/data/go/go.mod -mod=mod -modcacherw"
        export GOTOOLCHAIN=local
        
        echo "==> Running main.go with Go"
        cd "$MAIN_DIR" && \
        /usr/local/bin/gosu cloudron:cloudron env GOCACHE=/app/data/go/cache GOMODCACHE=/app/data/go/pkg/mod PORT=8080 GIN_MODE=release go run -modfile=/app/data/go/go.mod -mod=mod main.go --port 8080 \
            --storage.s3.endpoint="${S3_ENDPOINT}" \
            --storage.s3.region="${S3_REGION}" \
            --storage.s3.bucket="${S3_BUCKET}" \
            --storage.s3.accessKey="${S3_ACCESS_KEY}" \
            --storage.s3.secretKey="${S3_SECRET_KEY}" \
            --storage.s3.prefix="${S3_PREFIX:-ente/}" \
            --storage.s3.forcePathStyle=true \
            --storage.s3.areLocalBuckets=false \
            --storage.type="s3" \
            --config.path="/app/data/config/museum.yaml" \
            --database.sslmode="disable" \
            --log.level=debug > /app/data/logs/museum-server.log 2>&1 &
        SERVER_PID=$!
        echo "==> Museum server started with PID $SERVER_PID"
        
        # Check if the server process is actually running after a brief pause
        sleep 2
        if ! ps -p $SERVER_PID > /dev/null; then
            echo "==> WARNING: Server process exited immediately"
            echo "==> Recent server log output:"
            tail -n 50 /app/data/logs/museum-server.log || echo "==> No logs available yet"
            echo "==> Falling back to mock server"
            SERVER_PID=""
        fi
    else
        echo "==> ERROR: Could not find Museum binary or main.go source file"
        echo "==> Available Go files:"
        find "$SERVER_DIR" -name "*.go" | sort
        
        SERVER_PID=""
    fi
fi

# If server didn't start successfully, use mock server
if [ -z "$SERVER_PID" ] || ! ps -p $SERVER_PID > /dev/null; then
    echo "==> Starting mock server as fallback"
    # Last resort - create a temporary Go HTTP server that returns a meaningful error
    mkdir -p /tmp/mock-server
    cat > /tmp/mock-server/main.go <<EOT
package main

import (
    "fmt"
    "log"
    "net/http"
)

func main() {
    // Set up a handler for the root path
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Content-Type", "text/html")
        html := "<html><body><h1>Ente Museum Server Error</h1>"
        html += "<p>The Ente Museum server could not be started due to compatibility issues.</p>"
        html += "<p>Please check the application logs for more information.</p>"
        html += "</body></html>"
        fmt.Fprint(w, html)
    })
    
    // Add a health endpoint
    http.HandleFunc("/api/health", func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Content-Type", "application/json")
        fmt.Fprint(w, `{"status":"error","message":"Running in fallback mode"}`)
    })
    
    // Start the server
    log.Println("Starting mock server on port 8080")
    
    // Start in a goroutine to prevent blocking
    server := &http.Server{Addr: ":8080"}
    go func() {
        if err := server.ListenAndServe(); err != nil {
            log.Fatalf("Server error: %v", err)
        }
    }()
}
EOT
    
    # Make sure we're in the mock-server directory
    cd /tmp/mock-server
    
    go run main.go &
    SERVER_PID=$!
    echo "==> Mock server started with PID $SERVER_PID to show error message"
fi

echo "==> Testing health check endpoint directly"
curl -v http://localhost:3080/healthcheck

echo "==> Ente is now running!"
echo "==> Museum server: PID $SERVER_PID"
echo "==> Caddy: PID $CADDY_PID"

# Function to inject the config.js script tag into index.html files
inject_config_script() {
    echo "==> Attempting to inject config.js script tag into index.html files"
    
    # List of web app directories
    WEB_APPS=("/app/web/photos" "/app/web/accounts" "/app/web/auth" "/app/web/cast")
    
    for app_dir in "${WEB_APPS[@]}"; do
        if [ -f "$app_dir/index.html" ]; then
            echo "==> Processing $app_dir/index.html"
            
            # Try to modify in place without creating a backup
            sed -i 's|</head>|<script>window.ENTE_CONFIG = { API_URL: "'"${CLOUDRON_APP_ORIGIN}"'/api" };</script></head>|' "$app_dir/index.html" || echo "==> Cannot modify $app_dir/index.html - read-only file system"
        else
            echo "==> Skipping $app_dir - index.html not found"
        fi
    done
}

# Try to inject the config script but don't worry if it fails
inject_config_script || echo "==> NOTE: Could not inject configuration directly into HTML files"

# Wait for child processes to exit
wait $SERVER_PID
wait $CADDY_PID