#!/usr/bin/python
"""ComicTagger CLI functions"""
#
# Copyright 2013 ComicTagger Authors
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from __future__ import annotations

import dataclasses
import functools
import json
import logging
import os
import pathlib
import re
import sys
from collections.abc import Collection
from typing import Any, TextIO

from comicapi import merge, utils
from comicapi.comicarchive import ComicArchive, tags
from comicapi.genericmetadata import GenericMetadata
from comictaggerlib.cbltransformer import CBLTransformer
from comictaggerlib.ctsettings import ct_ns
from comictaggerlib.filerenamer import FileRenamer, get_rename_dir
from comictaggerlib.graphics import graphics_path
from comictaggerlib.issueidentifier import IssueIdentifier
from comictaggerlib.md import prepare_metadata
from comictaggerlib.quick_tag import QuickTag
from comictaggerlib.resulttypes import Action, IssueResult, MatchStatus, OnlineMatchResults, Result, Status
from comictalker.comictalker import ComicTalker, TalkerError

logger = logging.getLogger(__name__)


class OutputEncoder(json.JSONEncoder):
    def default(self, obj: Any) -> Any:
        if isinstance(obj, pathlib.Path):
            return str(obj)
        if not isinstance(obj, str) and isinstance(obj, Collection):
            return list(obj)

        # Let the base class default method raise the TypeError
        return json.JSONEncoder.default(self, obj)


