from collections import OrderedDict
from typing import Any

from . import is_google_colab, is_notebook
from .tqdm import _create_progress_bar, tqdm


def _format_speed_postfix(speed: float | None) -> str:
    s = tqdm.format_sizeof(speed) if speed is not None else "???"
    return f"{s}B/s  ".rjust(10, " ")


# Transfer byte count is hard to predict (dedup/compression), so we omit a total and show bytes only.
XET_TRANSFER_BAR_FORMAT = "{desc}: {bar}| {n_fmt:>5}B{postfix:>12}"
XET_BYTES_BAR_FORMAT = "{l_bar}{bar}| {n_fmt:>5}B / {total_fmt:>5}B{postfix:>12}"


def _set_monotonic_total(bar, total: int | None) -> None:
    if total is None or not hasattr(bar, "total"):
        return
    bar.total = max(bar.total or 0, total)


def _update_transfer_bar(bar, inc: int) -> None:
    """Update the transfer bar and grow its hidden total so the bar graphic advances.

    Network bytes are hard to predict (dedup/compression), so the display omits a denominator.
    tqdm still needs an internal total for the bar width — seeded from file size when known,
    then expanded here if bytes received exceed that estimate.
    """
    n_after = getattr(bar, "n", 0) + inc
    current_total = getattr(bar, "total", 0) or 0
    if n_after > 0 and current_total < n_after:
        bar.total = max(current_total, int(n_after * 1.25) + 1)
    bar.update(inc)


def _finish_transfer_bar(bar) -> None:
    """Snap the transfer bar to 100% when downloading stops.

    Transfer totals are seeded from file size, but actual network bytes are often lower.
    Set ``total = n`` so the bar fills completely instead of stopping partway.
    """
    n = getattr(bar, "n", 0)
    if n > 0 and hasattr(bar, "total") and bar.total != n:
        bar.total = n
        bar.refresh()


