run

#!/usr/bin/env bash
# DevNote: This script is kinda hard to re-write in a compiled language due to
# the way how a spawned process vs shell script modifies its environment. Using
# other forms of configs like yaml won't have the flexibility a shell script +
# source conf offers. Therefore bash is the best tool for this job of handling
# parent shell environment.

# -----------------------------[ CONFIGURATION ]----------------------------- #

config.clear() {
    # Default: project dir name
    PROJECT_NAME=""
    # Default: automatic detection
    # Available values:
    # none | angular | astal-gtk | django | elixir | fastapi | flask | flutter
    # go | html | nextjs | nodejs | python | python-uv | reactjs | rust
    PROJECT_TYPE=""

    # Services: add any valid systemd services here
    ENABLED_SERVICES=(
        # postgresql
        # docker
        # mongod
        # nginx
    )

    # Default: automatic detection
    # Available values: none | {custom url}
    URL=""
    # Default: xdg-open
    # Available values: {custom command with arguments ending with newtab flag}
    BROWSER=""

    # Settings: [ true | false ]
    AUTORUN_COMMANDS=true
}

# =========================================================================== #

# █░█ ▀█▀ █ █░░ █▀
# █▄█ ░█░ █ █▄▄ ▄█

# log(str:message)
log() {
    local green='\033[1;32m'
    local reset='\033[0m'
    echo -e "[${green}$(date +'%H:%M:%S')${reset}] $1"
}

