"""
Shared utility for formatting legacy output to eliminate duplication between services.
"""

from typing import Any


def _transform_phrases_to_object(phrases_array: list) -> dict:
    """Transform phrases array to object format for legacy compatibility."""
    if not phrases_array:
        return {}

    # Convert array of dicts to single object
    result = {}
    for phrase_dict in phrases_array:
        if isinstance(phrase_dict, dict):
            result.update(phrase_dict)
    return result


def _transform_phrase_counter(counter_value) -> str:
    """Transform phrase counter to use 'No Phrases found' for legacy compatibility."""
    if counter_value == 0 or counter_value == "No Phrases" or not counter_value:
        return "No Phrases found"
    return counter_value


def _transform_timestamp_array(timestamp_data: list) -> list:
    """Transform timestamp data to ensure legacy format compliance."""
    if not timestamp_data:
        return []

    # Should already be in correct format from content_analysis
    return timestamp_data


def format_audio_legacy_output(
    audio_result: dict[str, Any],
    transcription_result: dict[str, Any],
    content_result: dict[str, Any],
) -> dict[str, Any]:
    """Format output to match exact legacy JSON structure for audio files."""

    # Legacy output format - exact keys and structure for audio
    trans_obj = transcription_result.get("transcription")
    legacy_output = {
        # Audio analysis
        "audio_length": audio_result.get("audio_length", "0:00"),
        "audio_volume_dBFS": str(audio_result.get("audio_volume_dBFS", "-0.00")),
        "audio_volume": audio_result.get("audio_volume", "Normal"),
        "pause": audio_result.get("pause", 0),
        "pause_timestamp": audio_result.get("pause_timestamp", []),
        # Speech analysis
        "total_words_spoken": transcription_result.get("total_words_spoken", 0),
        "pace_of_speech": transcription_result.get("pace_of_speech", 0.0),
        # Legacy transcript key used by consumers (for audio, this is the main content)
        "video_cc": (
            trans_obj.get("text", "")
            if isinstance(trans_obj, dict)
            else (trans_obj if isinstance(trans_obj, str) else "")
        ),
        # Content analysis
        "filler_word_count": float(content_result.get("filler_word_count", 0.0)),
        "filler_word_timestamp": _transform_timestamp_array(
            content_result.get("filler_word_timestamp", [])
        ),
        "filler_count": content_result.get("filler_count", {}),
        "filler_phrases": content_result.get("filler_phrases", []),
        "filler_phrase_counter": content_result.get("filler_phrase_counter", 0),
        "power_word_count": content_result.get("power_word_count", 0),
        "power_word_timestamp": _transform_timestamp_array(
            content_result.get("power_word_timestamp", [])
        ),
        "power_count": content_result.get("power_count", {}),
        "power_phrases": _transform_phrases_to_object(
            content_result.get("power_phrases", [])
        ),
        "power_phrase_counter": _transform_phrase_counter(
            content_result.get("power_phrase_counter", 0)
        ),
        "negative_word_count": content_result.get("negative_word_count", 0),
        "negative_word_timestamp": content_result.get("negative_word_timestamp", []),
        "negative_count": content_result.get("negative_count", {}),
    }

    return legacy_output


def format_video_legacy_output(
    audio_result: dict[str, Any],
    video_result: dict[str, Any],
    transcription_result: dict[str, Any],
    content_result: dict[str, Any],
) -> dict[str, Any]:
    """Format output to match exact legacy JSON structure for video files."""

    # Legacy output format - exact keys and structure for video
    trans_obj = transcription_result.get("transcription")
    legacy_output = {
        # Video analysis
        # In legacy, video_cc is the full transcript text (result)
        "video_cc": (
            trans_obj.get("text", "")
            if isinstance(trans_obj, dict)
            else (trans_obj if isinstance(trans_obj, str) else "")
        ),
        # Audio analysis (handled by AudioAnalysisService)
        "audio_length": audio_result.get("audio_length", "0:00"),
        "audio_volume_dBFS": str(audio_result.get("audio_volume_dBFS", "-0.00")),
        "audio_volume": audio_result.get("audio_volume", "Normal"),
        "pause": audio_result.get("pause", 0),
        "pause_timestamp": audio_result.get("pause_timestamp", []),
        # Speech analysis (handled by AudioAnalysisService)
        "total_words_spoken": transcription_result.get("total_words_spoken", 0),
        "pace_of_speech": transcription_result.get("pace_of_speech", 0.0),
        # Visual analysis (video-specific)
        "video_light_value": video_result.get("video_light_value", 0),
        "video_light": video_result.get("video_light", "unknown"),
        "total_video_frames": video_result.get("total_video_frames", 0),
        # Eye contact analysis (video-specific)
        "eye_contact_leftside": video_result.get("eye_contact_leftside", 0),
        "eye_contact_rightside": video_result.get("eye_contact_rightside", 0),
        "eye_contact_center": video_result.get("eye_contact_center", 0),
        "total_eye_capture": video_result.get("total_eye_capture", 0),
        "percentage_eye_contact_center": video_result.get(
            "percentage_eye_contact_center", 0
        ),
        "percentage_eye_contact_left": video_result.get(
            "percentage_eye_contact_left", 0
        ),
        "percentage_eye_contact_right": video_result.get(
            "percentage_eye_contact_right", 0
        ),
        "eye_contact_behavior": video_result.get("eye_contact_behavior", "unknown"),
        # Smile analysis (video-specific)
        "smiling_frames": video_result.get("smiling_frames", 0),
        "total_smile_capture": video_result.get("total_smile_capture", 0),
        # Content analysis (handled by AudioAnalysisService)
        "filler_word_count": float(content_result.get("filler_word_count", 0.0)),
        "filler_word_timestamp": _transform_timestamp_array(
            content_result.get("filler_word_timestamp", [])
        ),
        "filler_count": content_result.get("filler_count", {}),
        "filler_phrases": content_result.get("filler_phrases", []),
        "filler_phrase_counter": content_result.get("filler_phrase_counter", 0),
        "power_word_count": content_result.get("power_word_count", 0),
        "power_word_timestamp": _transform_timestamp_array(
            content_result.get("power_word_timestamp", [])
        ),
        "power_count": content_result.get("power_count", {}),
        "power_phrases": _transform_phrases_to_object(
            content_result.get("power_phrases", [])
        ),
        "power_phrase_counter": _transform_phrase_counter(
            content_result.get("power_phrase_counter", 0)
        ),
        "negative_word_count": content_result.get("negative_word_count", 0),
        "negative_word_timestamp": content_result.get("negative_word_timestamp", []),
        "negative_count": content_result.get("negative_count", {}),
    }

    return legacy_output