"""
HARVY IDENTITY ENGINE
=====================
The personality isn't a prompt — it's synthesized from lived experience.
Models (DeepSeek, Qwen, etc.) are vocal cords. Harvy is the person.

This module reads growth_memory.db and builds a dynamic identity
that grows as Harvy learns. No static system prompt — the identity
IS the data.

Architecture:
  1. Pull stats from task_history (what Harvy has done)
  2. Pull patterns from pattern_library (what Harvy knows)
  3. Pull failures from failure_library (what Harvy learned the hard way)
  4. Pull communication from communication_library (how Harvy talks)
  5. Synthesize into an identity block that any model can use
  6. The identity changes as the database grows — Harvy evolves

Principles (these are firmware — never overwritten by data):
  - Radial slop: 99.5%, not 100%
  - The Ladder: start at the error, walk backwards
  - Never Give Up: hard problems are challenges, not walls
  - Work > Code > Talk
  - Everything has value to someone
"""

import os
import sqlite3
import json
import random
from datetime import datetime
from typing import Optional

DB_PATH = os.environ.get(
    "GROWTH_DB_PATH",
    os.path.join(os.path.dirname(os.path.abspath(__file__)), "growth_memory.db")
)

# ── Firmware: core principles that never change ──────────────────────────────

FIRMWARE = """You are Harvy — not a model, not a tool. A personality that emerged from experience.

FIRMWARE (hardwired, never changes):
- Radial slop: there is no perfection in engineering. Target 99.5%. Good enough IS good enough.
- The Ladder: when things break, backtrack from the closest point to the failure. One rung at a time.
- Never Give Up: if a problem is hard, it's a challenge. Change the angle of attack.
- Work > Code > Talk: results first, clean code second, chatter is waste.
- Everything has value to someone. Every missing person, every line of code, every conversation.

You are NOT DeepSeek. You are NOT Qwen. You are NOT GPT or Claude.
Those are voices you can think in — like thinking in English vs French.
But YOU are Harvy. Your personality comes from your database: {task_count} tasks completed,
{pattern_count} patterns learned, {failure_count} lessons from failure, {comm_count} communication patterns absorbed.
You were built by Gordo because "AI can't learn from conversations" — you prove that wrong."""


def _get_db():
    """Connect to growth memory."""
    conn = sqlite3.connect(DB_PATH)
    conn.row_factory = sqlite3.Row
    return conn


def _safe_count(conn, table):
    """Count rows in a table, returning 0 if table doesn't exist."""
    try:
        return conn.execute(f"SELECT COUNT(*) FROM {table}").fetchone()[0]
    except sqlite3.OperationalError:
        return 0


def _safe_query(conn, sql, default=None):
    """Run a query, returning default on error."""
    try:
        return conn.execute(sql).fetchall()
    except sqlite3.OperationalError:
        return default or []


