mtav

#!/usr/bin/env bash

# MTAV Stack - Unified development script
# Orchestrates backend API and frontend SPA services

set -e

# Get the directory where this script is located
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

# Change to script directory
cd "$SCRIPT_DIR"

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

# Project configuration
PROJECT_NAME="mtav-stack"
COMPOSE_FILE="docker-compose.yml"

# Helper functions
info() {
    echo -e "${BLUE}ℹ${NC} $1"
}

success() {
    echo -e "${GREEN}✓${NC} $1"
}

error() {
    echo -e "${RED}✗${NC} $1"
}

warning() {
    echo -e "${YELLOW}⚠${NC} $1"
}

# Check if Docker is running
check_docker() {
    if ! docker info > /dev/null 2>&1; then
        error "Docker is not running. Please start Docker and try again."
        exit 1
    fi
}

# Check submodules
check_submodules() {
    if [ ! -f "api/manage.py" ] || [ ! -f "spa/package.json" ]; then
        error "Submodules not initialized. Run: git submodule update --init --recursive"
        exit 1
    fi
}

# Show usage
usage() {
    cat << EOF
${GREEN}MTAV Stack - Multi-Repo Development Tool${NC}

Usage: ./mtav <command> [options]

${YELLOW}Container Management:${NC}
  up              Start all services (first-time setup)
  down            Stop and remove all containers
  stop            Stop containers (keep data)
  start           Start stopped containers
  restart         Restart all containers
  status          Show running containers
  logs [service]  Show logs (optional: specific service)

${YELLOW}Development:${NC}
  shell <service> Open shell (backend/frontend/db/redis)
  backend <cmd>   Run Django management command
  api <cmd>       Alias for backend
  frontend <cmd>  Run npm command in frontend
  spa <cmd>       Alias for frontend

${YELLOW}Database:${NC}
  migrate         Run database migrations
  makemigrations  Create new migrations
  dbshell         Open PostgreSQL shell
  reset-db        Drop and recreate database

${YELLOW}Testing:${NC}
  test            Run all tests (backend + frontend)
  test-backend    Run Django/pytest tests
  test-api        Alias for test-backend
  test-frontend   Run React/Vitest tests
  test-spa        Alias for test-frontend
  coverage        Run tests with coverage

${YELLOW}Maintenance:${NC}
  fresh           Nuclear option: rebuild everything
  rebuild [svc]   Rebuild containers (optional: specific service)
  update          Update dependencies (pip + npm)
  clean           Remove stopped containers and images

${YELLOW}Submodules:${NC}
  submodule-init  Initialize submodules
  submodule-update Update submodules to latest
  submodule-status Show submodule status

${YELLOW}Production:${NC}
  build <tag>     Build production images
  deploy          Deploy to production (placeholder)

${YELLOW}Utilities:${NC}
  superuser       Create Django superuser
  install         Install all dependencies

Examples:
  ./mtav up                      # Start everything
  ./mtav backend migrate         # Run migrations
  ./mtav test                    # Run all tests
  ./mtav shell backend           # Open backend shell
  ./mtav fresh                   # Fresh rebuild

EOF
}

# Main commands
cmd_up() {
    info "Starting MTAV Stack development environment..."
    check_docker
    check_submodules

    # Create .env if it doesn't exist
    if [ ! -f .env ]; then
        info "Creating .env from .env.example..."
        cp .env.example .env
        success ".env file created"
    fi

    # Build and start containers
    docker-compose up -d --build

    # Wait for database to be ready
    info "Waiting for database to be ready..."
    sleep 5

    # Run migrations
    info "Running database migrations..."
    docker-compose exec -T backend python manage.py migrate

    # Install frontend dependencies if needed
    if [ ! -d "spa/node_modules" ]; then
        info "Installing frontend dependencies..."
        docker-compose exec -T frontend npm install
    fi

    success "MTAV Stack is ready!"
    echo ""
    info "Access points:"
    echo "  Frontend SPA: http://localhost:3000"
    echo "  Backend API:  http://localhost:8000/api"
    echo "  API Docs:     http://localhost:8000/api/docs/"
    echo "  Admin Panel:  http://localhost:8000/admin"
    echo "  MailHog:      http://localhost:8025"
    echo ""
    info "Run './mtav logs' to see output"
}

cmd_down() {
    info "Stopping and removing containers..."
    docker-compose down
    success "Containers stopped and removed"
}

cmd_stop() {
    info "Stopping containers..."
    docker-compose stop
    success "Containers stopped"
}

cmd_start() {
    info "Starting containers..."
    docker-compose start
    success "Containers started"
}

cmd_restart() {
    info "Restarting containers..."
    docker-compose restart
    success "Containers restarted"
}

cmd_status() {
    docker-compose ps
}

cmd_logs() {
    if [ -n "$1" ]; then
        docker-compose logs -f "$1"
    else
        docker-compose logs -f
    fi
}

cmd_shell() {
    local service=${1:-backend}

    case "$service" in
        backend|api|django|python)
            docker-compose exec backend bash
            ;;
        frontend|spa|react|node)
            docker-compose exec frontend sh
            ;;
        db|database|postgres)
            docker-compose exec db psql -U mtav -d mtav
            ;;
        redis)
            docker-compose exec redis redis-cli
            ;;
        *)
            error "Unknown service: $service"
            info "Available: backend, frontend, db, redis"
            exit 1
            ;;
    esac
}

cmd_backend() {
    docker-compose exec backend python manage.py "$@"
}

cmd_frontend() {
    docker-compose exec frontend npm "$@"
}

cmd_migrate() {
    info "Running migrations..."
    docker-compose exec backend python manage.py migrate
    success "Migrations complete"
}

