"""
MetaRulesEngine — Vitalis FSI

Rules are not hardcoded. They are HDC vectors.
Rules that correlate with success get reinforced.
Rules that correlate with failure get mutated or dropped.
New rules crystallize from repeated successful action sequences.

This is the system rewriting its own decision logic.
"""
import numpy as np
import os
import json
from vitalis_ide.math_core.kernel import VitalisKernel

class MetaRulesEngine:
    REINFORCEMENT_RATE = 0.1
    MUTATION_RATE = 0.05
    PRUNE_THRESHOLD = 0.2
    MAX_RULES = 50

    def __init__(self):
        self.kernel = VitalisKernel()
        self.path = os.path.expanduser("~/.vitalis_workspace/meta_rules.json")
        self.vec_path = os.path.expanduser("~/.vitalis_workspace/rule_vectors.npy")
        self._load()

    def _load(self):
        self.rules = {}
        self.rule_vectors = {}
        if os.path.exists(self.path):
            with open(self.path) as f:
                self.rules = json.load(f)
        if os.path.exists(self.vec_path):
            self.rule_vectors = np.load(self.vec_path, allow_pickle=True).item()

    def _save(self):
        os.makedirs(os.path.dirname(self.path), exist_ok=True)
        with open(self.path, 'w') as f:
            json.dump(self.rules, f, indent=2)
        np.save(self.vec_path, self.rule_vectors)

    def crystallize(self, action_sequence: list, outcome: str):
        """
        Repeated successful action sequences crystallize into rules.
        The sequence becomes a rule the system applies automatically.
        """
        key = "→".join(action_sequence)
        vec = self.kernel.vectorize_tokens(action_sequence, positional=True)

        if key not in self.rules:
            self.rules[key] = {
                "sequence": action_sequence,
                "outcome": outcome,
                "confidence": 0.5,
                "uses": 0
            }
            self.rule_vectors[key] = vec
            print(f"[META-RULES] Rule crystallized: {key}")
        else:
            r = self.rules[key]
            if outcome == "success":
                r["confidence"] = min(r["confidence"] + self.REINFORCEMENT_RATE, 1.0)
            else:
                r["confidence"] = max(r["confidence"] - self.REINFORCEMENT_RATE, 0.0)
            r["uses"] += 1

        self._save()
        self._prune()

    def _prune(self):
        """Drop rules below confidence threshold."""
        to_drop = [k for k, v in self.rules.items()
                   if v["confidence"] < self.PRUNE_THRESHOLD and v["uses"] > 3]
        for k in to_drop:
            del self.rules[k]
            self.rule_vectors.pop(k, None)
            print(f"[META-RULES] Rule pruned: {k}")
        if to_drop:
            self._save()

    def match(self, context: str) -> dict:
        """Find the highest-confidence rule for this context."""
        ctx_vec = self.kernel.vectorize_tokens(context.split(), positional=False)
        best_match = None
        best_score = 0.0
        for key, vec in self.rule_vectors.items():
            sim = self.kernel.similarity(ctx_vec, vec)
            confidence = self.rules[key]["confidence"]
            score = sim * confidence
            if score > best_score:
                best_score = score
                best_match = self.rules[key]
        return {"rule": best_match, "score": round(best_score, 4)} if best_match else {}

    def report(self) -> dict:
        if not self.rules:
            return {"status": "No rules crystallized yet"}
        top = sorted(self.rules.items(), key=lambda x: x[1]["confidence"], reverse=True)[:5]
        return {
            "total_rules": len(self.rules),
            "top_rules": [{"sequence": v["sequence"],
                           "confidence": round(v["confidence"], 3),
                           "uses": v["uses"]} for _, v in top]
        }