"""Library Reorganize Job — moves files to match the current file organization template.

Safety design:
- Dry run mode is ON by default. The job only creates findings (reports) showing
  what WOULD move. The user must explicitly disable dry_run in job settings.
- The job is disabled by default (default_enabled=False) so it never runs
  automatically unless the user explicitly enables it.
- Case-insensitive path comparison on Windows prevents false moves.
- Destination collision check prevents overwriting existing files.
- Files without usable tags are skipped, not guessed at.
- Moves are always within the transfer folder; cannot escape to parent dirs.
"""

import os
import re
import shutil
import sys
import time

from core.repair_jobs import register_job
from core.repair_jobs.base import JobContext, JobResult, RepairJob
from utils.logging_config import get_logger

logger = get_logger("repair_job.library_reorganize")

AUDIO_EXTENSIONS = {'.mp3', '.flac', '.ogg', '.opus', '.m4a', '.aac', '.wav', '.wma', '.aiff', '.aif'}
SIDECAR_EXTENSIONS = {'.lrc', '.jpg', '.jpeg', '.png', '.nfo', '.txt', '.cue'}

# Windows and macOS use case-insensitive filesystems by default
_CASE_INSENSITIVE = sys.platform in ('win32', 'darwin')


def _paths_equivalent(path_a: str, path_b: str) -> bool:
    """Compare two paths, case-insensitive on Windows/macOS."""
    a = os.path.normpath(path_a)
    b = os.path.normpath(path_b)
    if _CASE_INSENSITIVE:
        return a.lower() == b.lower()
    return a == b


def _sanitize_filename(filename: str) -> str:
    """Sanitize filename for file system compatibility."""
    sanitized = re.sub(r'[<>:"/\\|?*]', '_', filename)
    sanitized = re.sub(r'\s+', ' ', sanitized).strip()
    sanitized = sanitized.rstrip('. ') or '_'
    if re.match(r'^(CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])(\.|$)', sanitized, re.IGNORECASE):
        sanitized = '_' + sanitized
    return sanitized[:200]


def _sanitize_context_values(context: dict) -> dict:
    """Sanitize all string values for path safety."""
    sanitized = {}
    for key, value in context.items():
        if isinstance(value, str):
            sanitized[key] = _sanitize_filename(value)
        else:
            sanitized[key] = value
    return sanitized


def _apply_path_template(template: str, context: dict) -> str:
    """Apply template variables to build a path string."""
    clean = _sanitize_context_values(context)
    result = template
    result = result.replace('$albumartist', clean.get('albumartist', clean.get('artist', 'Unknown Artist')))
    result = result.replace('$albumtype', clean.get('albumtype', 'Album'))
    result = result.replace('$playlist', clean.get('playlist_name', ''))
    result = result.replace('$artistletter', (clean.get('artist', 'U') or 'U')[0].upper())
    result = result.replace('$artist', clean.get('artist', 'Unknown Artist'))
    result = result.replace('$album', clean.get('album', 'Unknown Album'))
    result = result.replace('$title', clean.get('title', 'Unknown Track'))
    result = result.replace('$track', f"{clean.get('track_number', 1):02d}")
    result = result.replace('$year', str(clean.get('year', '')))
    result = re.sub(r'\s+', ' ', result)
    result = re.sub(r'\s*-\s*-\s*', ' - ', result)
    return result.strip()


