"""
Utility functions for CLI operations.

Provides helpers for file discovery, validation, and batch operations.
"""

import logging
from pathlib import Path
from typing import List

logger = logging.getLogger(__name__)


def discover_audio_files(paths: List[Path], pattern: str = "*.m4a") -> List[Path]:
    """
    Discover audio files from paths (files, directories, or glob patterns).

    Args:
        paths: List of file paths, directory paths, or patterns
        pattern: Default glob pattern for directories (default: *.m4a)

    Returns:
        List of audio file paths
    """
    audio_files = []
    seen = set()  # Avoid duplicates

    for path in paths:
        if path.is_file():
            # Direct file path
            if path.suffix.lower() in [".m4a", ".wav", ".mp3", ".flac"]:
                if str(path) not in seen:
                    audio_files.append(path)
                    seen.add(str(path))
                    logger.debug(f"Added file: {path}")
            else:
                logger.warning(f"Skipping non-audio file: {path}")

        elif path.is_dir():
            # Directory - find all audio files matching pattern
            logger.info(f"Searching directory: {path} with pattern {pattern}")
            found = list(path.glob(pattern))
            for file in found:
                if file.is_file() and str(file) not in seen:
                    audio_files.append(file)
                    seen.add(str(file))
            logger.info(f"Found {len(found)} files in {path}")

        else:
            # Could be a glob pattern
            parent = path.parent if path.parent.exists() else Path(".")
            pattern_str = path.name
            logger.info(f"Searching with glob pattern: {pattern_str} in {parent}")
            found = list(parent.glob(pattern_str))
            for file in found:
                if file.is_file() and str(file) not in seen:
                    audio_files.append(file)
                    seen.add(str(file))
            logger.info(f"Found {len(found)} files matching pattern {pattern_str}")

    # Sort for consistent processing order
    audio_files.sort()

    logger.info(f"Total discovered files: {len(audio_files)}")
    return audio_files


def validate_audio_files(files: List[Path]) -> tuple[List[Path], List[str]]:
    """
    Validate audio files and return valid files and error messages.

    Args:
        files: List of file paths to validate

    Returns:
        Tuple of (valid_files, error_messages)
    """
    valid_files = []
    errors = []

    for file in files:
        if not file.exists():
            errors.append(f"File not found: {file}")
            continue

        if not file.is_file():
            errors.append(f"Not a file: {file}")
            continue

        if file.suffix.lower() not in [".m4a", ".wav", ".mp3", ".flac"]:
            errors.append(f"Unsupported audio format: {file}")
            continue

        if file.stat().st_size == 0:
            errors.append(f"Empty file: {file}")
            continue

        valid_files.append(file)

    return valid_files, errors


def generate_output_filename(
    input_file: Path,
    segment_number: int,
    segment_type: str,
    start_time: float,
    end_time: float,
    output_dir: Path,
) -> Path:
    """
    Generate output filename with collision avoidance.

    Args:
        input_file: Source input file
        segment_number: Segment number
        segment_type: Type of segment (speech, nonverbal)
        start_time: Start time in seconds
        end_time: End time in seconds
        output_dir: Output directory

    Returns:
        Unique output file path
    """
    base_name = input_file.stem
    filename = (
        f"{base_name}_segment_{segment_number:03d}_"
        f"{segment_type}_{start_time:.2f}s-{end_time:.2f}s.m4a"
    )

    output_path = output_dir / filename

    # Handle collisions
    if output_path.exists():
        counter = 1
        while output_path.exists():
            filename = (
                f"{base_name}_segment_{segment_number:03d}_"
                f"{segment_type}_{start_time:.2f}s-{end_time:.2f}s_({counter}).m4a"
            )
            output_path = output_dir / filename
            counter += 1

    return output_path


def format_duration(seconds: float) -> str:
    """
    Format duration in seconds to human-readable string.

    Args:
        seconds: Duration in seconds

    Returns:
        Formatted string (e.g., "1h 23m 45s" or "12m 34s" or "45s")
    """
    if seconds < 60:
        return f"{seconds:.0f}s"

    minutes = int(seconds // 60)
    secs = int(seconds % 60)

    if minutes < 60:
        return f"{minutes}m {secs}s"

    hours = minutes // 60
    minutes = minutes % 60
    return f"{hours}h {minutes}m {secs}s"


def format_file_size(bytes: int) -> str:
    """
    Format file size to human-readable string.

    Args:
        bytes: File size in bytes

    Returns:
        Formatted string (e.g., "1.5 MB")
    """
    if bytes < 1024:
        return f"{bytes} B"

    kb = bytes / 1024
    if kb < 1024:
        return f"{kb:.1f} KB"

    mb = kb / 1024
    if mb < 1024:
        return f"{mb:.1f} MB"

    gb = mb / 1024
    return f"{gb:.2f} GB"