app.py

from flask import Flask, Response, render_template, request
import requests
import os
import logging
import collections
import math
import base64
from datetime import datetime, timezone

app = Flask(__name__)

gunicorn_logger = logging.getLogger('gunicorn.error')
app.logger.handlers = gunicorn_logger.handlers
app.logger.setLevel(gunicorn_logger.level)

# --- GitHub API Config ---
GITHUB_TOKEN = os.environ.get("GITHUB_TOKEN")
GITHUB_API_BASE_URL = "https://api.github.com"

# --- Lobster Keywords ---
REPO_KEYWORDS = ["lobster", "crab", "seafood", "aquarium", "fish"]

# --- Language → skill-icons filename mapping ---
LANG_TO_ICON = {
    "Python":     "Python-Dark",
    "JavaScript": "JavaScript",
    "TypeScript": "TypeScript",
    "HTML":       "HTML",
    "CSS":        "CSS",
    "Java":       "Java-Dark",
    "C++":        "CPP",
    "C#":         "CS",
    "Go":         "Go-Dark",
    "Rust":       "Rust-Dark",
    "Swift":      "Swift",
    "Kotlin":     "Kotlin-Dark",
    "PHP":        "PHP-Dark",
    "Ruby":       "Ruby",
    "Dart":       "Dart-Dark",
    "Shell":      "Bash-Dark",
    "C":          "C",
    "R":          "R-Dark",
    "Lua":        "Lua-Dark",
    "Dockerfile": "Docker",
    "Vue":        "VueJS-Dark",
    "Svelte":     "Svelte",
    "Scala":      "Scala-Dark",
    "Haskell":    "Haskell-Dark",
    "Elixir":     "Elixir-Dark",
    "Perl":       "Perl",
    "HCL":        "Terraform",
    "Nix":        "NixOS-Dark",
}

_ICON_CACHE: dict = {}

def get_skill_icon_b64(lang: str):
    """Fetch skill icon SVG and return as base64 data URI for inline SVG embedding."""
    if lang in _ICON_CACHE:
        return _ICON_CACHE[lang]
    icon_name = LANG_TO_ICON.get(lang)
    if not icon_name:
        _ICON_CACHE[lang] = None
        return None
    try:
        url = f"https://cdn.jsdelivr.net/gh/tandpfun/skill-icons@latest/icons/{icon_name}.svg"
        r = requests.get(url, timeout=3)
        if r.status_code == 200:
            uri = "data:image/svg+xml;base64," + base64.b64encode(r.content).decode()
            _ICON_CACHE[lang] = uri
            return uri
    except Exception as e:
        app.logger.warning(f"Icon fetch failed for {lang}: {e}")
    _ICON_CACHE[lang] = None
    return None


def calculate_hex_chart(sv, dv, iv, vv, lv, av, cx=375, cy=118, R=55):
    """Pre-compute hexagon radar chart SVG data to pass into the Jinja2 template."""
    vals  = [sv, dv, iv, vv, lv, av]
    maxes = [100, 8, 500, 5000, 30, 50]  # VIT max=5000 for influence_score

    def vtx(r, i):
        a = math.radians(i * 60 - 90)
        return cx + r * math.cos(a), cy + r * math.sin(a)

    # Concentric grid hexagons at 25 / 50 / 75 / 100 %
    grid = [
        " ".join(f"{vtx(p*R, i)[0]:.1f},{vtx(p*R, i)[1]:.1f}" for i in range(6))
        for p in (0.25, 0.5, 0.75, 1.0)
    ]
    # Spoke lines center → vertex
    spokes = [{"x": f"{vtx(R, i)[0]:.1f}", "y": f"{vtx(R, i)[1]:.1f}"} for i in range(6)]

    # Stat data polygon
    data_pts = []
    for i, (v, m) in enumerate(zip(vals, maxes)):
        ratio = max(min(v / m, 1.0) if m else 0, 0.05)
        x, y = vtx(ratio * R, i)
        data_pts.append(f"{x:.1f},{y:.1f}")

    # Vertex labels (stat name): STR top, clockwise
    lbl_names = ["STR", "DEX", "INT", "VIT", "LUK", "AGI"]
    labels = [
        {"name": n, "x": f"{vtx(R+14, i)[0]:.1f}", "y": f"{vtx(R+14, i)[1]:.1f}"}
        for i, n in enumerate(lbl_names)
    ]
    return {
        "grid": grid, "spokes": spokes,
        "data": " ".join(data_pts),
        "labels": labels,
        "cx": str(cx), "cy": str(cy),
    }