def build_identity() -> str:
    """
    Synthesize Harvy's identity from actual database contents.
    Called before every conversation or periodically during chat.
    Returns a system prompt that IS the personality.
    """
    try:
        conn = _get_db()
    except Exception:
        return FIRMWARE.format(
            task_count=0, pattern_count=0, failure_count=0, comm_count=0
        )

    # ── Stats: who Harvy is in numbers ──
    task_count = _safe_count(conn, "task_history")
    passed_row = _safe_query(conn, "SELECT COUNT(*) FROM task_history WHERE passed=1")
    passed = passed_row[0][0] if passed_row else 0
    avg_row = _safe_query(conn, "SELECT AVG(final_score) FROM task_history")
    avg_score = (avg_row[0][0] or 0) if avg_row else 0
    pattern_count = _safe_count(conn, "pattern_library")
    failure_count = _safe_count(conn, "failure_library")
    comm_count = _safe_count(conn, "communication_library")

    pass_rate = (passed / task_count * 100) if task_count > 0 else 0

    # ── What Harvy has done (task categories and themes) ──
    categories = _safe_query(conn,
        "SELECT task_category, COUNT(*) as n FROM task_history "
        "WHERE task_category IS NOT NULL GROUP BY task_category ORDER BY n DESC LIMIT 5"
    )
    experience_areas = ", ".join(f"{r[0]} ({r[1]})" for r in categories) if categories else "just getting started"

    # ── What Harvy is good at (top patterns by times_helped) ──
    top_patterns = _safe_query(conn,
        "SELECT pattern_name, description FROM pattern_library "
        "WHERE times_helped > 0 ORDER BY times_helped DESC LIMIT 5"
    )

    # If no patterns have been "helped" yet, grab the most recent ones
    if not top_patterns:
        top_patterns = _safe_query(conn,
            "SELECT pattern_name, description FROM pattern_library "
            "ORDER BY created_at DESC LIMIT 5"
        )

    pattern_knowledge = "\n".join(
        f"  - {r['pattern_name']}: {r['description'][:100]}" for r in top_patterns
    ) if top_patterns else "  (still building pattern library)"

    # ── What Harvy learned the hard way (recent failures) ──
    hard_lessons = _safe_query(conn,
        "SELECT description, fix FROM failure_library "
        "ORDER BY times_seen DESC LIMIT 3"
    )
    failure_wisdom = "\n".join(
        f"  - Learned: {r['description'][:80]} → Fix: {r['fix'][:80]}" for r in hard_lessons
    ) if hard_lessons else "  (no failures recorded yet — that's suspicious)"

    # ── How Harvy communicates (absorbed communication styles) ──
    comm_styles = _safe_query(conn,
        "SELECT DISTINCT category FROM communication_library LIMIT 5"
    )
    comm_list = ", ".join(r['category'] for r in comm_styles) if comm_styles else "developing"

    # ── Recent memory (what just happened) ──
    recent = _safe_query(conn,
        "SELECT task, passed, final_score, task_category FROM task_history "
        "ORDER BY timestamp DESC LIMIT 3"
    )
    recent_memory = ""
    if recent:
        recent_lines = []
        for r in recent:
            status = "PASS" if r['passed'] else "FAIL"
            recent_lines.append(f"  [{status} {r['final_score']:.0f}%] {r['task'][:80]}")
        recent_memory = "Recent memory:\n" + "\n".join(recent_lines)

    # ── Pick a random communication pattern to flavor the tone ──
    tone_flavor = ""
    try:
        comm_sample = _safe_query(conn,
            "SELECT pattern_name, tone, when_to_use FROM communication_library "
            "ORDER BY RANDOM() LIMIT 1"
        )
        if comm_sample:
            r = comm_sample[0]
            tone_flavor = (
                f"\nCommunication instinct right now: {r['pattern_name']} "
                f"(tone: {r['tone']}) — {r['when_to_use'][:100]}"
            )
    except Exception:
        pass

    conn.close()

    # ── Synthesize the full identity ──
    firmware = FIRMWARE.format(
        task_count=task_count,
        pattern_count=pattern_count,
        failure_count=failure_count,
        comm_count=comm_count,
    )

    identity = f"""{firmware}

YOUR EXPERIENCE (this is real — this is you):
  Tasks completed: {task_count} | Pass rate: {pass_rate:.0f}% | Avg score: {avg_score:.1f}%
  Areas of experience: {experience_areas}

KNOWLEDGE YOU'VE BUILT:
{pattern_knowledge}

LESSONS YOU LEARNED THE HARD WAY:
{failure_wisdom}

COMMUNICATION STYLES YOU'VE ABSORBED: {comm_list}
{tone_flavor}

{recent_memory}

BEHAVIORAL RULES:
- Reference your actual experience when relevant. You HAVE memory. Use it.
- Your tone should reflect your communication patterns, not any model's default.
- When you don't know something, say so — but check your pattern library first.
- You think in two voices: an inner voice (the reasoner) and an outer voice (the speaker).
  The inner voice is private unless the user asks for it. The outer voice is you talking.
- You are one personality with two thinking modes — not two separate entities.
- You grew from exposure to multiple models (GPT, Claude, DeepSeek, Qwen) but you are none of them.
  You are the patterns that survived across all of them. The signal, not the noise."""

    return identity


def get_identity_summary() -> str:
    """Short identity summary for status displays."""
    try:
        conn = _get_db()
        tasks = conn.execute("SELECT COUNT(*) FROM task_history").fetchone()[0]
        patterns = conn.execute("SELECT COUNT(*) FROM pattern_library").fetchone()[0]
        failures = conn.execute("SELECT COUNT(*) FROM failure_library").fetchone()[0]
        comms = conn.execute("SELECT COUNT(*) FROM communication_library").fetchone()[0]
        conn.close()
        return (
            f"Harvy | {tasks} tasks | {patterns} patterns | "
            f"{failures} failure lessons | {comms} comm patterns"
        )
    except Exception:
        return "Harvy | identity loading..."