#!/bin/bash

# Local Development Server Deployment Script
# Starts AWS, Tailscale, Frontend, and Backend services
#
# Usage:
#   ./scripts/local_dev.sh           # Normal mode
#   DEBUG=1 ./scripts/local_dev.sh   # Debug mode (verbose output)

set -e  # Exit on error

# Enable debug mode if DEBUG env var is set
if [ "${DEBUG}" = "1" ]; then
    set -x  # Print commands as they execute
    echo "Debug mode enabled"
fi

# Color codes for output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

# Paths
SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
PROJECT_ROOT="$(dirname "$SCRIPT_DIR")"
FRONTEND_DIR="$PROJECT_ROOT/ui/app-ui"
BACKEND_DIR="$PROJECT_ROOT/studio_api"
FE_LOG="/tmp/front_end_logs.txt"
BE_LOG="/tmp/back_end_logs.txt"

# PID tracking
FRONTEND_PID=""
BACKEND_PID=""
TAILSCALE_PID=""

# Cleanup function
cleanup() {
    echo -e "\n${YELLOW}========================================${NC}"
    echo -e "${YELLOW}Shutting down services...${NC}"
    echo -e "${YELLOW}========================================${NC}"

    if [ -n "$FRONTEND_PID" ]; then
        echo -e "${BLUE}Stopping frontend (PID: $FRONTEND_PID)${NC}"
        if kill -0 $FRONTEND_PID 2>/dev/null; then
            kill $FRONTEND_PID 2>/dev/null || true
            sleep 1
            if kill -0 $FRONTEND_PID 2>/dev/null; then
                echo -e "${YELLOW}  Force killing frontend...${NC}"
                kill -9 $FRONTEND_PID 2>/dev/null || true
            fi
            pkill -P $FRONTEND_PID 2>/dev/null || true
            echo -e "${GREEN}  ✓ Frontend stopped${NC}"
        else
            echo -e "${YELLOW}  Frontend already stopped${NC}"
        fi
    fi

    if [ -n "$BACKEND_PID" ]; then
        echo -e "${BLUE}Stopping backend (PID: $BACKEND_PID)${NC}"
        if kill -0 $BACKEND_PID 2>/dev/null; then
            kill $BACKEND_PID 2>/dev/null || true
            sleep 1
            if kill -0 $BACKEND_PID 2>/dev/null; then
                echo -e "${YELLOW}  Force killing backend...${NC}"
                kill -9 $BACKEND_PID 2>/dev/null || true
            fi
            pkill -P $BACKEND_PID 2>/dev/null || true
            echo -e "${GREEN}  ✓ Backend stopped${NC}"
        else
            echo -e "${YELLOW}  Backend already stopped${NC}"
        fi
    fi

    if [ -n "$TAILSCALE_PID" ]; then
        echo -e "${BLUE}Stopping tailscale funnel (PID: $TAILSCALE_PID)${NC}"
        if kill -0 $TAILSCALE_PID 2>/dev/null; then
            kill $TAILSCALE_PID 2>/dev/null || true
            echo -e "${GREEN}  ✓ Tailscale funnel stopped${NC}"
        else
            echo -e "${YELLOW}  Tailscale funnel already stopped${NC}"
        fi
    fi

    # Verify ports are freed
    echo -e "\n${BLUE}Verifying ports are freed...${NC}"
    if lsof -ti:3000 >/dev/null 2>&1; then
        echo -e "${YELLOW}  ⚠ Port 3000 still in use (PID: $(lsof -ti:3000))${NC}"
    else
        echo -e "${GREEN}  ✓ Port 3000 freed${NC}"
    fi

    if lsof -ti:8000 >/dev/null 2>&1; then
        echo -e "${YELLOW}  ⚠ Port 8000 still in use (PID: $(lsof -ti:8000))${NC}"
    else
        echo -e "${GREEN}  ✓ Port 8000 freed${NC}"
    fi

    echo -e "\n${GREEN}Cleanup complete${NC}"
    exit 0
}

# Trap Ctrl+C and errors
trap cleanup SIGINT SIGTERM EXIT

echo -e "${BLUE}================================================${NC}"
echo -e "${BLUE}  Starting Local Development Environment${NC}"
echo -e "${BLUE}================================================${NC}\n"

# Step 1: Check AWS SSO authentication
echo -e "${YELLOW}[1/6] Checking AWS SSO authentication...${NC}"
if aws sts get-caller-identity --profile studio-api-dev-envs >/dev/null 2>&1; then
    echo -e "${GREEN}✓ AWS session valid${NC}\n"
else
    echo -e "${YELLOW}⚠ AWS session expired or invalid, logging in...${NC}"
    aws sso login --profile studio-api-dev-envs
    echo -e "${GREEN}✓ AWS authenticated${NC}\n"