class CLI:
    def __init__(self, config: ct_ns, talkers: dict[str, ComicTalker]) -> None:
        self.config = config
        self.talkers = talkers
        self.batch_mode = False
        self.output_file = sys.stdout
        if config.Runtime_Options__json:
            self.output_file = sys.stderr

    def current_talker(self) -> ComicTalker:
        if self.config.Sources__source in self.talkers:
            return self.talkers[self.config.Sources__source]
        logger.error("Could not find the '%s' talker", self.config.Sources__source)
        raise SystemExit(2)

    def output(
        self,
        *args: Any,
        file: TextIO | None = None,
        force_output: bool = False,
        already_logged: bool = False,
        **kwargs: Any,
    ) -> None:
        if file is None:
            file = self.output_file
        if not args:
            log_args: tuple[Any, ...] = ("",)
        elif isinstance(args[0], str):
            log_args = (args[0].strip("\n"), *args[1:])
        else:
            log_args = args
        if not already_logged:
            logger.info(*log_args, **kwargs)
        if self.config.Runtime_Options__verbose > 0:
            return
        if not self.config.Runtime_Options__quiet or force_output:
            print(*args, **kwargs, file=file)

    def run(self) -> int:
        if len(self.config.Runtime_Options__files) < 1:
            if self.config.Commands__command == Action.print:
                res = self.print(None)
                if res.status != Status.success:
                    return_code = 3
                if self.config.Runtime_Options__json:
                    print(json.dumps(dataclasses.asdict(res), cls=OutputEncoder, indent=2))
                return 0
            logger.error("You must specify at least one filename.  Use the -h option for more info")
            return 1
        return_code = 0

        results: list[Result] = []
        match_results = OnlineMatchResults()
        self.batch_mode = len(self.config.Runtime_Options__files) > 1

        for f in self.config.Runtime_Options__files:
            res, match_results = self.process_file_cli(self.config.Commands__command, f, match_results)
            results.append(res)
            if results[-1].status != Status.success:
                return_code = 3
            if self.config.Runtime_Options__json:
                print(json.dumps(dataclasses.asdict(results[-1]), cls=OutputEncoder, indent=2))
            sys.stdout.flush()
            sys.stderr.flush()

        self.post_process_matches(match_results)

        if self.config.Auto_Tag__online:
            self.output(
                f"\nFiles tagged with metadata provided by {self.current_talker().name} {self.current_talker().website}",
            )
        return return_code

    def fetch_metadata(self, issue_id: str) -> GenericMetadata:
        # now get the particular issue data
        try:
            ct_md = self.current_talker().fetch_comic_data(issue_id)
        except TalkerError as e:
            logger.exception(f"Error retrieving issue details. Save aborted.\n{e}")
            return GenericMetadata()

        if self.config.Metadata_Options__apply_transform_on_import:
            ct_md = CBLTransformer(ct_md, self.config).apply()

        return ct_md

    def write_tags(self, ca: ComicArchive, md: GenericMetadata) -> bool:
        if not self.config.Runtime_Options__dryrun:
            for tag_id in self.config.Runtime_Options__tags_write:
                # write out the new data
                if not ca.write_tags(md, tag_id):
                    logger.error("The tag save seemed to fail for: %s!", tags[tag_id].name())
                    return False

            self.output("Save complete.")
        else:
            if self.config.Runtime_Options__quiet:
                self.output("dry-run option was set, so nothing was written")
            else:
                self.output("dry-run option was set, so nothing was written, but here is the final set of tags:")
                self.output(f"{md}")
        return True

    def display_match_set_for_choice(self, label: str, match_set: Result) -> None:
        self.output(f"{match_set.original_path} -- {label}:", force_output=True)

        # sort match list by year
        match_set.online_results.sort(key=lambda k: k.year or 0)

        for counter, m in enumerate(match_set.online_results, 1):
            self.output(
                "    {}. {} #{} [{}] ({}/{}) - {}".format(
                    counter,
                    m.series,
                    m.issue_number,
                    m.publisher,
                    m.month,
                    m.year,
                    m.issue_title,
                ),
                force_output=True,
            )
        if self.config.Runtime_Options__interactive:
            while True:
                i = input("Choose a match #, or 's' to skip: ")
                if (i.isdigit() and int(i) in range(1, len(match_set.online_results) + 1)) or i == "s":
                    break
            if i != "s":
                # save the data!
                # we know at this point, that the file is all good to go
                ca = ComicArchive(match_set.original_path)
                md, match_set.tags_read = self.create_local_metadata(ca, self.config.Runtime_Options__tags_read)
                ct_md = self.fetch_metadata(match_set.online_results[int(i) - 1].issue_id)

                match_set.md = prepare_metadata(md, ct_md, self.config)

                self.write_tags(ca, match_set.md)

    def post_process_matches(self, match_results: OnlineMatchResults) -> None:
        def print_header(header: str) -> None:
            self.output("", force_output=True)
            self.output(header, force_output=True)
            self.output("------------------", force_output=True)

        # now go through the match results
        if self.config.Runtime_Options__summary:
            if len(match_results.good_matches) > 0:
                print_header("Successful matches:")
                for f in match_results.good_matches:
                    self.output(f, force_output=True)

            if len(match_results.no_matches) > 0:
                print_header("No matches:")
                for f in match_results.no_matches:
                    self.output(f, force_output=True)

            if len(match_results.write_failures) > 0:
                print_header("File Write Failures:")
                for f in match_results.write_failures:
                    self.output(f, force_output=True)

            if len(match_results.fetch_data_failures) > 0:
                print_header("Network Data Fetch Failures:")
                for f in match_results.fetch_data_failures:
                    self.output(f, force_output=True)

        if not self.config.Runtime_Options__summary and not self.config.Runtime_Options__interactive:
            # just quit if we're not interactive or showing the summary
            return

        if len(match_results.multiple_matches) > 0:
            self.output("\nArchives with multiple high-confidence matches:\n------------------", force_output=True)
            for match_set in match_results.multiple_matches:
                self.display_match_set_for_choice("Multiple high-confidence matches", match_set)

        if len(match_results.low_confidence_matches) > 0:
            self.output("\nArchives with low-confidence matches:\n------------------", force_output=True)
            for match_set in match_results.low_confidence_matches:
                if len(match_set.online_results) == 1:
                    label = "Single low-confidence match"
                else:
                    label = "Multiple low-confidence matches"

                self.display_match_set_for_choice(label, match_set)

    def create_local_metadata(
        self, ca: ComicArchive, tags_to_read: list[str], /, tags_only: bool = False
    ) -> tuple[GenericMetadata, list[str]]:
        md = GenericMetadata()
        md.apply_default_page_list(ca.get_page_name_list())
        filename_md = GenericMetadata()

        # now, overlay the parsed filename info
        if self.config.Auto_Tag__parse_filename and not tags_only:
            filename_md = ca.metadata_from_filename(
                self.config.Filename_Parsing__filename_parser,
                self.config.Filename_Parsing__remove_c2c,
                self.config.Filename_Parsing__remove_fcbd,
                self.config.Filename_Parsing__remove_publisher,
                self.config.Filename_Parsing__split_words,
                self.config.Filename_Parsing__allow_issue_start_with_letter,
                self.config.Filename_Parsing__protofolius_issue_number_scheme,
            )

        file_md = GenericMetadata()
        tags_used = []
        for tag_id in tags_to_read:
            if ca.has_tags(tag_id):
                try:
                    t_md = ca.read_tags(tag_id)
                    if not t_md.is_empty:
                        file_md.overlay(
                            t_md,
                            self.config.Metadata_Options__tag_merge,
                            self.config.Metadata_Options__tag_merge_lists,
                        )
                        tags_used.append(tag_id)
                except Exception as e:
                    logger.error("Failed to load metadata for %s: %s", ca.path, e)

        filename_merge = merge.Mode.ADD_MISSING
        if self.config.Auto_Tag__prefer_filename:
            filename_merge = merge.Mode.OVERLAY

        md.overlay(file_md, mode=merge.Mode.OVERLAY, merge_lists=False)
        if not tags_only:
            md.overlay(filename_md, mode=filename_merge, merge_lists=False)
            # finally, use explicit stuff (always 'overlay' mode)
            md.overlay(self.config.Auto_Tag__metadata, mode=merge.Mode.OVERLAY, merge_lists=True)

        return (md, tags_used)

    def print(self, ca: ComicArchive | None) -> Result:
        md = None
        if ca is None:
            if not self.config.Auto_Tag__metadata.is_empty:
                if not self.config.Auto_Tag__metadata.is_empty:
                    self.output("--------- CLI tags ---------")
                    self.output(self.config.Auto_Tag__metadata)
            return Result(Action.print, Status.success, None, md=md)  # type: ignore
        if not self.config.Runtime_Options__tags_read:
            page_count = ca.get_number_of_pages()

            brief = ""

            if self.batch_mode:
                brief = f"{ca.path}: "

            brief += ca.archiver.name() + " archive "

            brief += f"({page_count: >3} pages)"
            brief += "  tags:[ "

            tag_names = [tags[tag_id].name() for tag_id in tags if ca.has_tags(tag_id)]
            brief += " ".join(tag_names)
            brief += " ]"

            self.output(brief)

        if self.config.Runtime_Options__quiet:
            return Result(Action.print, Status.success, ca.path)

        self.output()

        for tag_id, tag in tags.items():
            if not self.config.Runtime_Options__tags_read or tag_id in self.config.Runtime_Options__tags_read:
                if ca.has_tags(tag_id):
                    self.output(f"--------- {tag.name()} tags ---------")
                    try:
                        if self.config.Runtime_Options__raw:
                            self.output(ca.read_raw_tags(tag_id))
                        else:
                            md = ca.read_tags(tag_id)
                            self.output(md)
                    except Exception as e:
                        logger.error("Failed to read tags from %s: %s", ca.path, e)
        return Result(Action.print, Status.success, ca.path, md=md)

    def delete_tags(self, ca: ComicArchive, tag_id: str) -> Status:
        tag_name = tags[tag_id].name()

        if ca.has_tags(tag_id):
            if not self.config.Runtime_Options__dryrun:
                if ca.remove_tags(tag_id):
                    self.output(f"{ca.path}: Removed {tag_name} tags.")
                    return Status.success
                else:
                    self.output(f"{ca.path}: Tag removal seemed to fail!")
                    return Status.write_failure
            else:
                self.output(f"{ca.path}: dry-run. {tag_name} tags not removed")
                return Status.success
        self.output(f"{ca.path}: This archive doesn't have {tag_name} tags to remove.")
        return Status.success

    def delete(self, ca: ComicArchive) -> Result:
        res = Result(Action.delete, Status.success, ca.path)
        for tag_id in self.config.Runtime_Options__tags_write:
            status = self.delete_tags(ca, tag_id)
            if status == Status.success:
                res.tags_deleted.append(tag_id)
            else:
                res.status = status
        return res

    def _copy_tags(self, ca: ComicArchive, md: GenericMetadata, source_names: str, dst_tag_id: str) -> Status:
        dst_tag_name = tags[dst_tag_id].name()
        if self.config.Runtime_Options__skip_existing_tags and ca.has_tags(dst_tag_id):
            self.output(f"{ca.path}: Already has {dst_tag_name} tags. Not overwriting.")
            return Status.existing_tags

        if len(self.config.Commands__copy) == 1 and dst_tag_id in self.config.Commands__copy:
            self.output(f"{ca.path}: Destination and source are same: {dst_tag_name}. Nothing to do.")
            return Status.existing_tags

        if not self.config.Runtime_Options__dryrun:
            if self.config.Metadata_Options__apply_transform_on_bulk_operation and dst_tag_id == "cbi":
                md = CBLTransformer(md, self.config).apply()

            if ca.write_tags(md, dst_tag_id):
                self.output(f"{ca.path}: Copied {source_names} tags to {dst_tag_name}.")
            else:
                self.output(f"{ca.path}: Tag copy seemed to fail!")
                return Status.write_failure
        else:
            self.output(f"{ca.path}: dry-run.  {source_names} tags not copied")
        return Status.success

    def copy(self, ca: ComicArchive) -> Result:
        res = Result(Action.copy, Status.success, ca.path)
        src_tag_names = []
        for src_tag_id in self.config.Commands__copy:
            src_tag_names.append(tags[src_tag_id].name())
            if ca.has_tags(src_tag_id):
                res.tags_read.append(src_tag_id)

        if not res.tags_read:
            self.output(f"{ca.path}: This archive doesn't have any {', '.join(src_tag_names)} tags to copy.")
            res.status = Status.read_failure
            return res
        try:
            res.md, res.tags_read = self.create_local_metadata(ca, res.tags_read, tags_only=True)
        except Exception as e:
            logger.error("Failed to read tags from %s: %s", ca.path, e)
            return res

        for dst_tag_id in self.config.Runtime_Options__tags_write:
            if dst_tag_id in self.config.Commands__copy:
                continue

            status = self._copy_tags(ca, res.md, ", ".join(src_tag_names), dst_tag_id)
            if status == Status.success:
                res.tags_written.append(dst_tag_id)
            else:
                res.status = status
        return res

    def try_quick_tag(self, ca: ComicArchive, md: GenericMetadata) -> GenericMetadata | None:
        if not self.config.Runtime_Options__enable_quick_tag:
            self.output("skipping quick tag")
            return None
        self.output("starting quick tag")
        try:
            qt = QuickTag(
                self.config.Quick_Tag__url,
                str(utils.parse_url(self.current_talker().website).host),
                self.current_talker(),
                self.config,
                self.output,
            )
            ct_md = qt.id_comic(
                ca,
                md,
                self.config.Quick_Tag__simple,
                set(self.config.Quick_Tag__hash),
                self.config.Quick_Tag__exact_only,
                self.config.Runtime_Options__interactive,
                self.config.Quick_Tag__aggressive_filtering,
                self.config.Quick_Tag__max,
            )
            if ct_md is None:
                ct_md = GenericMetadata()
            return ct_md
        except Exception:
            logger.exception("Quick Tagging failed")
        return None

    def normal_tag(
        self, ca: ComicArchive, tags_read: list[str], md: GenericMetadata, match_results: OnlineMatchResults
    ) -> tuple[GenericMetadata, list[IssueResult], Result | None, OnlineMatchResults]:
        # ct_md, results, matches, match_results
        if md is None or md.is_empty:
            logger.error("No metadata given to search online with!")
            res = Result(
                Action.save,
                status=Status.match_failure,
                original_path=ca.path,
                match_status=MatchStatus.no_match,
                tags_written=self.config.Runtime_Options__tags_write,
                tags_read=tags_read,
            )
            match_results.no_matches.append(res)
            return GenericMetadata(), [], res, match_results

        ii = IssueIdentifier(ca, self.config, self.current_talker())

        ii.set_output_function(functools.partial(self.output, already_logged=True))
        if not self.config.Auto_Tag__use_year_when_identifying:
            md.year = None
        if self.config.Auto_Tag__ignore_leading_numbers_in_filename and md.series is not None:
            md.series = re.sub(r"^([\d.]+)(.*)", r"\2", md.series)
        result, matches = ii.identify(ca, md)

        found_match = False
        choices = False
        low_confidence = False

        if result == IssueIdentifier.result_no_matches:
            pass
        elif result == IssueIdentifier.result_found_match_but_bad_cover_score:
            low_confidence = True
            found_match = True
        elif result == IssueIdentifier.result_found_match_but_not_first_page:
            found_match = True
        elif result == IssueIdentifier.result_multiple_matches_with_bad_image_scores:
            low_confidence = True
            choices = True
        elif result == IssueIdentifier.result_one_good_match:
            found_match = True
        elif result == IssueIdentifier.result_multiple_good_matches:
            choices = True

        if choices:
            if low_confidence:
                logger.error("Online search: Multiple low confidence matches. Save aborted")
                res = Result(
                    Action.save,
                    status=Status.match_failure,
                    original_path=ca.path,
                    online_results=matches,
                    match_status=MatchStatus.low_confidence_match,
                    tags_written=self.config.Runtime_Options__tags_write,
                    tags_read=tags_read,
                )
                match_results.low_confidence_matches.append(res)
                return GenericMetadata(), matches, res, match_results

            logger.error("Online search: Multiple good matches. Save aborted")
            res = Result(
                Action.save,
                status=Status.match_failure,
                original_path=ca.path,
                online_results=matches,
                match_status=MatchStatus.multiple_match,
                tags_written=self.config.Runtime_Options__tags_write,
                tags_read=tags_read,
            )
            match_results.multiple_matches.append(res)
            return GenericMetadata(), matches, res, match_results
        if low_confidence and self.config.Runtime_Options__abort_on_low_confidence:
            logger.error("Online search: Low confidence match. Save aborted")
            res = Result(
                Action.save,
                status=Status.match_failure,
                original_path=ca.path,
                online_results=matches,
                match_status=MatchStatus.low_confidence_match,
                tags_written=self.config.Runtime_Options__tags_write,
                tags_read=tags_read,
            )
            match_results.low_confidence_matches.append(res)
            return GenericMetadata(), matches, res, match_results
        if not found_match:
            logger.error("Online search: No match found. Save aborted")
            res = Result(
                Action.save,
                status=Status.match_failure,
                original_path=ca.path,
                online_results=matches,
                match_status=MatchStatus.no_match,
                tags_written=self.config.Runtime_Options__tags_write,
                tags_read=tags_read,
            )
            match_results.no_matches.append(res)
            return GenericMetadata(), matches, res, match_results

        # we got here, so we have a single match

        # now get the particular issue data
        ct_md = self.fetch_metadata(matches[0].issue_id)
        if ct_md.is_empty:
            res = Result(
                Action.save,
                status=Status.fetch_data_failure,
                original_path=ca.path,
                online_results=matches,
                match_status=MatchStatus.good_match,
                tags_written=self.config.Runtime_Options__tags_write,
                tags_read=tags_read,
            )
            match_results.fetch_data_failures.append(res)
            return GenericMetadata(), matches, res, match_results
        return ct_md, matches, None, match_results

    def save(self, ca: ComicArchive, match_results: OnlineMatchResults) -> tuple[Result, OnlineMatchResults]:
        if self.config.Runtime_Options__skip_existing_tags:
            for tag_id in self.config.Runtime_Options__tags_write:
                if ca.has_tags(tag_id):
                    self.output(f"{ca.path}: Already has {tags[tag_id].name()} tags. Not overwriting.")
                    return (
                        Result(
                            Action.save,
                            original_path=ca.path,
                            status=Status.existing_tags,
                            tags_written=self.config.Runtime_Options__tags_write,
                        ),
                        match_results,
                    )

        if self.batch_mode:
            self.output(f"Processing {utils.path_to_short_str(ca.path)}...")

        md, tags_read = self.create_local_metadata(ca, self.config.Runtime_Options__tags_read)
        if md.issue is None or md.issue == "":
            if self.config.Auto_Tag__assume_issue_one:
                md.issue = "1"

        matches: list[IssueResult] = []
        # now, search online

        ct_md = GenericMetadata()
        if self.config.Auto_Tag__online:
            if self.config.Auto_Tag__issue_id is not None:
                # we were given the actual issue ID to search with
                try:
                    ct_md = self.current_talker().fetch_comic_data(self.config.Auto_Tag__issue_id)
                except TalkerError as e:
                    logger.exception(f"Error retrieving issue details. Save aborted.\n{e}")
                    res = Result(
                        Action.save,
                        original_path=ca.path,
                        status=Status.fetch_data_failure,
                        tags_written=self.config.Runtime_Options__tags_write,
                        tags_read=tags_read,
                    )
                    match_results.fetch_data_failures.append(res)
                    return res, match_results

                if ct_md is None or ct_md.is_empty:
                    logger.error("No match for ID %s was found.", self.config.Auto_Tag__issue_id)
                    res = Result(
                        Action.save,
                        status=Status.match_failure,
                        original_path=ca.path,
                        match_status=MatchStatus.no_match,
                        tags_written=self.config.Runtime_Options__tags_write,
                        tags_read=tags_read,
                    )
                    match_results.no_matches.append(res)
                    return res, match_results

            else:
                qt_md = self.try_quick_tag(ca, md)
                if qt_md is None or qt_md.is_empty:
                    if qt_md is not None:
                        self.output("Failed to find match via quick tag")
                    ct_md, matches, res, match_results = self.normal_tag(ca, tags_read, md, match_results)  # type: ignore[assignment]
                    if res is not None:
                        return res, match_results
                else:
                    self.output("Successfully matched via quick tag")
                    ct_md = qt_md
                    matches = [
                        IssueResult(
                            series=ct_md.series or "",
                            distance=-1,
                            issue_number=ct_md.issue or "",
                            issue_count=ct_md.issue_count,
                            url_image_hash=-1,
                            issue_title=ct_md.title or "",
                            issue_id=ct_md.issue_id or "",
                            series_id=ct_md.issue_id or "",
                            month=ct_md.month,
                            year=ct_md.year,
                            publisher=None,
                            image_url=ct_md._cover_image or "",
                            alt_image_urls=[],
                            description=ct_md.description or "",
                        )
                    ]

        res = Result(
            Action.save,
            status=Status.success,
            original_path=ca.path,
            online_results=matches,
            match_status=MatchStatus.good_match,
            md=prepare_metadata(md, ct_md, self.config),
            tags_written=self.config.Runtime_Options__tags_write,
            tags_read=tags_read,
        )
        assert res.md
        # ok, done building our metadata. time to save
        if self.write_tags(ca, res.md):
            match_results.good_matches.append(res)
        else:
            res.status = Status.write_failure
            match_results.write_failures.append(res)
        return res, match_results

    def rename(self, ca: ComicArchive) -> Result:
        original_path = ca.path
        msg_hdr = ""
        if self.batch_mode:
            msg_hdr = f"{ca.path}: "

        md, tags_read = self.create_local_metadata(ca, self.config.Runtime_Options__tags_read)

        if md.series is None:
            logger.error(msg_hdr + "Can't rename without series name")
            return Result(Action.rename, Status.read_failure, original_path)

        new_ext = ""  # default
        if self.config.File_Rename__auto_extension:
            new_ext = ca.extension()

        renamer = FileRenamer(
            None,
            platform="universal" if self.config.File_Rename__strict_filenames else "auto",
            replacements=self.config.File_Rename__replacements,
        )
        renamer.set_metadata(md, ca.path.name)
        renamer.set_template(self.config.File_Rename__template)
        renamer.set_issue_zero_padding(self.config.File_Rename__issue_number_padding)
        renamer.set_smart_cleanup(self.config.File_Rename__use_smart_string_cleanup)
        renamer.move = self.config.File_Rename__move
        renamer.move_only = self.config.File_Rename__only_move

        try:
            new_name = renamer.determine_name(ext=new_ext)
        except ValueError:
            logger.exception(
                msg_hdr
                + "Invalid format string!\n"
                + "Your rename template is invalid!\n\n"
                + "%s\n\n"
                + "Please consult the template help in the settings "
                + "and the documentation on the format at "
                + "https://docs.python.org/3/library/string.html#format-string-syntax",
                self.config.File_Rename__template,
            )
            return Result(Action.rename, Status.rename_failure, original_path, md=md)
        except Exception:
            logger.exception("Formatter failure: %s metadata: %s", self.config.File_Rename__template, renamer.metadata)
            return Result(Action.rename, Status.rename_failure, original_path, md=md)

        folder = get_rename_dir(ca, self.config.File_Rename__dir if self.config.File_Rename__move else None)

        full_path = folder / new_name

        if full_path == ca.path:
            self.output(msg_hdr + "Filename is already good!")
            return Result(Action.rename, Status.success, original_path, full_path, md=md)

        suffix = ""
        if not self.config.Runtime_Options__dryrun:
            # rename the file
            try:
                ca.rename(utils.unique_file(full_path))
            except OSError:
                logger.exception("Failed to rename comic archive: %s", ca.path)
                return Result(Action.rename, Status.write_failure, original_path, full_path, md=md)
        else:
            suffix = " (dry-run, no change)"

        self.output(f"renamed '{original_path.name}' -> '{new_name}' {suffix}")
        return Result(Action.rename, Status.success, original_path, tags_read=tags_read, md=md)

    def export(self, ca: ComicArchive) -> Result:
        msg_hdr = ""
        if self.batch_mode:
            msg_hdr = f"{ca.path}: "

        if ca.is_zip():
            logger.error(msg_hdr + "Archive is already a zip file.")
            return Result(Action.export, Status.success, ca.path)

        filename_path = ca.path
        new_file = filename_path.with_suffix(".cbz")

        if self.config.Runtime_Options__abort_on_conflict and new_file.exists():
            self.output(msg_hdr + f"{new_file.name} already exists in the that folder.")
            return Result(Action.export, Status.write_failure, ca.path)

        new_file = utils.unique_file(new_file)

        delete_success = False
        export_success = False
        if not self.config.Runtime_Options__dryrun:
            if ca.export_as_zip(new_file):
                export_success = True
                if self.config.Runtime_Options__delete_original:
                    try:
                        filename_path.unlink(missing_ok=True)
                        delete_success = True
                    except OSError:
                        logger.exception(msg_hdr + "Error deleting original archive after export")
            else:
                # last export failed, so remove the zip, if it exists
                new_file.unlink(missing_ok=True)
        else:
            msg = msg_hdr + f"Dry-run:  Would try to create {os.path.split(new_file)[1]}"
            if self.config.Runtime_Options__delete_original:
                msg += " and delete original."
            self.output(msg)
            return Result(Action.export, Status.success, ca.path, new_file)

        msg = msg_hdr
        if export_success:
            msg += f"Archive exported successfully to: {os.path.split(new_file)[1]}"
            if self.config.Runtime_Options__delete_original and delete_success:
                msg += " (Original deleted) "
        else:
            msg += "Archive failed to export!"

        self.output(msg)

        return Result(Action.export, Status.success, ca.path, new_file)

    def process_file_cli(
        self, command: Action, filename: str, match_results: OnlineMatchResults
    ) -> tuple[Result, OnlineMatchResults]:
        if not os.path.lexists(filename):
            logger.error("Cannot find %s", filename)
            return Result(command, Status.read_failure, pathlib.Path(filename)), match_results

        ca = ComicArchive(filename, str(graphics_path / "nocover.png"))

        if not ca.seems_to_be_a_comic_archive():
            logger.error("Sorry, but %s is not a comic archive!", filename)
            return Result(Action.rename, Status.read_failure, ca.path), match_results

        if not ca.is_writable() and (command in (Action.delete, Action.copy, Action.save, Action.rename)):
            logger.error("This archive is not writable")
            return Result(command, Status.write_permission_failure, ca.path), match_results

        if command == Action.print:
            return self.print(ca), match_results

        elif command == Action.delete:
            return self.delete(ca), match_results

        elif command == Action.copy is not None:
            return self.copy(ca), match_results

        elif command == Action.save:
            return self.save(ca, match_results)

        elif command == Action.rename:
            return self.rename(ca), match_results

        elif command == Action.export:
            return self.export(ca), match_results
        return Result(None, Status.read_failure, ca.path), match_results  # type: ignore[arg-type]