import os
import json
import psycopg2
import redis
from datetime import datetime
from qdrant_client import QdrantClient
from qdrant_client.models import Distance, VectorParams

# Memory Store Connector (v1.0)
# Connects to Elestio managed services

class MemoryStores:
    def __init__(self):
        # Configuration logic would normally pull from env
        # Placeholder for local/mock testing if env not set
        self.pg_conn_str = os.getenv("PG_CONN_STR", "dbname=genesis user=postgres")
        self.redis_url = os.getenv("REDIS_URL", "redis://localhost:6379")
        self.qdrant_url = os.getenv("QDRANT_URL", "http://localhost:6333")

        # Lazily connect to avoid crashes if services are starting
        self._pg = None
        self._redis = None
        self._qdrant = None

    @property
    def pg(self):
        if self._pg is None:
            self._pg = psycopg2.connect(self.pg_conn_str)
        return self._pg

    @property
    def redis(self):
        if self._redis is None:
            self._redis = redis.from_url(self.redis_url, decode_responses=True)
        return self._redis

    @property
    def qdrant(self):
        if self._qdrant is None:
            self._qdrant = QdrantClient(url=self.qdrant_url)
        return self._qdrant

    def log_audit(self, event_type, worker_id, validation_report):
        """Log to immutable audit trail (P4)"""
        cursor = self.pg.cursor()
        cursor.execute("""
            INSERT INTO audit_trail 
            (event_type, worker_id, validation_passed, gate1_score, 
             gate2_score, gate3_score, overall_score, validation_report)
            VALUES (%s, %s, %s, %s, %s, %s, %s, %s)
            RETURNING id, timestamp
        """, (
            event_type,
            worker_id,
            validation_report.get('passed'),
            validation_report['gates']['foundation']['score'],
            validation_report['gates']['intelligence']['score'],
            validation_report['gates']['realtime']['score'],
            validation_report.get('overall_score'),
            json.dumps(validation_report)
        ))
        result = cursor.fetchone()
        self.pg.commit()
        return result

    def update_worker_trust(self, worker_id, validation_passed):
        """Update worker trust score (P9 - Adaptive)"""
        cursor = self.pg.cursor()
        cursor.execute("""
            INSERT INTO worker_trust (worker_id, total_validations, passed_validations, trust_score)
            VALUES (%s, 1, %s, %s)
            ON CONFLICT (worker_id) DO UPDATE SET
                total_validations = worker_trust.total_validations + 1,
                passed_validations = worker_trust.passed_validations + %s,
                trust_score = (worker_trust.passed_validations + %s)::FLOAT / 
                             (worker_trust.total_validations + 1),
                last_updated = NOW()
            RETURNING trust_score
        """, (worker_id, 1 if validation_passed else 0, 0.5, 
              1 if validation_passed else 0, 1 if validation_passed else 0))
        trust_score = cursor.fetchone()[0]
        self.pg.commit()
        return trust_score

# Global memory instance
memory = MemoryStores()