"""BAT🦇 packing interface for Flamenco."""

import asyncio
import logging
import pathlib
import re
import threading
import typing
import urllib.parse

import bpy
from blender_asset_tracer import pack
from blender_asset_tracer.pack import progress, transfer, shaman

log = logging.getLogger(__name__)

_running_packer = None  # type: pack.Packer
_packer_lock = threading.RLock()

# For using in other parts of the add-on, so only this file imports BAT.
Aborted = pack.Aborted
FileTransferError = transfer.FileTransferError
parse_shaman_endpoint = shaman.parse_endpoint


class BatProgress(progress.Callback):
    """Report progress of BAT Packing to the UI.

    Uses asyncio.run_coroutine_threadsafe() to ensure the UI is only updated
    from the main thread. This is required since we run the BAT Pack in a
    background thread.
    """

    def __init__(self) -> None:
        super().__init__()
        self.loop = asyncio.get_event_loop()

    def _set_attr(self, attr: str, value):
        async def do_it():
            setattr(bpy.context.window_manager, attr, value)

        asyncio.run_coroutine_threadsafe(do_it(), loop=self.loop)

    def _txt(self, msg: str):
        """Set a text in a thread-safe way."""
        self._set_attr("flamenco_status_txt", msg)

    def _status(self, status: str):
        """Set the flamenco_status property in a thread-safe way."""
        self._set_attr("flamenco_status", status)

    def _progress(self, progress: int):
        """Set the flamenco_progress property in a thread-safe way."""
        self._set_attr("flamenco_progress", progress)

    def pack_start(self) -> None:
        self._txt("Starting BAT Pack operation")

    def pack_done(
        self, output_blendfile: pathlib.Path, missing_files: typing.Set[pathlib.Path]
    ) -> None:
        if missing_files:
            self._txt("There were %d missing files" % len(missing_files))
        else:
            self._txt("Pack of %s done" % output_blendfile.name)

    def pack_aborted(self, reason: str):
        self._txt("Aborted: %s" % reason)
        self._status("ABORTED")

    def trace_blendfile(self, filename: pathlib.Path) -> None:
        """Called for every blendfile opened when tracing dependencies."""
        self._txt("Inspecting %s" % filename.name)

    def trace_asset(self, filename: pathlib.Path) -> None:
        if filename.stem == ".blend":
            return
        self._txt("Found asset %s" % filename.name)

    def rewrite_blendfile(self, orig_filename: pathlib.Path) -> None:
        self._txt("Rewriting %s" % orig_filename.name)

    def transfer_file(self, src: pathlib.Path, dst: pathlib.Path) -> None:
        self._txt("Transferring %s" % src.name)

    def transfer_file_skipped(self, src: pathlib.Path, dst: pathlib.Path) -> None:
        self._txt("Skipped %s" % src.name)

    def transfer_progress(self, total_bytes: int, transferred_bytes: int) -> None:
        self._progress(round(100 * transferred_bytes / total_bytes))

    def missing_file(self, filename: pathlib.Path) -> None:
        # TODO(Sybren): report missing files in a nice way
        pass


class ShamanPacker(shaman.ShamanPacker):
    """Packer with support for getting an auth token from Flamenco Server."""

    def __init__(
        self,
        bfile: pathlib.Path,
        project: pathlib.Path,
        target: str,
        endpoint: str,
        checkout_id: str,
        *,
        manager_id: str,
        **kwargs
    ) -> None:
        self.manager_id = manager_id
        super().__init__(bfile, project, target, endpoint, checkout_id, **kwargs)

    def _get_auth_token(self) -> str:
        """get a token from Flamenco Server"""

        from ..blender import PILLAR_SERVER_URL
        from ..pillar import blender_id_subclient, uncached_session, SUBCLIENT_ID

        url = urllib.parse.urljoin(
            PILLAR_SERVER_URL, "flamenco/jwt/generate-token/%s" % self.manager_id
        )
        auth_token = blender_id_subclient()["token"]

        resp = uncached_session.get(url, auth=(auth_token, SUBCLIENT_ID))
        resp.raise_for_status()
        return resp.text


async def copy(
    context,
    base_blendfile: pathlib.Path,
    project: pathlib.Path,
    target: str,
    exclusion_filter: str,
    *,
    relative_only: bool,
    packer_class=pack.Packer,
    **packer_args
) -> typing.Tuple[pathlib.Path, typing.Set[pathlib.Path]]:
    """Use BAT🦇 to copy the given file and dependencies to the target location.

    :raises: FileTransferError if a file couldn't be transferred.
    :returns: the path of the packed blend file, and a set of missing sources.
    """
    global _running_packer

    loop = asyncio.get_event_loop()
    wm = bpy.context.window_manager

    packer = packer_class(
        base_blendfile,
        project,
        target,
        compress=True,
        relative_only=relative_only,
        **packer_args
    )
    with packer:
        with _packer_lock:
            if exclusion_filter:
                # There was a mistake in an older version of the property tooltip,
                # showing semicolon-separated instead of space-separated. We now
                # just handle both.
                filter_parts = re.split("[ ;]+", exclusion_filter.strip(" ;"))
                packer.exclude(*filter_parts)

            packer.progress_cb = BatProgress()
            _running_packer = packer

        log.debug("awaiting strategise")
        wm.flamenco_status = "INVESTIGATING"
        await loop.run_in_executor(None, packer.strategise)

        log.debug("awaiting execute")
        wm.flamenco_status = "TRANSFERRING"
        await loop.run_in_executor(None, packer.execute)

        log.debug("done")
        wm.flamenco_status = "DONE"

    with _packer_lock:
        _running_packer = None

    return packer.output_path, packer.missing_files


def abort() -> None:
    """Abort a running copy() call.

    No-op when there is no running copy(). Can be called from any thread.
    """

    with _packer_lock:
        if _running_packer is None:
            log.debug("No running packer, ignoring call to bat_abort()")
            return
        log.info("Aborting running packer")
        _running_packer.abort()