# code_block(str:message)
code_block() {
    local green='\033[1;32m'
    local bg_gray='\033[48;5;236m'
    local reset='\033[0m'
    local pad="  "
    # Read input (supports \n)
    local content
    content=$(printf "%b" "$1")
    # Split into lines
    IFS=$'\n' read -r -d '' -a lines <<<"$content"$'\0'
    # Calculate max line width
    local max=0
    for line in "${lines[@]}"; do
        ((${#line} > max)) && max=${#line}
    done
    local width=$((max + ${#pad} * 2))
    # Top padding
    echo ""
    printf "${bg_gray}${green}%*s${reset}\n" "$width" ""
    # Content
    for line in "${lines[@]}"; do
        printf "${bg_gray}${green}%s%-*s%s${reset}\n" \
            "$pad" "$max" "$line" "$pad"
    done
    # Bottom padding
    printf "${bg_gray}${green}%*s${reset}\n" "$width" ""
    echo ""
}

# open_browser(str:new_tab_url str:browser_cmd?)
open_browser() {
    # CHECK: Valid URL
    local url="$1"
    if [[ -z "$url" ]]; then
        return
    fi

    # CHECK: Valid browser
    local browser="$2"
    if [[ -z "$browser" ]]; then
        browser="xdg-open"
    else
        command -v "${browser%% *}" >/dev/null || {
            log "❌ Error: ${browser%% *} not found"
            exit 1
        }
    fi

    log "🌐 Launching browser"
    (
        # Wait for the server to start
        local timeout=60
        while ! curl -sf "$url" >/dev/null; do
            sleep 1
            ((timeout--)) || { exit 1; }
        done

        # Launch the browser
        $browser "$url" >/dev/null &
    ) &
}

ensure_window() {
    local name="$1"
    if tmux has-session -t "$PROJECT_NAME" 2>/dev/null; then
        tmux new-window -t "$PROJECT_NAME" -n "$name"
    else
        tmux new-session -d -s "$PROJECT_NAME" -n "$name"
    fi
}

# create_window(window_name:str command?:str)
create_window() {
    local name="$1"
    local cmd="$2"

    # CHECK: Valid Name
    if [[ -z "$name" ]]; then
        log "🚫 Error: Missing window name"
        return
    fi

    # ACTION: Window without command
    if [[ -z "$cmd" ]]; then
        ensure_window "$name"
        return
    fi

    # ACTION: Create window only if valid command
    if command -v "${cmd%% *}" >/dev/null; then
        ensure_window "$name"

        local STRATEGY="clear" # clear | socket

        case "$STRATEGY" in
            clear)
                # "clear" Enter fixes send-keys doubling text due to shell race condition
                # Even though it's a hack, the logic is simple, it works and it's extremely fast
                tmux send-keys -t "$PROJECT_NAME:$name" "clear" Enter "$cmd"
                if [ "$AUTORUN_COMMANDS" == true ]; then
                    tmux send-keys -t "$PROJECT_NAME:$name" Enter
                fi
                ;;
            socket)
                # PHASE 1: Synchronize with shell readiness via wait-for
                local sync_channel="sync_${PROJECT_NAME}_${name}_$$_${RANDOM}"
                tmux wait-for -L "$sync_channel" # Lock
                tmux send-keys -t "$PROJECT_NAME:$name" "tmux wait-for -U $sync_channel" Enter
                tmux wait-for -L "$sync_channel"
                # PHASE 2: Shell is now ready. Send the actual command cleanly.
                tmux send-keys -t "$PROJECT_NAME:$name" "$cmd"
                if [ "$AUTORUN_COMMANDS" == true ]; then
                    tmux send-keys -t "$PROJECT_NAME:$name" Enter
                fi
                # PHASE 3: Unlock
                tmux wait-for -U "$sync_channel" 2>/dev/null || true
                ;;
        esac
    fi
}

# create_temp_window(str:window_name str:command)
create_temp_window() {
    local name="$1"
    local cmd="$2"
    if command -v "${cmd%% *}" >/dev/null; then
        tmux new-window -t "$PROJECT_NAME" -n "$name" "$cmd"
    fi
}

get_python_entrypoint() {
    for entry in "main.py" "app.py" "server.py"; do
        if [[ -f "$entry" ]]; then
            echo "$entry"
            return 0
        fi
    done
    return 1
}

# █▄▄ █▀█ █▀█ █░█░█ █▀ █▀▀ █▀█
# █▄█ █▀▄ █▄█ ▀▄▀▄▀ ▄█ ██▄ █▀▄

get_server_url() {
    local project_type="$1"
    case "$project_type" in
        "none") ;; # Do nothing
        "python") ;;
        "python-uv") ;;
        "fastapi") ;;
        "flask") echo "http://localhost:5000" ;;
        "html")
            if command -v live-server >/dev/null; then
                echo "http://localhost:8080"
            fi
            ;;
        "django") echo "http://localhost:8000" ;;
        "nodejs") ;;
        "reactjs") echo "http://localhost:3000" ;;
        "nextjs") echo "http://localhost:3000" ;;
        "angular") echo "http://localhost:4200" ;;
        "flutter") ;;
        "astal-gtk") ;;
        "elixir") echo "http://localhost:4000" ;;
        "rust") ;;
        "go") ;;
        *) log "🚧 Warning: No server url for ${project_type}" ;;
    esac
}

# █░░ ▄▀█ █▄█ █▀█ █░█ ▀█▀ █▀
# █▄▄ █▀█ ░█░ █▄█ █▄█ ░█░ ▄█

# run_server_command(str:project_type)
run_server_command() {
    local project_type="$1"
    case "$project_type" in
        "none") ;; # Do nothing
        "python") echo "python $(get_python_entrypoint)" ;;
        "python-uv") echo "uv run $(get_python_entrypoint)" ;;
        "fastapi") echo "uvicorn main:app --reload" ;;
        "flask") echo "python $(get_python_entrypoint)" ;;
        "html")
            if command -v live-server >/dev/null; then
                echo "live-server --no-browser"
            fi
            ;;
        "django") echo "python manage.py runserver" ;;
        "nodejs") echo "npm start" ;;
        "reactjs") echo "npm start" ;;
        "nextjs") echo "npm run dev" ;;
        "angular") echo "ng serve" ;;
        "flutter") echo "flutter run" ;;
        "astal-gtk") echo "ags run" ;;
        "elixir") echo "iex -S mix phx.server" ;;
        "rust") echo "cargo run" ;;
        "go") echo "go run ." ;;
        *) log "🚧 Warning: No server setup for ${project_type}" ;;
    esac
}