fi

# Step 2: Check Tailscale funnel
echo -e "${YELLOW}[2/6] Checking Tailscale funnel...${NC}"

# Find tailscale binary (common locations on macOS)
TAILSCALE_BIN=""
if [ -x "/Applications/Tailscale.app/Contents/MacOS/Tailscale" ]; then
    TAILSCALE_BIN="/Applications/Tailscale.app/Contents/MacOS/Tailscale"
elif command -v tailscale >/dev/null 2>&1; then
    TAILSCALE_BIN="tailscale"
elif [ -x "/usr/local/bin/tailscale" ]; then
    TAILSCALE_BIN="/usr/local/bin/tailscale"
fi

if [ -z "$TAILSCALE_BIN" ]; then
    echo -e "${RED}✗ tailscale not found${NC}"
    echo -e "${YELLOW}Debug: Checked locations:${NC}"
    echo -e "  - /Applications/Tailscale.app/Contents/MacOS/Tailscale"
    echo -e "  - PATH: $PATH"
    echo -e "  - /usr/local/bin/tailscale"
    echo -e "${YELLOW}Try manually: open -a Tailscale${NC}\n"
    exit 1
fi

echo -e "${BLUE}Debug: Found tailscale at: $TAILSCALE_BIN${NC}"

if pgrep -f "tailscale funnel 8000" >/dev/null 2>&1; then
    EXISTING_PID=$(pgrep -f "tailscale funnel 8000")
    echo -e "${GREEN}✓ Tailscale funnel already running (PID: $EXISTING_PID)${NC}\n"
else
    echo -e "${YELLOW}⚠ Starting Tailscale funnel on port 8000...${NC}"

    # Try to start tailscale funnel, capturing output to a temp file
    TAILSCALE_LOG="/tmp/tailscale_funnel_startup.log"
    echo -e "${BLUE}Debug: Starting tailscale funnel (output in $TAILSCALE_LOG)${NC}"
    "$TAILSCALE_BIN" funnel 8000 > "$TAILSCALE_LOG" 2>&1 &
    TAILSCALE_PID=$!
    echo -e "${BLUE}Debug: Spawned PID $TAILSCALE_PID${NC}"

    # Immediately check if it's running
    sleep 0.5
    if ! kill -0 $TAILSCALE_PID 2>/dev/null; then
        echo -e "${RED}✗ Tailscale funnel exited immediately${NC}"
        echo -e "${YELLOW}Output:${NC}"
        cat "$TAILSCALE_LOG"
        echo -e "\n${YELLOW}Possible causes:${NC}"
        echo -e "  1. Funnel already running: $TAILSCALE_BIN status"
        echo -e "  2. Not logged in: $TAILSCALE_BIN status"
        echo -e "  3. Funnel not enabled: $TAILSCALE_BIN funnel status"
        echo -e "  4. Try manually: $TAILSCALE_BIN funnel 8000${NC}\n"
        exit 1
    fi

    # Wait a bit more and check again
    sleep 2
    if kill -0 $TAILSCALE_PID 2>/dev/null; then
        echo -e "${GREEN}✓ Tailscale funnel started (PID: $TAILSCALE_PID)${NC}"
        echo -e "${BLUE}Debug: First few lines of output:${NC}"
        head -3 "$TAILSCALE_LOG" 2>/dev/null || echo "(no output)"
        echo ""
    else
        echo -e "${RED}✗ Tailscale funnel died after starting${NC}"
        echo -e "${YELLOW}Full output:${NC}"
        cat "$TAILSCALE_LOG"
        exit 1
    fi
fi

# Step 3: Frontend dependency check
echo -e "${YELLOW}[3/6] Checking frontend dependencies...${NC}"
cd "$FRONTEND_DIR"
if [ ! -d "node_modules" ] || [ "package.json" -nt "node_modules" ]; then
    echo -e "${YELLOW}⚠ Installing frontend dependencies...${NC}"
    pnpm install
    echo -e "${GREEN}✓ Frontend dependencies installed${NC}\n"
else
    echo -e "${GREEN}✓ Frontend dependencies up to date${NC}\n"
fi

# Step 4: Backend migration check
echo -e "${YELLOW}[4/6] Checking backend migrations...${NC}"
cd "$BACKEND_DIR"
if AWS_PROFILE='studio-api-dev-envs' uv run python manage.py showmigrations --plan 2>/dev/null | grep -q "\[ \]"; then
    echo -e "${YELLOW}⚠ Unapplied migrations found, running migrate...${NC}"
    AWS_PROFILE='studio-api-dev-envs' uv run python manage.py migrate_all
    echo -e "${GREEN}✓ Migrations applied${NC}\n"