def _build_path_from_template(template: str, context: dict) -> tuple:
    """Build (folder_path, filename_base) from a template string and context."""
    full_path = _apply_path_template(template, context)
    quality_value = context.get('quality', '')
    disc_value = f"{context.get('disc_number', 1):02d}"

    path_parts = full_path.split('/')
    if len(path_parts) > 1:
        folder_parts = path_parts[:-1]
        filename_base = path_parts[-1]

        cleaned_folders = []
        for part in folder_parts:
            part = part.replace('$quality', '')
            part = part.replace('$disc', '')
            part = re.sub(r'\s*\[\s*\]', '', part)
            part = re.sub(r'\s*\(\s*\)', '', part)
            part = re.sub(r'\s*\{\s*\}', '', part)
            part = re.sub(r'\s*-\s*$', '', part)
            part = re.sub(r'^\s*-\s*', '', part)
            part = re.sub(r'\s+', ' ', part).strip()
            if part:
                cleaned_folders.append(part)

        filename_base = filename_base.replace('$quality', quality_value)
        filename_base = filename_base.replace('$disc', disc_value)
        filename_base = re.sub(r'\s*\[\s*\]', '', filename_base)
        filename_base = re.sub(r'\s*\(\s*\)', '', filename_base)
        filename_base = re.sub(r'\s*\{\s*\}', '', filename_base)
        filename_base = re.sub(r'\s*-\s*$', '', filename_base)
        filename_base = re.sub(r'\s+', ' ', filename_base).strip()

        sanitized_folders = [_sanitize_filename(p) for p in cleaned_folders]
        folder_path = os.path.join(*sanitized_folders) if sanitized_folders else ''
        return folder_path, _sanitize_filename(filename_base)
    else:
        full_path = full_path.replace('$quality', quality_value)
        full_path = full_path.replace('$disc', disc_value)
        full_path = re.sub(r'\s*\[\s*\]', '', full_path)
        full_path = re.sub(r'\s*\(\s*\)', '', full_path)
        full_path = re.sub(r'\s*\{\s*\}', '', full_path)
        full_path = re.sub(r'\s*-\s*$', '', full_path)
        full_path = re.sub(r'\s+', ' ', full_path).strip()
        return '', _sanitize_filename(full_path)


def _get_audio_quality(file_path: str) -> str:
    """Read audio file and return a quality descriptor string."""
    try:
        ext = os.path.splitext(file_path)[1].lower()
        if ext == '.flac':
            from mutagen.flac import FLAC
            audio = FLAC(file_path)
            bits = audio.info.bits_per_sample
            return f"FLAC {bits}bit"
        elif ext == '.mp3':
            from mutagen.mp3 import MP3, BitrateMode
            audio = MP3(file_path)
            kbps = audio.info.bitrate // 1000
            if audio.info.bitrate_mode == BitrateMode.VBR:
                return "MP3-VBR"
            return f"MP3-{kbps}"
        elif ext in ('.m4a', '.aac', '.mp4'):
            from mutagen.mp4 import MP4
            audio = MP4(file_path)
            kbps = audio.info.bitrate // 1000
            return f"M4A-{kbps}"
        elif ext == '.ogg':
            from mutagen.oggvorbis import OggVorbis
            audio = OggVorbis(file_path)
            kbps = audio.info.bitrate // 1000
            return f"OGG-{kbps}"
        elif ext == '.opus':
            from mutagen.oggopus import OggOpus
            audio = OggOpus(file_path)
            kbps = audio.info.bitrate // 1000
            return f"OPUS-{kbps}"
        return ''
    except Exception:
        return ''


def _read_tag_metadata(file_path: str) -> dict:
    """Read artist, album, title, track_number, disc_number, year from file tags."""
    try:
        from mutagen import File as MutagenFile
        audio = MutagenFile(file_path, easy=True)
        if audio is None:
            return {}

        def first(tag_list):
            if isinstance(tag_list, list) and tag_list:
                return str(tag_list[0])
            if isinstance(tag_list, str):
                return tag_list
            return ''

        meta = {}
        meta['artist'] = first(audio.get('artist', ['']))
        meta['albumartist'] = first(audio.get('albumartist', [''])) or meta['artist']
        meta['album'] = first(audio.get('album', ['']))
        meta['title'] = first(audio.get('title', ['']))

        # Track number: may be "3/12" format
        raw_track = first(audio.get('tracknumber', ['1']))
        try:
            meta['track_number'] = int(raw_track.split('/')[0])
        except (ValueError, IndexError):
            meta['track_number'] = 1

        # Disc number: may be "1/2" format
        raw_disc = first(audio.get('discnumber', ['1']))
        try:
            meta['disc_number'] = int(raw_disc.split('/')[0])
        except (ValueError, IndexError):
            meta['disc_number'] = 1

        # Year
        raw_date = first(audio.get('date', ['']))
        meta['year'] = raw_date[:4] if raw_date and len(raw_date) >= 4 else ''

        return meta
    except Exception as e:
        logger.debug("Failed to read tags from %s: %s", file_path, e)
        return {}


def _remove_empty_dirs(directory: str, root: str):
    """Remove empty directories up to root. Never removes root itself."""
    directory = os.path.normpath(directory)
    root = os.path.normpath(root)
    while directory != root and len(directory) > len(root) and directory.startswith(root):
        try:
            if os.path.isdir(directory) and not os.listdir(directory):
                os.rmdir(directory)
                directory = os.path.dirname(directory)
            else:
                break
        except OSError:
            break