setup_base_layout() {
    create_window "Cmd" "$(run_server_command "$PROJECT_TYPE")"
    create_window "Editor" "nvim"
}

setup_fastapi_layout() {
    setup_base_layout
    create_window "Test" "clear && pytest"
}

setup_django_layout() {
    setup_base_layout
    create_window "Test" "python manage.py test"
}

setup_rust_layout() {
    setup_base_layout
    create_window "Test" "cargo test"
}

setup_go_layout() {
    setup_base_layout
    create_window "Test" "go test ./..."
}

# select_layout(str:project_type)
setup_layout() {
    local project_type="$1"
    case "$project_type" in
        "none") setup_base_layout ;;
        "python") setup_base_layout ;;
        "python-uv") setup_base_layout ;;
        "django") setup_django_layout ;;
        "fastapi") setup_fastapi_layout ;;
        "flask") setup_base_layout ;;
        "html") setup_base_layout ;;
        "nodejs") setup_base_layout ;;
        "reactjs") setup_base_layout ;;
        "nextjs") setup_base_layout ;;
        "angular") setup_base_layout ;;
        "flutter") setup_base_layout ;;
        "astal-gtk") setup_base_layout ;;
        "elixir") setup_base_layout ;;
        "rust") setup_rust_layout ;;
        "go") setup_go_layout ;;
        *)
            log "🚧 Unknown technology: ${project_type}. Using default layout..."
            setup_base_layout
            ;;
    esac
}

# █▀ █▀▀ █▀█ █░█ █ █▀▀ █▀▀ █▀
# ▄█ ██▄ █▀▄ ▀▄▀ █ █▄▄ ██▄ ▄█

# Already Running Services
# Since you started the service by yourself, script will not touch it
RUNNING_SERVICES=()

project.services.start() {
    set_running_services() {
        RUNNING_SERVICES=() # reset
        for service in "${ENABLED_SERVICES[@]}"; do
            if systemctl is-active --quiet "$service"; then
                RUNNING_SERVICES+=("$service")
                # log "🔧 Service: $service is already running"
            fi
        done
    }
    set_running_services
    for service in "${ENABLED_SERVICES[@]}"; do
        if ! systemctl is-active --quiet "$service"; then
            log "🔧 Service: Starting $service..."
            sudo systemctl start "$service"
        fi
    done
}

project.services.stop() {
    # associative array for O(1) lookup
    local -A running_map
    for svc in "${RUNNING_SERVICES[@]}"; do
        running_map["$svc"]=1
    done
    for service in "${ENABLED_SERVICES[@]}"; do
        if [[ -n "${running_map[$service]}" ]]; then
            # log "🔧 Service: Skipping $service"
            continue
        fi
        if systemctl is-active --quiet "$service"; then
            log "🔧 Service: Stopping $service..."
            sudo systemctl stop "$service"
        else
            log "🤔 Service: $service is not running"
        fi
    done
    sudo -k
}

# █▀▀ █▄░█ █░█   █▀ █▀▀ ▀█▀ █░█ █▀█
# ██▄ █░▀█ ▀▄▀   ▄█ ██▄ ░█░ █▄█ █▀▀

# setup_base_env(str:dependency_dir str:dependency_cmd)
setup_base_env() {
    local dependency_dir="$1"
    local dependency_cmd="$2"
    if [[ ! -d $dependency_dir ]]; then
        log "🚀 Setting up dependencies..."
        command -v "${dependency_cmd%% *}" >/dev/null || {
            log "❌ Error: ${dependency_cmd%% *} not found"
            exit 1
        }
        $dependency_cmd
    fi
}

setup_python_env() {
    local dependency_dir="${1:-venv/}"
    local dependency_cmd="${2:-python -m venv venv}"
    if [[ ! -d $dependency_dir ]]; then
        setup_base_env "$dependency_dir" "$dependency_cmd"
        log "📦 Installing requirements..."
        # shellcheck disable=SC1090
        source "./$dependency_dir/bin/activate"
        if [[ -f "requirements.txt" ]]; then
            pip install -r requirements.txt
        else
            log "🚧 Warning: No requirements.txt found"
        fi
    else
        # shellcheck disable=SC1090
        source "./$dependency_dir/bin/activate"
    fi
}

