"""
Usage Tracking model for API key usage statistics
"""

from datetime import datetime
from typing import Optional
from sqlalchemy import Column, Integer, String, DateTime, Boolean, Text, JSON, ForeignKey, Float
from sqlalchemy.orm import relationship
from app.db.database import Base


class UsageTracking(Base):
    """Usage tracking model for detailed API key usage statistics"""
    
    __tablename__ = "usage_tracking"
    
    id = Column(Integer, primary_key=True, index=True)
    
    # API Key relationship
    api_key_id = Column(Integer, ForeignKey("api_keys.id"), nullable=False)
    api_key = relationship("APIKey", back_populates="usage_tracking")
    
    # User relationship
    user_id = Column(Integer, ForeignKey("users.id"), nullable=False)
    user = relationship("User", back_populates="usage_tracking")
    
    # Budget relationship (optional)
    budget_id = Column(Integer, ForeignKey("budgets.id"), nullable=True)
    budget = relationship("Budget", back_populates="usage_tracking")
    
    # Request information
    endpoint = Column(String, nullable=False)  # API endpoint used
    method = Column(String, nullable=False)  # HTTP method
    model = Column(String, nullable=True)  # Model used (if applicable)
    
    # Usage metrics
    request_tokens = Column(Integer, default=0)  # Input tokens
    response_tokens = Column(Integer, default=0)  # Output tokens
    total_tokens = Column(Integer, default=0)  # Total tokens used
    
    # Cost tracking
    cost_cents = Column(Integer, default=0)  # Cost in cents
    cost_currency = Column(String, default="USD")  # Currency
    
    # Response information
    response_time_ms = Column(Integer, nullable=True)  # Response time in milliseconds
    status_code = Column(Integer, nullable=True)  # HTTP status code
    
    # Request metadata
    request_id = Column(String, nullable=True)  # Unique request identifier
    session_id = Column(String, nullable=True)  # Session identifier
    ip_address = Column(String, nullable=True)  # Client IP address
    user_agent = Column(String, nullable=True)  # User agent
    
    # Additional metadata
    request_metadata = Column(JSON, default=dict)  # Additional request metadata
    
    # Timestamps
    created_at = Column(DateTime, default=datetime.utcnow)
    
    def __repr__(self):
        return f"<UsageTracking(id={self.id}, api_key_id={self.api_key_id}, endpoint='{self.endpoint}')>"
    
    def to_dict(self):
        """Convert usage tracking to dictionary for API responses"""
        return {
            "id": self.id,
            "api_key_id": self.api_key_id,
            "user_id": self.user_id,
            "endpoint": self.endpoint,
            "method": self.method,
            "model": self.model,
            "request_tokens": self.request_tokens,
            "response_tokens": self.response_tokens,
            "total_tokens": self.total_tokens,
            "cost_cents": self.cost_cents,
            "cost_currency": self.cost_currency,
            "response_time_ms": self.response_time_ms,
            "status_code": self.status_code,
            "request_id": self.request_id,
            "session_id": self.session_id,
            "ip_address": self.ip_address,
            "user_agent": self.user_agent,
            "request_metadata": self.request_metadata,
            "created_at": self.created_at.isoformat() if self.created_at else None
        }
    
    @classmethod
    def create_tracking_record(
        cls,
        api_key_id: int,
        user_id: int,
        endpoint: str,
        method: str,
        model: Optional[str] = None,
        request_tokens: int = 0,
        response_tokens: int = 0,
        cost_cents: int = 0,
        response_time_ms: Optional[int] = None,
        status_code: Optional[int] = None,
        request_id: Optional[str] = None,
        session_id: Optional[str] = None,
        ip_address: Optional[str] = None,
        user_agent: Optional[str] = None,
        request_metadata: Optional[dict] = None
    ) -> "UsageTracking":
        """Create a new usage tracking record"""
        return cls(
            api_key_id=api_key_id,
            user_id=user_id,
            endpoint=endpoint,
            method=method,
            model=model,
            request_tokens=request_tokens,
            response_tokens=response_tokens,
            total_tokens=request_tokens + response_tokens,
            cost_cents=cost_cents,
            response_time_ms=response_time_ms,
            status_code=status_code,
            request_id=request_id,
            session_id=session_id,
            ip_address=ip_address,
            user_agent=user_agent,
            request_metadata=request_metadata or {}
        )