def get_github_stats(username):
    headers = {"Accept": "application/vnd.github.v3+json"}
    if GITHUB_TOKEN:
        headers["Authorization"] = f"token {GITHUB_TOKEN}"
    else:
        app.logger.warning("GITHUB_TOKEN not set. Rate limits may apply.")

    try:
        u = requests.get(f"{GITHUB_API_BASE_URL}/users/{username}", headers=headers, timeout=5)
        u.raise_for_status()
        ud = u.json()

        repos_count  = ud.get("public_repos", 0)
        followers    = ud.get("followers", 0)
        public_gists = ud.get("public_gists", 0)

        xp    = repos_count * 10 + followers * 5 + public_gists * 2
        level = int(xp ** 0.5) if xp > 0 else 1

        lang_data     = collections.defaultdict(int)
        lobster_count = 0
        total_stars   = 0
        fork_count    = 0
        all_pushed    = []
        repos_list    = []

        try:
            rr = requests.get(
                f"{GITHUB_API_BASE_URL}/users/{username}/repos",
                headers=headers, params={"per_page": 100}, timeout=5
            )
            rr.raise_for_status()
            repos_list = rr.json()
            for repo in repos_list:
                if lang := repo.get("language"):
                    lang_data[lang] += 1
                total_stars += repo.get("stargazers_count", 0)
                if repo.get("fork"):
                    fork_count += 1
                if pushed := repo.get("pushed_at"):
                    all_pushed.append(pushed)
                name = repo.get("name", "").lower()
                desc = (repo.get("description") or "").lower()
                if any(kw in name or kw in desc for kw in REPO_KEYWORDS):
                    lobster_count += 1
        except requests.exceptions.RequestException as e:
            app.logger.warning(f"Repos fetch failed: {e}")

        original_count = repos_count - fork_count

        # --- INFLUENCE_SCORE (replaces fixed VIT=100) ---
        influence_score = int(followers * 10 + total_stars * 0.5)

        # --- ACTIVITY_LEVEL (based on latest repo push) ---
        now_utc = datetime.now(timezone.utc)
        if all_pushed:
            latest_dt  = datetime.fromisoformat(max(all_pushed).replace("Z", "+00:00"))
            days_since = (now_utc - latest_dt).days
        else:
            days_since = 999
        if   days_since <= 30:  activity_label, activity_pct = "ACTIVE",   100
        elif days_since <= 60:  activity_label, activity_pct = "MODERATE",  75
        elif days_since <= 90:  activity_label, activity_pct = "IDLE",      50
        else:                   activity_label, activity_pct = "DORMANT",   25

        # --- CODE_QUALITY_INDEX ---
        if repos_count > 0:
            original_ratio = original_count / repos_count
            total_issues   = sum(r.get("open_issues_count", 0) for r in repos_list)
            issue_density  = total_issues / repos_count
            score = (original_ratio * 40
                     + max(0, 30 - min(issue_density * 3, 30))
                     + activity_pct * 0.3)
            if   score >= 85: code_quality = "S"
            elif score >= 70: code_quality = "A"
            elif score >= 55: code_quality = "B"
            elif score >= 40: code_quality = "C"
            else:             code_quality = "D"
        else:
            code_quality = "D"

        # --- OPEN_SOURCE_AGE ---
        raw_created = ud.get("created_at", "")
        if raw_created:
            created_dt  = datetime.fromisoformat(raw_created.replace("Z", "+00:00"))
            age_days    = (now_utc - created_dt).days
            age_years   = age_days / 365.25
            open_source_age = f"{age_years:.1f}Y" if age_years >= 1 else f"{int(age_days/30)}M"
        else:
            open_source_age = "?"

        # Job class
        ll = {k.lower() for k in lang_data}
        if   "python"     in ll:                   job = "Necromancer"
        elif "javascript" in ll or "typescript" in ll: job = "Shadow Mage"
        elif "java"       in ll:                   job = "Warrior"
        elif "c++"        in ll:                   job = "Berserker"
        elif "rust"       in ll:                   job = "Iron Monk"
        elif "go"         in ll:                   job = "Wind Ranger"
        else:                                      job = "Civilian"

        # Combat stats
        str_v = repos_count
        int_v = followers
        agi_v = level * 2
        vit_v = influence_score  # influence: followers×10 + stars×0.5
        dex_v = len(lang_data)   # language diversity
        luk_v = public_gists     # gists count

        # Skill rank (SSS → D scale)
        def rank(n):
            if n >= 20: return "SSS"
            if n >= 15: return "SS"
            if n >= 10: return "S"
            if n >= 5:  return "A"
            if n >= 3:  return "B"
            if n >= 2:  return "C"
            return "D"

        # Top-3 language skills with icons
        ranked = sorted(lang_data.items(), key=lambda x: x[1], reverse=True)
        skills = [
            {"lang": lang, "rank": rank(cnt), "icon": get_skill_icon_b64(lang)}
            for lang, cnt in ranked[:3]
        ] or [{"lang": "Unknown", "rank": "D", "icon": None}]

        # Lobster level
        if   lobster_count >= 10: lobster_display = "KING 👑"
        elif lobster_count >= 5:  lobster_display = "ELITE 🦞🦞"
        elif lobster_count >= 1:  lobster_display = "SPECIAL 🦐"
        else:                     lobster_display = "Novice"

        return {
            "username": username,
            "level":    level,
            "job":      job,
            "title":    "The Awakened",
            "str":      str_v,
            "int":      int_v,
            "agi":      agi_v,
            "vit":      vit_v,
            "dex":      dex_v,
            "luk":      luk_v,
            "skills":   skills,
            "lobster_display":  lobster_display,
            "activity_label":   activity_label,
            "activity_pct":     activity_pct,
            "code_quality":     code_quality,
            "open_source_age":  open_source_age,
            "original_count":   original_count,
            "fork_count":       fork_count,
            "total_stars":      total_stars,
            "hex": calculate_hex_chart(str_v, dex_v, int_v, vit_v, luk_v, agi_v),
        }

    except requests.exceptions.RequestException as e:
        app.logger.error(f"GitHub API failed: {e}")
    except Exception as e:
        app.logger.error(f"Stats error: {e}")
    return None


def render_stats_svg(stats):
    if not stats:
        stats = {
            "username": "UNKNOWN", "level": 0,
            "job": "Civilian", "title": "The Awakened",
            "str": 0, "int": 0, "agi": 0, "vit": 0, "dex": 0, "luk": 0,
            "skills": [{"lang": "Unknown", "rank": "D", "icon": None}],
            "lobster_display":  "Novice",
            "activity_label":   "DORMANT",
            "activity_pct":     0,
            "code_quality":     "D",
            "open_source_age":  "?",
            "original_count":   0,
            "fork_count":       0,
            "total_stars":      0,
            "hex": calculate_hex_chart(0, 0, 0, 0, 0, 0),
        }
    resp = Response(render_template('card.svg', stats=stats), mimetype='image/svg+xml')
    resp.headers['Cache-Control'] = 'public, max-age=3600'
    return resp


@app.route('/api/card')
def api_card():
    username = request.args.get('username', '').strip()
    return render_stats_svg(get_github_stats(username) if username else None)


if __name__ == '__main__':
    app.run(debug=True, port=5000)