setup_node_env() {
    setup_base_env "node_modules/" "npm install"
}

setup_elixir_env() {
    setup_base_env "deps/" "mix setup"
}

# select_env(str:project_type)
setup_env() {
    local project_type="$1"
    case "$project_type" in
        "none") ;; # Do nothing
        "python") setup_python_env ;;
        "python-uv") ;; # uv manages its own environment
        "django") setup_python_env ;;
        "fastapi") setup_python_env ;;
        "flask") setup_python_env ;;
        "html") ;;
        "nodejs") setup_node_env ;;
        "reactjs") setup_node_env ;;
        "nextjs") setup_node_env ;;
        "angular") setup_node_env ;;
        "flutter") ;;
        "astal-gtk") setup_node_env ;;
        "elixir") setup_elixir_env ;;
        "rust") ;; # Rust sets up its own environment with cargo
        "go") ;;   # No environment in Go
        *) log "🚧 Unknown technology: ${project_type}" ;;
    esac
}

# █▀▀ █░█ █▀▀ █▀▀ █▄▀ █▀
# █▄▄ █▀█ ██▄ █▄▄ █░█ ▄█

precheck_alembic() {
    # CHECK: alembic is installed
    if ! command -v alembic >/dev/null; then
        log "❌ Error: alembic.ini found but alembic is not installed"
        return
    fi

    # Capture both stdout + stderr
    local alembic_output
    alembic_output="$(alembic check 2>&1)"
    local alembic_status=$?

    if [[ $alembic_status == 0 ]]; then
        # CASE: Revision Created | DB Migrated
        return
    fi

    case "$alembic_output" in
        *"ERROR [alembic.util.messaging] Target database is not up to date."*)
            # CASE: Revision Created | DB Not Migrated
            log "📎 - Migrating DB to latest alembic revision..."
            alembic upgrade head
            ;;
        *) ;;
    esac
}

postcheck_alembic() {
    # CHECK: alembic is installed
    if ! command -v alembic >/dev/null; then
        log "❌ Error: alembic.ini found but alembic is not installed"
        return
    fi

    # Capture both stdout + stderr
    local alembic_output
    alembic_output="$(alembic check 2>&1)"
    local alembic_status=$?

    if [[ $alembic_status == 0 ]]; then
        # CASE: Revision Created | DB Migrated
        return
    fi

    case "$alembic_output" in
        *"ERROR [alembic.util.messaging] New upgrade operations detected"*)
            # CASE: Model Changed | Revision Not Created
            case "$alembic_output" in
                *"INFO  [alembic.autogenerate.compare] Detected added table"*)
                    local table_name=$(grep -oP "Detected added table '\K[^']+" <<<"$alembic_output")
                    log "📎 - New table detected. You probably want:"
                    code_block "alembic revision --autogenerate -m \"add $table_name\"\nalembic upgrade head"
                    ;;
                *)
                    log "📎 - Model changes detected. Consider:"
                    code_block "alembic revision --autogenerate -m \"schema changes\"\nalembic upgrade head"
                    ;;
            esac

            return 1
            ;;
        *"ERROR [alembic.util.messaging] Target database is not up to date."*)
            # CASE: Revision Created | DB Not Migrated
            log "📎 - Looks like you forgot to migrate DB"
            alembic upgrade head
            log "📎 - DB migrated to latest revision"
            ;;
        *)
            # CASE: Unrecognized Error
            log "❌ Alembic failed with an unrecognized error"
            log "$alembic_output"
            return 1
            ;;
    esac
}

precheck_django() {
    # Run migrations if needed
    if python manage.py showmigrations --plan | grep '\[ \]'; then
        log "📎 - Running migrations to database..."
        python manage.py migrate
    fi
}