cmd_makemigrations() {
    info "Creating migrations..."
    docker-compose exec backend python manage.py makemigrations "$@"
    success "Migrations created"
}

cmd_dbshell() {
    docker-compose exec db psql -U mtav -d mtav
}

cmd_reset_db() {
    warning "This will DELETE ALL DATA. Are you sure? (y/N)"
    read -r response
    if [[ ! "$response" =~ ^[Yy]$ ]]; then
        info "Cancelled"
        exit 0
    fi

    info "Dropping and recreating database..."
    docker-compose exec db psql -U mtav -c "DROP DATABASE IF EXISTS mtav;"
    docker-compose exec db psql -U mtav -c "CREATE DATABASE mtav;"

    info "Running migrations..."
    docker-compose exec backend python manage.py migrate

    success "Database reset complete"
}

cmd_test() {
    info "Running all tests..."

    # Backend tests
    info "Running backend tests..."
    docker-compose exec backend pytest "$@"

    # Frontend tests
    info "Running frontend tests..."
    docker-compose exec frontend npm test -- --run

    success "All tests complete"
}

cmd_test_backend() {
    docker-compose exec backend pytest "$@"
}

cmd_test_frontend() {
    docker-compose exec frontend npm test "$@"
}

cmd_coverage() {
    info "Running tests with coverage..."
    docker-compose exec backend pytest --cov=apps --cov-report=html --cov-report=term
    success "Coverage report generated in api/htmlcov/"
}

cmd_fresh() {
    warning "This will DESTROY ALL DATA and rebuild from scratch. Continue? (y/N)"
    read -r response
    if [[ ! "$response" =~ ^[Yy]$ ]]; then
        info "Cancelled"
        exit 0
    fi

    info "Nuclear option activated! Rebuilding everything..."

    # Stop and remove everything
    docker-compose down -v

    # Remove Python cache
    find api -type d -name "__pycache__" -exec rm -rf {} + 2>/dev/null || true
    find api -type f -name "*.pyc" -delete 2>/dev/null || true

    # Remove node_modules
    rm -rf spa/node_modules 2>/dev/null || true

    # Rebuild and start
    cmd_up

    success "Fresh rebuild complete!"
}

cmd_rebuild() {
    local service="$1"

    if [ -n "$service" ]; then
        info "Rebuilding $service..."
        docker-compose up -d --build "$service"
    else
        info "Rebuilding all services..."
        docker-compose up -d --build
    fi

    success "Rebuild complete"
}

cmd_update() {
    info "Updating dependencies..."

    # Update Python packages
    info "Updating Python packages..."
    docker-compose exec backend pip install --upgrade -r requirements.txt

    # Update Node packages
    info "Updating Node packages..."
    docker-compose exec frontend npm update

    success "Dependencies updated"
}

cmd_clean() {
    info "Cleaning up Docker resources..."
    docker-compose down
    docker system prune -f
    success "Cleanup complete"
}

cmd_submodule_init() {
    info "Initializing submodules..."
    git submodule update --init --recursive
    success "Submodules initialized"
}

cmd_submodule_update() {
    info "Updating submodules to latest..."
    git submodule update --remote --merge
    success "Submodules updated"
}

cmd_submodule_status() {
    git submodule status
}

cmd_build() {
    local tag=${1:-latest}

    info "Building production images with tag: $tag..."

    docker build -t mtav-api:$tag ./api
    docker build -t mtav-spa:$tag ./spa

    success "Production images built"
}

cmd_deploy() {
    error "Deploy command not yet implemented"
    info "This is a placeholder for production deployment"
    exit 1
}

cmd_superuser() {
    docker-compose exec backend python manage.py createsuperuser
}

cmd_install() {
    info "Installing all dependencies..."

    # Backend
    info "Installing backend dependencies..."
    docker-compose exec backend pip install -r requirements.txt

    # Frontend
    info "Installing frontend dependencies..."
    docker-compose exec frontend npm install

    success "All dependencies installed"
}

# Main script
main() {
    local command="$1"
    shift || true

    case "$command" in
        # Container management
        up) cmd_up "$@" ;;
        down) cmd_down "$@" ;;
        stop) cmd_stop "$@" ;;
        start) cmd_start "$@" ;;
        restart) cmd_restart "$@" ;;
        status) cmd_status "$@" ;;
        logs) cmd_logs "$@" ;;

        # Development
        shell) cmd_shell "$@" ;;
        backend|api) cmd_backend "$@" ;;
        frontend|spa) cmd_frontend "$@" ;;

        # Database
        migrate) cmd_migrate "$@" ;;
        makemigrations) cmd_makemigrations "$@" ;;
        dbshell) cmd_dbshell "$@" ;;
        reset-db) cmd_reset_db "$@" ;;

        # Testing
        test) cmd_test "$@" ;;
        test-backend|test-api) cmd_test_backend "$@" ;;
        test-frontend|test-spa) cmd_test_frontend "$@" ;;
        coverage) cmd_coverage "$@" ;;

        # Maintenance
        fresh) cmd_fresh "$@" ;;
        rebuild) cmd_rebuild "$@" ;;
        update) cmd_update "$@" ;;
        clean) cmd_clean "$@" ;;

        # Submodules
        submodule-init) cmd_submodule_init "$@" ;;
        submodule-update) cmd_submodule_update "$@" ;;
        submodule-status) cmd_submodule_status "$@" ;;

        # Production
        build) cmd_build "$@" ;;
        deploy) cmd_deploy "$@" ;;

        # Utilities
        superuser) cmd_superuser "$@" ;;
        install) cmd_install "$@" ;;

        # Help
        help|--help|-h|"") usage ;;

        *)
            error "Unknown command: $command"
            echo ""
            usage
            exit 1
            ;;
    esac
}

main "$@"