#!/bin/bash

set -eu

# Create necessary directories
mkdir -p /app/data/config /app/data/storage /app/data/nginx/tmp /app/data/go

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
if [[ ! -f /app/data/config/config.yaml ]]; then
    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"
    
    # For initial setup, create a placeholder S3 config to allow user creation
    # This will let the app start and allow initial setup
    if [[ ! -f /app/data/config/s3.env ]]; then
        echo "==> Creating temporary S3 configuration to allow initial setup"
        cat > /app/data/config/s3.env <<EOT
# Temporary S3 configuration - please replace with real values
S3_ENDPOINT=http://localhost:9000
S3_REGION=us-east-1
S3_BUCKET=ente-test
S3_ACCESS_KEY=minioadmin
S3_SECRET_KEY=minioadmin
S3_PREFIX=ente/
EOT
        echo "==> Temporary S3 configuration created to allow initial user creation"
        echo "==> Please replace with real S3 credentials after first user is created"
        
        # Modify config to make S3 optional during initial setup
        sed -i 's/storage.type: "s3"/storage.type: "local"/' /app/data/config/config.yaml
    fi
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/}"

# 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

# Install or verify required packages
echo "==> Checking for required packages"
if ! command -v nginx &> /dev/null; then
    echo "==> Installing NGINX"
    apt-get update && apt-get install -y nginx
fi

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

# Create a custom NGINX configuration in the writable data directory
cat > /app/data/nginx/ente.conf <<EOT
worker_processes 1;
error_log stderr;
daemon off;
pid /app/data/nginx/nginx.pid;

events {
    worker_connections 1024;
}

http {
    include /etc/nginx/mime.types;
    default_type application/octet-stream;
    access_log /dev/stdout combined;
    sendfile on;
    keepalive_timeout 65;
    
    # Define temp file paths
    client_body_temp_path /app/data/nginx/tmp;
    proxy_temp_path /app/data/nginx/tmp;
    fastcgi_temp_path /app/data/nginx/tmp;
    uwsgi_temp_path /app/data/nginx/tmp;
    scgi_temp_path /app/data/nginx/tmp;
    
    server {
        listen 8080;
        
        # Photos app - root path
        location / {
            root /app/web/photos;
            try_files \$uri \$uri/ /index.html;
        }
        
        # Accounts app
        location /accounts/ {
            alias /app/web/accounts/;
            try_files \$uri \$uri/ /accounts/index.html;
        }
        
        # Auth app
        location /auth/ {
            alias /app/web/auth/;
            try_files \$uri \$uri/ /auth/index.html;
        }
        
        # Cast app
        location /cast/ {
            alias /app/web/cast/;
            try_files \$uri \$uri/ /cast/index.html;
        }
        
        # API endpoints - proxy to Museum server
        location /api/ {
            proxy_pass http://localhost:8000;
            proxy_http_version 1.1;
            proxy_set_header Upgrade \$http_upgrade;
            proxy_set_header Connection 'upgrade';
            proxy_set_header Host \$host;
            proxy_cache_bypass \$http_upgrade;
            access_log /dev/stdout;
            error_log /dev/stderr debug;
        }
    }
}
EOT

echo "==> Custom NGINX configuration created at /app/data/nginx/ente.conf"

# 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)"
else
    echo "==> Installing Go"
    apt-get update && apt-get install -y golang
fi

# 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
# Prevent Go from trying to download newer versions
export GOTOOLCHAIN=local
export GOPROXY=direct

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

# Test if API endpoint is reachable
echo "==> Testing API connectivity"
curl -v http://localhost:8000/api/health || echo "API not yet available, this is normal during startup"

# Set up database environment variables
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 CONFIG_PATH="/app/data/config/config.yaml"

# 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 8000 (different from the NGINX port 8080)
echo "==> Starting Museum server"

# Modify environment variables for frontend
echo "==> Setting up environment variables for frontend"
# For web frontend, these aren't changing
export NEXT_PUBLIC_ENTE_ENDPOINT="${CLOUDRON_APP_ORIGIN}"

# 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 8000 \
        --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/}" &
    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"
    /usr/local/bin/gosu cloudron:cloudron go run cmd/museum/main.go --port 8000 \
        --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/}" \
        --log.level=debug &
    SERVER_PID=$!
    echo "==> Museum server started with PID $SERVER_PID"
# 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"
        /usr/local/bin/gosu cloudron:cloudron go run main.go --port 8000 &
        SERVER_PID=$!
        echo "==> Museum server started with PID $SERVER_PID"
    else
        echo "==> ERROR: Could not find Museum binary or main.go source file"
        echo "==> Available Go files:"
        find "$SERVER_DIR" -name "*.go" | sort
        
        # Last resort - create a temporary Go HTTP server that returns a meaningful error
        echo "==> Creating a temporary HTTP server to show the error to users"
        mkdir -p /tmp/mock-server
        cat > /tmp/mock-server/main.go <<EOT
package main

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

func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Content-Type", "text/html")
        fmt.Fprintf(w, "<html><body><h1>Ente Museum Server Error</h1>")
        fmt.Fprintf(w, "<p>The Ente Museum server could not be started because no suitable Go source files were found.</p>")
        fmt.Fprintf(w, "<p>Please check the logs for more information.</p>")
        fmt.Fprintf(w, "</body></html>")
    })
    
    log.Println("Starting mock server on port 8000")
    log.Fatal(http.ListenAndServe(":8000", nil))
}
EOT
        cd /tmp/mock-server
        go run main.go &
        SERVER_PID=$!
        echo "==> Mock server started with PID $SERVER_PID to show error message"
    fi
fi

# Serve the static web apps in the foreground using our custom nginx config
echo "==> Running NGINX in the foreground with custom configuration"
exec nginx -c /app/data/nginx/ente.conf 