@register_job
class LibraryReorganizeJob(RepairJob):
    job_id = 'library_reorganize'
    display_name = 'Library Reorganize'
    description = 'Moves files to match the current file organization template (dry run by default)'
    help_text = (
        'Scans your transfer folder and reads each audio file\'s tags (artist, album, title, '
        'track number, disc number) to compute the expected file path based on your current '
        'file organization template from Settings.\n\n'
        'Any file whose actual path doesn\'t match the expected template gets flagged. In dry '
        'run mode (default), a finding is created showing the current and expected paths. '
        'Disable dry run to have the job move files automatically.\n\n'
        'Safety features: case-insensitive path comparison on Windows/macOS, collision '
        'detection, path escape prevention, and sidecar file handling (.lrc, .nfo, etc.).\n\n'
        'Settings:\n'
        '- Dry Run: When enabled, only reports what would change without moving files\n'
        '- Move Sidecars: Also move associated files (.lrc, .jpg, .nfo) alongside audio files'
    )
    icon = 'repair-icon-reorganize'
    default_enabled = False
    default_interval_hours = 168  # Weekly — but disabled by default so won't auto-run
    default_settings = {
        'dry_run': True,
        'move_sidecars': True,
    }
    auto_fix = True

    def scan(self, context: JobContext) -> JobResult:
        result = JobResult()
        transfer = context.transfer_folder
        if not os.path.isdir(transfer):
            logger.warning("Transfer folder does not exist: %s", transfer)
            return result

        # Get template config
        cm = context.config_manager
        if not cm:
            logger.error("No config manager available")
            return result

        if not cm.get('file_organization.enabled', True):
            logger.info("File organization is disabled — skipping reorganize")
            if context.report_progress:
                context.report_progress(phase='Skipped — file organization disabled',
                                        log_line='File organization is disabled in settings',
                                        log_type='skip')
            return result

        templates = cm.get('file_organization.templates', {})
        album_template = templates.get('album_path', '$albumartist/$albumartist - $album/$track - $title')
        single_template = templates.get('single_path', '$artist/$artist - $title/$title')
        disc_label = cm.get('file_organization.disc_label', 'Disc')

        dry_run = self._get_setting(context, 'dry_run', True)
        move_sidecars = self._get_setting(context, 'move_sidecars', True)

        if context.report_progress:
            mode_label = 'DRY RUN' if dry_run else 'LIVE'
            context.report_progress(phase=f'Scanning files ({mode_label})...',
                                    log_line=f'Mode: {mode_label} — Scanning {transfer}',
                                    log_type='info')

        # Collect all audio files
        audio_files = []
        for root_dir, _dirs, files in os.walk(transfer):
            if context.check_stop():
                return result
            for fname in files:
                ext = os.path.splitext(fname)[1].lower()
                if ext in AUDIO_EXTENSIONS:
                    audio_files.append(os.path.join(root_dir, fname))

        total = len(audio_files)
        if total == 0:
            logger.info("No audio files found in transfer folder")
            if context.report_progress:
                context.report_progress(phase='No files found', log_line='No audio files in transfer folder',
                                        log_type='info')
            return result

        if context.report_progress:
            context.report_progress(phase=f'Reading tags from {total} files...',
                                    log_line=f'Found {total} audio files',
                                    log_type='info', scanned=0, total=total)

        # Pre-read all tags and group by album for multi-disc detection
        file_tags = {}  # fpath -> tags dict
        album_groups = {}  # (albumartist, album) -> [fpath, ...]
        for fpath in audio_files:
            tags = _read_tag_metadata(fpath)
            file_tags[fpath] = tags
            key = (tags.get('albumartist', '') or tags.get('artist', ''),
                   tags.get('album', ''))
            if key not in album_groups:
                album_groups[key] = []
            album_groups[key].append(fpath)

        # Compute total_discs per album group
        album_total_discs = {}
        for key, fpaths in album_groups.items():
            max_disc = max((file_tags[fp].get('disc_number', 1) for fp in fpaths), default=1)
            album_total_discs[key] = max_disc

        # Track claimed destinations to detect in-batch collisions
        claimed_destinations = set()

        for i, fpath in enumerate(audio_files):
            if context.check_stop():
                return result
            if i % 50 == 0 and context.wait_if_paused():
                return result

            result.scanned += 1
            fname = os.path.basename(fpath)
            file_ext = os.path.splitext(fname)[1]

            tags = file_tags.get(fpath, {})

            # Skip files without minimum usable tags
            title = tags.get('title', '') or ''
            artist = tags.get('artist', '') or ''
            if not title and not artist:
                result.skipped += 1
                if context.report_progress and i % 20 == 0:
                    context.report_progress(scanned=i + 1, total=total,
                                            phase=f'Processing ({i+1}/{total})...')
                continue

            # Use defaults only when tags exist but are empty
            artist = artist or 'Unknown Artist'
            albumartist = tags.get('albumartist', '') or artist
            album = tags.get('album', '') or ''
            title = title or 'Unknown Track'
            track_number = tags.get('track_number', 1) or 1
            disc_number = tags.get('disc_number', 1) or 1
            year = tags.get('year', '')

            # Read quality for $quality template variable
            quality = _get_audio_quality(fpath)

            # Determine template type: album or single
            album_key = (albumartist, album)
            group_size = len(album_groups.get(album_key, []))
            is_album = bool(album) and group_size > 1
            total_discs = album_total_discs.get(album_key, 1)

            template_context = {
                'artist': artist,
                'albumartist': albumartist,
                'album': album or title,
                'title': title,
                'track_number': track_number,
                'disc_number': disc_number,
                'year': year,
                'quality': quality,
                'albumtype': 'Album',
            }

            if is_album:
                template = album_template
                user_controls_disc = '$disc' in template
                folder_path, filename_base = _build_path_from_template(template, template_context)
                if folder_path and filename_base:
                    if total_discs > 1 and not user_controls_disc:
                        disc_folder = f"{disc_label} {disc_number}"
                        expected = os.path.join(transfer, folder_path, disc_folder, filename_base + file_ext)
                    else:
                        expected = os.path.join(transfer, folder_path, filename_base + file_ext)
                else:
                    result.skipped += 1
                    continue
            else:
                template = single_template
                folder_path, filename_base = _build_path_from_template(template, template_context)
                if folder_path and filename_base:
                    expected = os.path.join(transfer, folder_path, filename_base + file_ext)
                else:
                    result.skipped += 1
                    continue

            # Safety: verify destination is still inside transfer folder
            expected_norm = os.path.normpath(expected)
            transfer_norm = os.path.normpath(transfer)
            if not expected_norm.startswith(transfer_norm + os.sep) and expected_norm != transfer_norm:
                logger.warning("Computed path escapes transfer folder, skipping: %s", expected_norm)
                result.skipped += 1
                continue

            actual_norm = os.path.normpath(fpath)

            # Case-insensitive comparison on Windows/macOS
            if _paths_equivalent(actual_norm, expected_norm):
                if context.report_progress and i % 20 == 0:
                    context.report_progress(scanned=i + 1, total=total,
                                            phase=f'Processing ({i+1}/{total})...')
                continue

            # Check for in-batch destination collision
            dest_key = expected_norm.lower() if _CASE_INSENSITIVE else expected_norm
            if dest_key in claimed_destinations:
                result.skipped += 1
                if context.report_progress:
                    context.report_progress(
                        scanned=i + 1, total=total,
                        log_line=f'SKIP (duplicate dest): {os.path.basename(fpath)}',
                        log_type='skip'
                    )
                continue
            claimed_destinations.add(dest_key)

            # File needs to move
            if dry_run:
                rel_actual = os.path.relpath(actual_norm, transfer)
                rel_expected = os.path.relpath(expected_norm, transfer)
                if context.create_finding:
                    context.create_finding(
                        job_id=self.job_id,
                        finding_type='path_mismatch',
                        severity='info',
                        entity_type='file',
                        entity_id=None,
                        file_path=fpath,
                        title=f'Would move: {os.path.basename(fpath)}',
                        description=f'From: {rel_actual}\nTo: {rel_expected}',
                        details={'from': rel_actual, 'to': rel_expected}
                    )
                    result.findings_created += 1
                if context.report_progress:
                    context.report_progress(
                        scanned=i + 1, total=total,
                        phase=f'Dry run ({i+1}/{total})...',
                        log_line=f'[DRY] {os.path.basename(fpath)} -> {os.path.relpath(expected_norm, transfer)}',
                        log_type='info'
                    )
            else:
                # Actually move the file
                try:
                    dest_dir = os.path.dirname(expected_norm)
                    os.makedirs(dest_dir, exist_ok=True)

                    # Collision: skip if destination already exists and is a different file
                    if os.path.exists(expected_norm):
                        # On case-insensitive FS, check if it's the same file (case rename)
                        try:
                            same_file = os.path.samefile(actual_norm, expected_norm)
                        except (OSError, ValueError):
                            same_file = False

                        if not same_file:
                            result.skipped += 1
                            if context.report_progress:
                                context.report_progress(
                                    scanned=i + 1, total=total,
                                    log_line=f'SKIP (exists): {os.path.basename(fpath)}',
                                    log_type='skip'
                                )
                            continue

                        # Same file, different case — use two-step rename to avoid
                        # OS refusing rename to "same" path on case-insensitive FS
                        if _CASE_INSENSITIVE:
                            tmp_path = expected_norm + '.tmp_rename'
                            shutil.move(actual_norm, tmp_path)
                            shutil.move(tmp_path, expected_norm)
                        else:
                            shutil.move(actual_norm, expected_norm)
                    else:
                        shutil.move(actual_norm, expected_norm)

                    result.auto_fixed += 1

                    # Move sidecar files (LRC, cover art, etc.)
                    if move_sidecars:
                        stem = os.path.splitext(os.path.basename(actual_norm))[0]
                        src_dir = os.path.dirname(actual_norm)
                        for sidecar_ext in SIDECAR_EXTENSIONS:
                            sidecar_src = os.path.join(src_dir, stem + sidecar_ext)
                            if os.path.isfile(sidecar_src):
                                new_stem = os.path.splitext(os.path.basename(expected_norm))[0]
                                sidecar_dst = os.path.join(dest_dir, new_stem + sidecar_ext)
                                try:
                                    shutil.move(sidecar_src, sidecar_dst)
                                except Exception as se:
                                    logger.debug("Failed to move sidecar %s: %s", sidecar_src, se)

                    # Update DB file_path if there's a matching track
                    self._update_db_path(context.db, actual_norm, expected_norm)

                    # Clean up empty source directories
                    _remove_empty_dirs(os.path.dirname(actual_norm), transfer)

                    if context.report_progress:
                        context.report_progress(
                            scanned=i + 1, total=total,
                            phase=f'Moving ({i+1}/{total})...',
                            log_line=f'Moved: {os.path.basename(fpath)}',
                            log_type='success'
                        )
                except Exception as e:
                    logger.error("Failed to move %s -> %s: %s", fpath, expected_norm, e)
                    result.errors += 1
                    if context.report_progress:
                        context.report_progress(
                            scanned=i + 1, total=total,
                            log_line=f'ERROR: {os.path.basename(fpath)} -- {e}',
                            log_type='error'
                        )

            if context.update_progress and (i + 1) % 10 == 0:
                context.update_progress(i + 1, total)

        if context.update_progress:
            context.update_progress(total, total)

        mode_text = 'Dry run' if dry_run else 'Reorganize'
        summary = f"{mode_text} complete: {result.scanned} scanned, {result.auto_fixed} moved, {result.findings_created} findings, {result.skipped} skipped, {result.errors} errors"
        logger.info(summary)
        if context.report_progress:
            context.report_progress(
                phase='Complete',
                log_line=summary,
                log_type='success',
                scanned=total, total=total
            )

        return result

    def estimate_scope(self, context: JobContext) -> int:
        transfer = context.transfer_folder
        if not os.path.isdir(transfer):
            return 0
        count = 0
        for _root, _dirs, files in os.walk(transfer):
            for fname in files:
                if os.path.splitext(fname)[1].lower() in AUDIO_EXTENSIONS:
                    count += 1
        return count

    def _get_setting(self, context: JobContext, key: str, default):
        """Read a job-specific setting from config."""
        if context.config_manager:
            return context.config_manager.get(f'repair.jobs.{self.job_id}.settings.{key}', default)
        return default

    def _update_db_path(self, db, old_path: str, new_path: str):
        """Update file_path in the tracks table when a file is moved."""
        conn = None
        try:
            conn = db._get_connection()
            cursor = conn.cursor()
            # Try exact match first
            cursor.execute("UPDATE tracks SET file_path = ? WHERE file_path = ?",
                           (new_path, old_path))
            if cursor.rowcount == 0:
                # Try normalized path match
                cursor.execute("UPDATE tracks SET file_path = ? WHERE file_path = ?",
                               (new_path, os.path.normpath(old_path)))
            conn.commit()
        except Exception as e:
            logger.debug("DB path update failed for %s: %s", old_path, e)
        finally:
            if conn:
                conn.close()