class XetDownloadProgressReporter:
    """Dual progress bars for Xet downloads: network transfer and file reconstruction.

    ``total_transfer_bytes_completed`` tracks bytes received from the network (updated continuously).
    ``total_bytes_completed`` tracks bytes written to disk (updated after buffered chunks are flushed).
    Showing both bars gives responsive feedback on slow connections where reconstruction lags behind transfer.
    """

    def __init__(
        self,
        *,
        reconstruction_desc: str,
        transfer_desc: str = "Downloading bytes",
        total: int | None = None,
        log_level: int,
        name: str | None = None,
        tqdm_class: type | None = None,
        external_reconstruction_bar: Any | None = None,
        position: int = 0,
    ):
        self._prev_bytes_completed = 0
        self._prev_transfer_bytes_completed = 0

        cls = tqdm_class or tqdm
        routes_transfer_via_reconstruction = external_reconstruction_bar is not None and callable(
            getattr(external_reconstruction_bar, "update_transfer", None)
        )
        uses_aggregated_tqdm_class = external_reconstruction_bar is None and callable(
            getattr(cls, "update_transfer", None)
        )

        if external_reconstruction_bar is not None:
            self.reconstruction_bar = external_reconstruction_bar
            self._owns_reconstruction_bar = False
        else:
            self.reconstruction_bar = _create_progress_bar(
                cls=cls,  # ty: ignore[invalid-argument-type]
                log_level=log_level,
                name=name,
                desc=reconstruction_desc,
                total=total,
                unit="B",
                unit_scale=True,
                position=position + 1,
                bar_format=XET_BYTES_BAR_FORMAT,
                leave=True,
            )
            self._owns_reconstruction_bar = True

        if routes_transfer_via_reconstruction or uses_aggregated_tqdm_class:
            self.transfer_bar = self.reconstruction_bar
            self._owns_transfer_bar = False
        elif external_reconstruction_bar is not None:
            self.transfer_bar = None
            self._owns_transfer_bar = False
        else:
            self.transfer_bar = _create_progress_bar(
                cls=tqdm,
                log_level=log_level,
                name=f"{name}.transfer" if name else None,
                desc=transfer_desc,
                total=total,
                unit="B",
                unit_scale=True,
                position=position,
                bar_format=XET_TRANSFER_BAR_FORMAT,
                leave=True,
            )
            self._owns_transfer_bar = True

    @property
    def _aggregated(self) -> bool:
        return self.transfer_bar is not None and self.transfer_bar is self.reconstruction_bar

    def update_progress(self, group_report, _item_reports: dict | None = None) -> None:
        bytes_inc = max(0, group_report.total_bytes_completed - self._prev_bytes_completed)
        transfer_inc = max(0, group_report.total_transfer_bytes_completed - self._prev_transfer_bytes_completed)
        self._prev_bytes_completed = group_report.total_bytes_completed
        self._prev_transfer_bytes_completed = group_report.total_transfer_bytes_completed

        if bytes_inc > 0:
            self.reconstruction_bar.update(bytes_inc)
            self.reconstruction_bar.set_postfix_str(
                _format_speed_postfix(group_report.total_bytes_completion_rate), refresh=False
            )

        if transfer_inc > 0 and self.transfer_bar is not None:
            if self._aggregated:
                self.reconstruction_bar.update_transfer(transfer_inc)
                self.reconstruction_bar.set_transfer_postfix_str(
                    _format_speed_postfix(group_report.total_transfer_bytes_completion_rate), refresh=False
                )
            else:
                _update_transfer_bar(self.transfer_bar, transfer_inc)
                self.transfer_bar.set_postfix_str(
                    _format_speed_postfix(group_report.total_transfer_bytes_completion_rate), refresh=False
                )

        if group_report.total_bytes:
            _set_monotonic_total(self.reconstruction_bar, group_report.total_bytes)

    def close(self) -> None:
        """Close bars owned by this reporter.

        Standalone downloads finish the transfer bar first (snap hidden total to ``n``), then close it.
        Aggregated and external bars (e.g. snapshot ``_AggregatedTqdm`` or a reused ``_tqdm_bar``) are left
        open — their parent caller owns their lifecycle.
        """
        if self.transfer_bar is not None and self._owns_transfer_bar:
            _finish_transfer_bar(self.transfer_bar)
            if hasattr(self.transfer_bar, "close"):
                self.transfer_bar.close()
        if self._owns_reconstruction_bar and hasattr(self.reconstruction_bar, "close"):
            self.reconstruction_bar.close()

    def __enter__(self) -> "XetDownloadProgressReporter":
        return self

    def __exit__(self, *args) -> None:
        self.close()