postcheck_django() {
    local red='\033[1;31m'
    local rst='\033[0m'

    # Capture both stdout + stderr
    local django_output
    django_output="$(python manage.py migrate 2>&1)"

    case "$django_output" in
        *"Your models in app(s):"*"have changes that are not yet reflected in a migration"*)
            # CASE: Model Changed | Revision Not Created
            local app_names=$(grep -oP "Your models in app\(s\): '\K[^']+" <<<"$django_output")
            log "📎 - Model changes detected in: ${red}$app_names${rst}. Consider:"
            code_block "python manage.py makemigrations\npython manage.py migrate"
            ;;
        *)
            # CASE: Revision Created | DB Migrated
            return 0
            ;;
    esac
}

# █▀█ █▀█ █▀▀   █▀▀ █░░ █ █▀▀ █░█ ▀█▀
# █▀▀ █▀▄ ██▄   █▀░ █▄▄ █ █▄█ █▀█ ░█░

preflight_fastapi() {
    if [[ -f "alembic.ini" ]]; then
        log "✈️ Preflight: alembic"
        precheck_alembic
    fi
}

preflight_django() {
    log "✈️ Preflight: django"
    precheck_django
}

# preflight(str:project_type)
check.preflight() {
    local project_type="$1"
    case "$project_type" in
        "none") ;;
        "python") ;;
        "python-uv") ;;
        "django") preflight_django ;;
        "fastapi") preflight_fastapi ;;
        "flask") ;;
        "html") ;;
        "nodejs") ;;
        "react") ;;
        "nextjs") ;;
        "angular") ;;
        "flutter") ;;
        "astal-gtk") ;;
        "elixir") ;;
        "rust") ;;
        "go") ;;
        *) ;;
    esac
}

# █▀█ █▀█ █▀ ▀█▀   █▀▀ █░░ █ █▀▀ █░█ ▀█▀
# █▀▀ █▄█ ▄█ ░█░   █▀░ █▄▄ █ █▄█ █▀█ ░█░

postflight_fastapi() {
    if [[ -f "alembic.ini" ]]; then
        log "✈️ Postflight: alembic"
        postcheck_alembic
    fi
}

postflight_django() {
    log "✈️ Postflight: django"
    postcheck_django
}

# postflight_check(str:project_type)
check.postflight() {
    local project_type="$1"
    case "$project_type" in
        "none") ;;
        "python") ;;
        "python-uv") ;;
        "django") postflight_django ;;
        "fastapi") postflight_fastapi ;;
        "flask") ;;
        "html") ;;
        "nodejs") ;;
        "react") ;;
        "nextjs") ;;
        "angular") ;;
        "flutter") ;;
        "astal-gtk") ;;
        "elixir") ;;
        "rust") ;;
        "go") ;;
        *) ;;
    esac
}

# █▀▄ █▀▀ ▀█▀ █▀▀ █▀▀ ▀█▀ █ █▀█ █▄░█
# █▄▀ ██▄ ░█░ ██▄ █▄▄ ░█░ █ █▄█ █░▀█

detect_project_type() {
    # python
    python_file=$(get_python_entrypoint)
    if [[ -f "$python_file" ]]; then
        if grep -q "from fastapi import FastAPI" $python_file; then
            echo "fastapi" && return
        elif grep -q "from flask import Flask" $python_file; then
            echo "flask" && return
        fi
        if [[ -f "pyproject.toml" ]]; then
            echo "python-uv" && return
        fi
        echo "python" && return
    fi

    # django
    if [[ -f "manage.py" ]]; then
        echo "django" && return
    fi

    # nodejs
    if [[ -f "package.json" ]]; then
        if [[ -f "angular.json" ]]; then
            echo "angular" && return
        elif [[ -f "next.config.js" ]] || [[ -f "next.config.ts" ]] || [[ -f "next.config.mjs" ]]; then
            echo "nextjs" && return
        elif grep -q "react" package.json; then
            echo "reactjs" && return
        elif [[ -d "@girs" ]]; then
            echo "astal-gtk" && return
        fi
        echo "nodejs" && return
    fi

    # flutter
    if [[ -f "pubspec.yaml" ]]; then
        echo "flutter" && return
    fi

    # elixir
    if [[ -f "mix.exs" ]]; then
        echo "elixir" && return
    fi

    # rust
    if [[ -f "Cargo.toml" ]]; then
        echo "rust" && return
    fi

    # go
    if [[ -f "go.mod" ]]; then
        echo "go" && return
    fi

    # html
    if [[ -f "index.html" ]]; then
        echo "html" && return
    fi

    # none
    echo "none" && return
}

