from loguru import logger
from sqlalchemy.orm import Session
from datetime import datetime
import json
from typing import Dict, Any, Optional

from database.models import JiraAnalysis
from llm.models import JiraWebhookPayload

def create_analysis_record(db: Session, payload: JiraWebhookPayload) -> JiraAnalysis:
    """Creates a new Jira analysis record in the database."""
    db_analysis = JiraAnalysis(
        issue_key=payload.issueKey,
        project_key=payload.projectKey,
        status="pending",
        issue_summary=payload.summary,
        request_payload=payload.model_dump(),
        created_at=datetime.utcnow(),
        updated_at=datetime.utcnow()
    )
    db.add(db_analysis)
    db.commit()
    db.refresh(db_analysis)
    return db_analysis

def get_analysis_record(db: Session, issue_key: str) -> Optional[JiraAnalysis]:
    """Retrieves the latest analysis record for a given Jira issue key."""
    logger.debug(f"Attempting to retrieve analysis record for issue key: {issue_key}")
    record = db.query(JiraAnalysis).filter(JiraAnalysis.issue_key == issue_key).order_by(JiraAnalysis.created_at.desc()).first()
    if record:
        logger.debug(f"Found analysis record for {issue_key}: {record.id}")
    else:
        logger.debug(f"No analysis record found for {issue_key}")
    return record

def update_analysis_record(
    db: Session,
    record_id: int,
    status: str,
    analysis_result: Optional[Dict[str, Any]] = None,
    error_message: Optional[str] = None,
    raw_response: Optional[Dict[str, Any]] = None
) -> Optional[JiraAnalysis]:
    """Updates an existing Jira analysis record."""
    db_analysis = db.query(JiraAnalysis).filter(JiraAnalysis.id == record_id).first()
    if db_analysis:
        db_analysis.status = status
        db_analysis.updated_at = datetime.utcnow()
        if analysis_result:
            db_analysis.analysis_result = analysis_result
        if error_message:
            db_analysis.error_message = error_message
        if raw_response:
            db_analysis.raw_response = json.dumps(raw_response)
        
        db.commit()
        db.refresh(db_analysis)
    return db_analysis

def get_all_analysis_records(db: Session) -> list[JiraAnalysis]:
    """Retrieves all analysis records from the database."""
    return db.query(JiraAnalysis).all()

def get_analysis_by_id(db: Session, record_id: int) -> Optional[JiraAnalysis]:
    """Retrieves an analysis record by its unique database ID."""
    return db.query(JiraAnalysis).filter(JiraAnalysis.id == record_id).first()

def delete_all_analysis_records(db: Session) -> int:
    """Deletes all analysis records from the database and returns count of deleted records."""
    count = db.query(JiraAnalysis).count()
    db.query(JiraAnalysis).delete()
    db.commit()
    return count
    db.commit()
    db.query(JiraAnalysis).delete()
    db.commit()