class XetUploadProgressReporter:
    """
    Reports on progress for Xet uploads.

    Shows summary progress bars when running in notebooks or GUIs, and detailed per-file progress in console environments.
    """

    def __init__(self, n_lines: int = 10, description_width: int = 30, total_files: int | None = None):
        self.n_lines = n_lines
        self.description_width = description_width
        self.total_files = total_files

        self.per_file_progress = is_google_colab() or not is_notebook()

        self.tqdm_settings = {
            "unit": "B",
            "unit_scale": True,
            "leave": True,
            "unit_divisor": 1000,
            "nrows": n_lines + 3 if self.per_file_progress else 3,
            "miniters": 1,
            "bar_format": XET_BYTES_BAR_FORMAT,
        }

        # Overall progress bars
        self.data_processing_bar = tqdm(
            total=0, desc=self.format_desc("Processing Files (0 / 0)", False), position=0, **self.tqdm_settings
        )

        self.upload_bar = tqdm(
            total=0, desc=self.format_desc("New Data Upload", False), position=1, **self.tqdm_settings
        )

        self.known_items: set[str] = set()
        self.completed_items: set[str] = set()

        # Track previous absolute values to compute increments
        self._prev_bytes_completed: int = 0
        self._prev_transfer_bytes_completed: int = 0

        # Item bars (scrolling view)
        self.item_state: OrderedDict[str, Any] = OrderedDict()
        self.current_bars: list = [None] * self.n_lines

    def format_desc(self, name: str, indent: bool) -> str:
        """
        if name is longer than width characters, prints ... at the start and then the last width-3 characters of the name, otherwise
        the whole name right justified into description_width characters.  Also adds some padding.
        """

        if not self.per_file_progress:
            # Here we just use the defaults.
            return name

        padding = "  " if indent else ""
        width = self.description_width - len(padding)

        if len(name) > width:
            name = f"...{name[-(width - 3) :]}"

        return f"{padding}{name.ljust(width)}"

    def reset_for_next_commit(self):
        """Reset per-commit state so the reporter can be reused across multiple upload commits."""
        self._prev_bytes_completed = 0
        self._prev_transfer_bytes_completed = 0
        self.known_items.clear()
        self.completed_items.clear()
        self.item_state.clear()

    def update_progress(self, group_report, item_reports: dict):
        # Update all the per-item values.
        for item in item_reports.values():
            item_name = item.item_name

            self.known_items.add(item_name)

            # Only care about items where the processing has already started.
            if item.bytes_completed == 0:
                continue

            # Overwrite the existing value in there.
            self.item_state[item_name] = item

        bar_idx = 0
        new_completed = []

        # Now, go through and update all the bars
        for name, item in self.item_state.items():
            # Is this ready to be removed on the next update?
            if item.bytes_completed == item.total_bytes:
                self.completed_items.add(name)
                new_completed.append(name)

            # If we're only showing summary information, then don't update the individual bars
            if not self.per_file_progress:
                continue

            # If we've run out of bars to use, then collapse the last ones together.
            if bar_idx >= len(self.current_bars):
                bar = self.current_bars[-1]
                in_final_bar_mode = True
                final_bar_aggregation_count = bar_idx + 1 - len(self.current_bars)
            else:
                bar = self.current_bars[bar_idx]
                in_final_bar_mode = False

            if bar is None:
                self.current_bars[bar_idx] = tqdm(
                    desc=self.format_desc(name, True),
                    position=2 + bar_idx,  # Set to the position past the initial bars.
                    total=item.total_bytes,
                    initial=item.bytes_completed,
                    **self.tqdm_settings,
                )

            elif in_final_bar_mode:
                bar.n += item.bytes_completed
                bar.total += item.total_bytes
                bar.set_description(self.format_desc(f"[+ {final_bar_aggregation_count} files]", True), refresh=False)
            else:
                bar.set_description(self.format_desc(name, True), refresh=False)
                bar.n = item.bytes_completed
                bar.total = item.total_bytes

            bar_idx += 1

        # Remove all the completed ones from the ordered dictionary
        for name in new_completed:
            # Only remove ones from consideration to make room for more items coming in.
            if len(self.item_state) <= self.n_lines:
                break

            del self.item_state[name]

        if self.per_file_progress:
            # Now manually refresh each of the bars
            for bar in self.current_bars:
                if bar:
                    bar.refresh()

        # Update overall bars
        bytes_inc = max(0, group_report.total_bytes_completed - self._prev_bytes_completed)
        transfer_inc = max(0, group_report.total_transfer_bytes_completed - self._prev_transfer_bytes_completed)
        self._prev_bytes_completed = group_report.total_bytes_completed
        self._prev_transfer_bytes_completed = group_report.total_transfer_bytes_completed

        self.data_processing_bar.total = group_report.total_bytes
        total_files_count = self.total_files if self.total_files is not None else len(self.known_items)
        self.data_processing_bar.set_description(
            self.format_desc(f"Processing Files ({len(self.completed_items)} / {total_files_count})", False),
            refresh=False,
        )
        self.data_processing_bar.set_postfix_str(
            _format_speed_postfix(group_report.total_bytes_completion_rate), refresh=False
        )
        self.data_processing_bar.update(bytes_inc)

        self.upload_bar.total = group_report.total_transfer_bytes
        self.upload_bar.set_postfix_str(
            _format_speed_postfix(group_report.total_transfer_bytes_completion_rate), refresh=False
        )
        self.upload_bar.update(transfer_inc)

    def close(self):
        self.data_processing_bar.close()
        self.upload_bar.close()

        if self.per_file_progress:
            for bar in self.current_bars:
                if bar:
                    bar.close()