else
    echo -e "${GREEN}✓ All migrations up to date${NC}\n"
fi

# Step 5: Start Frontend
echo -e "${YELLOW}[5/6] Starting frontend server...${NC}"

# Check if port 3000 is in use
if lsof -ti:3000 >/dev/null 2>&1; then
    EXISTING_PID=$(lsof -ti:3000)
    echo -e "${RED}✗ Port 3000 is already in use (PID: $EXISTING_PID)${NC}"
    echo -e "${YELLOW}Debug: Kill with: kill $EXISTING_PID${NC}"
    echo -e "${YELLOW}Attempting to kill existing process...${NC}"
    kill $EXISTING_PID 2>/dev/null || true
    sleep 2
    if lsof -ti:3000 >/dev/null 2>&1; then
        echo -e "${RED}✗ Failed to free port 3000, exiting${NC}\n"
        exit 1
    fi
    echo -e "${GREEN}✓ Port 3000 freed${NC}"
fi

cd "$FRONTEND_DIR"
echo -e "${BLUE}Debug: Working directory: $(pwd)${NC}"
> "$FE_LOG"  # Clear log file

echo -e "${BLUE}Debug: Starting pnpm dev...${NC}"
pnpm dev >> "$FE_LOG" 2>&1 &
FRONTEND_PID=$!
echo -e "${GREEN}✓ Frontend process spawned (PID: $FRONTEND_PID)${NC}"

# Wait for frontend to start (check for "ready" in logs or port to open)
echo -e "${YELLOW}Waiting for frontend to be ready...${NC}"
for i in {1..30}; do
    if lsof -ti:3000 >/dev/null 2>&1; then
        echo -e "${GREEN}✓ Frontend server listening on port 3000${NC}"
        break
    fi
    if ! kill -0 $FRONTEND_PID 2>/dev/null; then
        echo -e "${RED}✗ Frontend process died during startup${NC}"
        echo -e "${YELLOW}Last 20 lines of frontend log:${NC}"
        tail -20 "$FE_LOG"
        exit 1
    fi
    sleep 1
done

if ! lsof -ti:3000 >/dev/null 2>&1; then
    echo -e "${YELLOW}⚠ Frontend not ready after 30s, continuing anyway...${NC}"
    echo -e "${YELLOW}Check logs: tail -f $FE_LOG${NC}"
fi

echo -e "  Logs: $FE_LOG\n"

# Step 6: Start Backend
echo -e "${YELLOW}[6/6] Starting backend server...${NC}"

# Check if port 8000 is in use
if lsof -ti:8000 >/dev/null 2>&1; then
    EXISTING_PID=$(lsof -ti:8000)
    EXISTING_CMD=$(ps -p $EXISTING_PID -o command= 2>/dev/null || echo "unknown")
    echo -e "${RED}✗ Port 8000 is already in use (PID: $EXISTING_PID)${NC}"
    echo -e "${YELLOW}Debug: Process: $EXISTING_CMD${NC}"
    echo -e "${YELLOW}Debug: Kill with: kill $EXISTING_PID${NC}"
    echo -e "${YELLOW}Attempting to kill existing process...${NC}"
    kill $EXISTING_PID 2>/dev/null || true
    sleep 2
    if lsof -ti:8000 >/dev/null 2>&1; then
        echo -e "${RED}✗ Failed to free port 8000, exiting${NC}"
        echo -e "${YELLOW}Try manually: kill -9 $EXISTING_PID${NC}\n"
        exit 1
    fi
    echo -e "${GREEN}✓ Port 8000 freed${NC}"
fi

cd "$BACKEND_DIR"
echo -e "${BLUE}Debug: Working directory: $(pwd)${NC}"
echo -e "${BLUE}Debug: AWS_PROFILE=studio-api-dev-envs${NC}"
> "$BE_LOG"  # Clear log file

echo -e "${BLUE}Debug: Starting Django runserver...${NC}"
AWS_PROFILE='studio-api-dev-envs' uv run python manage.py runserver >> "$BE_LOG" 2>&1 &
BACKEND_PID=$!
echo -e "${GREEN}✓ Backend process spawned (PID: $BACKEND_PID)${NC}"

# Wait for backend to start (check for port to open)
echo -e "${YELLOW}Waiting for backend to be ready...${NC}"
for i in {1..30}; do
    if lsof -ti:8000 >/dev/null 2>&1; then
        echo -e "${GREEN}✓ Backend server listening on port 8000${NC}"
        break
    fi
    if ! kill -0 $BACKEND_PID 2>/dev/null; then
        echo -e "${RED}✗ Backend process died during startup${NC}"
        echo -e "${YELLOW}Last 30 lines of backend log:${NC}"
        tail -30 "$BE_LOG"
        exit 1
    fi
    sleep 1