# █▀▄▀█ ▄▀█ █ █▄░█
# █░▀░█ █▀█ █ █░▀█

config.load_user_overrides() {
    # INIT: Load global config if available
    config_file="${XDG_CONFIG_HOME:-$HOME/.config}/run/config.conf"
    # shellcheck disable=SC1090
    [[ -f "$config_file" ]] && source "$config_file"

    # INIT: Load custom overrides if available
    OVERRIDE_FILE=".runrc"
    # shellcheck disable=SC1090
    [[ -f "$OVERRIDE_FILE" ]] && source "$OVERRIDE_FILE"
}

config.detect_project_settings() {
    # FALLBACK: PROJECT_NAME={project dir name}
    if [[ -z "$PROJECT_NAME" ]]; then
        PROJECT_NAME="$(basename "$PWD")"
        # SANITIZE: Replace dots with underscores
        PROJECT_NAME="${PROJECT_NAME//./_}"
        # SANITIZE: Remove invalid characters
        PROJECT_NAME="${PROJECT_NAME//[^a-zA-Z0-9 _-]/}"
        # EDGE_CASE: No valid characters at all
        if [[ -z "$PROJECT_NAME" ]]; then
            PROJECT_NAME="invalid_project_name"
        fi
    fi

    # FALLBACK: PROJECT_TYPE={automatic detection}
    if [[ -z "$PROJECT_TYPE" ]]; then
        PROJECT_TYPE="$(detect_project_type)"
        log "🔍 Detected: $PROJECT_TYPE"
    fi

    # FALLBACK: NEW_TAB_URL={automatic detection}
    if [[ -z "$URL" ]]; then
        URL=$(get_server_url "$PROJECT_TYPE")
    fi
}

project.load_environment() {
    # SETUP: ENV or custom
    if declare -f setup_env_custom >/dev/null; then
        setup_env_custom
    else
        setup_env "$PROJECT_TYPE"
    fi
}

setup.code_output() {
    # ACTION: OPEN BROWSER
    if [[ "$URL" != "none" ]]; then
        open_browser "$URL" "$BROWSER"
    fi
}

setup.tmux_layout() {
    # REQUIRE: tmux dependency for LAYOUT
    if ! command -v tmux >/dev/null; then
        # FALLBACK: RUN SERVER (Blocking)
        local cmd=$(run_server_command "$PROJECT_TYPE")
        if [[ -z "$cmd" ]]; then
            log "🚫 Error: No server found for this type"
            exit 1
        fi
        log "ℹ️ Running server without tmux..."
        eval "$cmd"
        exit 0
    fi

    # ACTION: Attach session if exists
    if tmux has-session -t "$PROJECT_NAME" 2>/dev/null; then
        log "Session '$PROJECT_NAME' already exists. Attaching..."
        tmux attach -t "$PROJECT_NAME"
        exit 0
    fi

    # SETUP: LAYOUT or custom
    if declare -f setup_layout_custom >/dev/null; then
        setup_layout_custom
    else
        setup_layout "$PROJECT_TYPE"
    fi

    # ACTION: POST INIT HOOK
    if declare -f setup_post_init_hook >/dev/null; then
        setup_post_init_hook
    fi

    tmux attach -t "$PROJECT_NAME:1"
}

# =========================================================================== #

config.clear
config.load_user_overrides
config.detect_project_settings

project.services.start
project.load_environment

check.preflight "$PROJECT_TYPE"
setup.code_output
setup.tmux_layout
check.postflight "$PROJECT_TYPE"

project.services.stop
log "👋 Goodbye!"