#!/usr/bin/env python3

"""
Bulk rename media files according to tags.
"""

import argparse
import os
import re
import sys
from pathlib import Path
from string import Template
from mutagen import File, FileType, MutagenError


def _parse_tags(filename: Path) -> dict[str, list[str]]:
    try:
        file_info: FileType | None = File(filename, easy=True)
    except (MutagenError, OSError) as e:
        raise RuntimeError(str(e)) from None
    if file_info is None:
        raise RuntimeError("Unknown format")

    return {
        str(k).lower(): list(filter(None, [str(_) for _ in v] if isinstance(v, list) else [str(v)]))
        for k, v in file_info.items()
    }


def _interpolate(tpl: Template, subst: list[tuple[str, str]], tags: dict[str, list[str]]) -> str:
    try:
        name: str = tpl.substitute({k: v[0] for k, v in tags.items() if len(v) >= 1})
        for repl, pat in subst:
            name = re.sub(pat, repl, name)
        return name
    except re.error as e:
        raise RuntimeError(f"Invalid replacement: {str(e)}") from None
    except KeyError as e:
        raise RuntimeError(f"No {str(e)} tag") from None
    except ValueError as e:
        raise RuntimeError(str(e)) from None


def _colorize(colors: bool, color: int, s: str) -> str:
    return "".join((f"\033[0;{color}m", s, "\033[0m")) if colors else s


def _main(colors: bool, dry_run: bool, interactive: bool, no_clobber: bool,
          fmt: str, replace: list[str] | None, files: list[Path]) -> bool:
    err: bool = False
    tpl: Template = Template(fmt)
    sub: list[tuple[str, str]] = [tuple(_.split("/", maxsplit=1)) if "/" in _ else ("", _)
                                  for _ in replace] if replace is not None else []
    for file in files:
        print("".join(("* ", file.parent.as_posix(), "/", _colorize(colors, 33, file.name))))

        try:
            tags: dict[str, list[str]] = _parse_tags(file)
        except RuntimeError as e:
            print("".join(("! Cannot parse tags: ", _colorize(colors, 31, str(e)))))
            err = True
            continue

        try:
            new_file = file.with_stem(_interpolate(tpl, sub, tags))
        except (RuntimeError, ValueError) as e:
            print("".join(("! Cannot interpolate name: ", _colorize(colors, 31, str(e)))))
            err = True
            continue

        if new_file == file:
            print("".join(("> ", new_file.parent.as_posix(), "/", _colorize(colors, 32, new_file.name), " (NO-OP)")))
            continue
        elif no_clobber and new_file.exists():
            print("".join(("! File exists: ", _colorize(colors, 31, new_file.name))))
            err = True
            continue
        elif dry_run:
            print("".join(("> ", new_file.parent.as_posix(), "/", _colorize(colors, 32, new_file.name), " (DRY-RUN)")))
            continue
        else:
            print("".join(("> ", new_file.parent.as_posix(), "/", _colorize(colors, 32, new_file.name))))

        if interactive and not input("? Rename [y/n] ").startswith(("y", "Y")):
            continue

        try:
            file.rename(new_file)
        except OSError as e:
            print("".join(("! Cannot rename: ", _colorize(colors, 31, str(e)))))
            err = True
    return not err


def main() -> int:
    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.ArgumentDefaultsHelpFormatter)
    parser.add_argument("--dry-run", action='store_true', default=False,
                        help="do not actually rename")
    parser.add_argument("--interactive", action='store_true', default=False,
                        help="ask for confirmation")
    parser.add_argument("--no-clobber", action='store_true', default=False,
                        help="do not overwrite existing files")
    parser.add_argument("--fmt", type=str, metavar="TEMPLATE", default="${artist} - ${title}",
                        help="tag-based template for renaming")
    parser.add_argument("--replace", type=str, metavar="[REPL/]REGEX", nargs="*",
                        help="post-processing substitutions, for example: '_/[/|]' or ' *\\([^)]*\\)$'")
    parser.add_argument("files", metavar="FILE", type=Path, nargs="+",
                        help="input media files")
    args = parser.parse_args()
    colors: bool = not os.getenv("NO_COLOR", "") and os.isatty(sys.stdout.fileno())

    try:
        return 0 if _main(colors=colors, **vars(args)) else 1
    except KeyboardInterrupt:
        return 130


if __name__ == "__main__":
    sys.exit(main())