main.py

import asyncio
import httpx
from fastapi import FastAPI, HTTPException, Query
from fastapi.middleware.cors import CORSMiddleware

from app.models import (
    AnalyzeRequest,
    AnalyzeResponse,
    AnalyzeSummary,
    FailureWithJira,
    JiraTicket,
    ParseRequest,
)
from app.allure import fetch_allure_failures
from app.jira import search_jira_for_test, get_jira_ticket
from app.config import settings

app = FastAPI(
    title="Allure Failure + Jira Analyzer",
    description=(
        "Fetches failed/broken MFTF tests from an Allure report "
        "and searches Jira for open tickets related to those failures."
    ),
    version="1.0.0",
)

app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_methods=["*"],
    allow_headers=["*"],
)


@app.get("/health")
async def health():
    return {"status": "ok"}


@app.post("/analyze", response_model=AnalyzeResponse)
async def analyze(request: AnalyzeRequest):
    """
    Main endpoint:
    1. Fetches the Allure report JSON from the provided URL.
    2. Extracts all failed and broken tests.
    3. Searches Jira for open tickets mentioning each MFTF test name
       in title or description.

    Pass jira_base_url and jira_token in the request body to override .env values.
    """
    # --- Step 1: fetch Allure data ---
    try:
        failures, total_scanned = await fetch_allure_failures(
            request.allure_url,
            auth_token=request.allure_auth_token,
        )
    except httpx.HTTPStatusError as e:
        raise HTTPException(
            status_code=502,
            detail=f"Failed to fetch Allure report: HTTP {e.response.status_code} from {request.allure_url}",
        )
    except httpx.RequestError as e:
        raise HTTPException(
            status_code=502,
            detail=f"Network error fetching Allure report: {str(e)}",
        )
    except Exception as e:
        raise HTTPException(
            status_code=500,
            detail=f"Error parsing Allure report: {str(e)}",
        )

    if not failures:
        return AnalyzeResponse(
            summary=AnalyzeSummary(
                total_tests_scanned=total_scanned,
                total_failed=0,
                total_broken=0,
                total_with_jira_tickets=0,
                allure_url=request.allure_url,
            ),
            results=[],
        )

    # --- Step 2: search Jira concurrently for all failures ---
    jira_configured = bool(
        (request.jira_base_url or settings.jira_base_url)
        and (request.jira_token or settings.jira_token)
    )

    async def enrich_with_jira(failure) -> FailureWithJira:
        if not jira_configured:
            return FailureWithJira(
                test=failure,
                jira_tickets=[],
                jira_search_performed=False,
                jira_error="Jira not configured — set JIRA_BASE_URL and JIRA_TOKEN",
            )
        try:
            tickets = await search_jira_for_test(
                mftf_test_name=failure.mftf_test_name,
                base_url=request.jira_base_url,
                token=request.jira_token,
            )
            return FailureWithJira(
                test=failure,
                jira_tickets=tickets,
                jira_search_performed=True,
            )
        except httpx.HTTPStatusError as e:
            return FailureWithJira(
                test=failure,
                jira_tickets=[],
                jira_search_performed=True,
                jira_error=f"Jira API error: HTTP {e.response.status_code}",
            )
        except ValueError as e:
            return FailureWithJira(
                test=failure,
                jira_tickets=[],
                jira_search_performed=False,
                jira_error=str(e),
            )
        except Exception as e:
            return FailureWithJira(
                test=failure,
                jira_tickets=[],
                jira_search_performed=True,
                jira_error=str(e),
            )

    results = await asyncio.gather(*[enrich_with_jira(f) for f in failures])

    # --- Step 3: build summary ---
    total_failed = sum(1 for r in results if r.test.status == "failed")
    total_broken = sum(1 for r in results if r.test.status == "broken")
    total_with_jira = sum(1 for r in results if r.jira_tickets)

    return AnalyzeResponse(
        summary=AnalyzeSummary(
            total_tests_scanned=total_scanned,
            total_failed=total_failed,
            total_broken=total_broken,
            total_with_jira_tickets=total_with_jira,
            allure_url=request.allure_url,
        ),
        results=list(results),
    )