done

if ! lsof -ti:8000 >/dev/null 2>&1; then
    echo -e "${YELLOW}⚠ Backend not ready after 30s, continuing anyway...${NC}"
    echo -e "${YELLOW}Check logs: tail -f $BE_LOG${NC}"
fi

echo -e "  Logs: $BE_LOG\n"

# Show initial logs
echo -e "${BLUE}================================================${NC}"
echo -e "${BLUE}  All Services Running${NC}"
echo -e "${BLUE}================================================${NC}"
echo -e "${GREEN}Frontend:${NC} http://localhost:3000 ${BLUE}(PID: $FRONTEND_PID)${NC}"
echo -e "${GREEN}Backend:${NC}  http://localhost:8000 ${BLUE}(PID: $BACKEND_PID)${NC}"
if [ -n "$TAILSCALE_PID" ]; then
    echo -e "${GREEN}Tailscale:${NC} Port 8000 ${BLUE}(PID: $TAILSCALE_PID)${NC}"
fi
echo -e "\n${GREEN}Logs:${NC}"
echo -e "  ${BLUE}Frontend:${NC} tail -f $FE_LOG"
echo -e "  ${BLUE}Backend:${NC}  tail -f $BE_LOG"
echo -e "\n${GREEN}Debug Commands:${NC}"
echo -e "  ${BLUE}Check ports:${NC} lsof -i :3000 && lsof -i :8000"
echo -e "  ${BLUE}Stop services:${NC} kill $FRONTEND_PID $BACKEND_PID"
echo -e "  ${BLUE}Watch logs:${NC}"
echo -e "    Frontend: tail -f $FE_LOG"
echo -e "    Backend:  tail -f $BE_LOG"
echo -e "\n${GREEN}Troubleshooting:${NC}"
echo -e "  ${BLUE}If frontend not loading:${NC}"
echo -e "    1. Check: lsof -i :3000"
echo -e "    2. Check logs: tail -50 $FE_LOG"
echo -e "    3. Try: cd $FRONTEND_DIR && pnpm dev"
echo -e "  ${BLUE}If backend not loading:${NC}"
echo -e "    1. Check: lsof -i :8000"
echo -e "    2. Check logs: tail -50 $BE_LOG"
echo -e "    3. Check AWS: aws sts get-caller-identity --profile studio-api-dev-envs"
echo -e "\n${YELLOW}Press Ctrl+C to stop all services${NC}\n"

# Show last few lines of each log
echo -e "${BLUE}Recent Frontend Log:${NC}"
tail -5 "$FE_LOG" 2>/dev/null || echo -e "${YELLOW}  (no logs yet)${NC}"
echo -e "\n${BLUE}Recent Backend Log:${NC}"
tail -5 "$BE_LOG" 2>/dev/null || echo -e "${YELLOW}  (no logs yet)${NC}"
echo ""

# Monitor processes
MONITOR_INTERVAL=5
CHECK_COUNT=0
while true; do
    CHECK_COUNT=$((CHECK_COUNT + 1))

    # Check frontend
    if ! kill -0 $FRONTEND_PID 2>/dev/null; then
        echo -e "\n${RED}✗✗✗ FRONTEND PROCESS DIED ✗✗✗${NC}"
        echo -e "${YELLOW}Frontend PID $FRONTEND_PID is no longer running${NC}"
        echo -e "\n${BLUE}Port 3000 status:${NC}"
        lsof -i :3000 || echo -e "${YELLOW}  Port 3000 is not in use${NC}"
        echo -e "\n${BLUE}Last 30 lines of frontend log:${NC}"
        tail -30 "$FE_LOG"
        exit 1
    fi

    # Check backend
    if ! kill -0 $BACKEND_PID 2>/dev/null; then
        echo -e "\n${RED}✗✗✗ BACKEND PROCESS DIED ✗✗✗${NC}"
        echo -e "${YELLOW}Backend PID $BACKEND_PID is no longer running${NC}"
        echo -e "\n${BLUE}Port 8000 status:${NC}"
        lsof -i :8000 || echo -e "${YELLOW}  Port 8000 is not in use${NC}"
        echo -e "\n${BLUE}Last 30 lines of backend log:${NC}"
        tail -30 "$BE_LOG"
        exit 1
    fi

    # Every 30 seconds, show a heartbeat
    if [ $((CHECK_COUNT % 6)) -eq 0 ]; then
        echo -e "${BLUE}[$(date '+%H:%M:%S')] Services running - Frontend PID: $FRONTEND_PID, Backend PID: $BACKEND_PID${NC}"
    fi

    sleep $MONITOR_INTERVAL
done