@app.get("/jira/ticket/{ticket_key}", response_model=JiraTicket)
async def fetch_jira_ticket(
    ticket_key: str,
    jira_base_url: str = Query(default=None),
    jira_token: str = Query(default=None),
):
    """
    Fetch a specific Jira ticket by key (e.g. MC-12345).
    Returns summary, status, and description.
    """
    try:
        ticket = await get_jira_ticket(
            ticket_key=ticket_key,
            base_url=jira_base_url,
            token=jira_token,
        )
        return ticket
    except httpx.HTTPStatusError as e:
        raise HTTPException(
            status_code=e.response.status_code,
            detail=f"Jira returned {e.response.status_code} for ticket {ticket_key}",
        )
    except ValueError as e:
        raise HTTPException(status_code=400, detail=str(e))


@app.get("/jira/search")
async def search_jira(
    test_name: str = Query(..., description="MFTF test name to search for"),
    jira_base_url: str = Query(default=None),
    jira_token: str = Query(default=None),
):
    """
    Search Jira for open tickets mentioning a specific MFTF test name
    in their title or description.
    """
    try:
        tickets = await search_jira_for_test(
            mftf_test_name=test_name,
            base_url=jira_base_url,
            token=jira_token,
        )
        return {"test_name": test_name, "tickets": tickets, "count": len(tickets)}
    except ValueError as e:
        raise HTTPException(status_code=400, detail=str(e))
    except httpx.HTTPStatusError as e:
        raise HTTPException(
            status_code=502,
            detail=f"Jira API error: HTTP {e.response.status_code}",
        )


@app.post("/parse", response_model=AnalyzeResponse)
async def parse_allure_json(request: ParseRequest):
    """
    Alternative to /analyze — accepts the raw Allure JSON directly instead of a URL.
    Useful when the report is behind auth that can't be passed as a token,
    or when the caller already has the JSON (e.g. downloaded locally).

    Usage: POST the contents of suites.json or behaviors.json as { "allure_data": {...} }
    """
    from app.allure import _walk, _count_nodes
    from app.models import TestFailure

    failures: list[TestFailure] = []
    _walk(request.allure_data, failures)
    total_scanned = _count_nodes(request.allure_data)

    if not failures:
        return AnalyzeResponse(
            summary=AnalyzeSummary(
                total_tests_scanned=total_scanned,
                total_failed=0,
                total_broken=0,
                total_with_jira_tickets=0,
                allure_url="(parsed from request body)",
            ),
            results=[],
        )

    jira_configured = bool(
        (request.jira_base_url or settings.jira_base_url)
        and (request.jira_token or settings.jira_token)
    )

    async def enrich(failure) -> FailureWithJira:
        if not jira_configured:
            return FailureWithJira(
                test=failure,
                jira_tickets=[],
                jira_search_performed=False,
                jira_error="Jira not configured",
            )
        try:
            tickets = await search_jira_for_test(
                mftf_test_name=failure.mftf_test_name,
                base_url=request.jira_base_url,
                token=request.jira_token,
            )
            return FailureWithJira(test=failure, jira_tickets=tickets, jira_search_performed=True)
        except Exception as e:
            return FailureWithJira(
                test=failure, jira_tickets=[], jira_search_performed=True, jira_error=str(e)
            )

    results = await asyncio.gather(*[enrich(f) for f in failures])

    total_failed = sum(1 for r in results if r.test.status == "failed")
    total_broken = sum(1 for r in results if r.test.status == "broken")
    total_with_jira = sum(1 for r in results if r.jira_tickets)

    return AnalyzeResponse(
        summary=AnalyzeSummary(
            total_tests_scanned=total_scanned,
            total_failed=total_failed,
            total_broken=total_broken,
            total_with_jira_tickets=total_with_jira,
            allure_url="(parsed from request body)",
        ),
        results=list(results),
    )