Logging

class Dataset:
    """Dataset in a graph."""

    def __init__(self, name: str, point_limit: int | None = None) -> None:
        """Args:
        name: Name of the dataset.
        point_limit: Amount of points allowed in the dataset at a time."""
        self.name = name
        self.points: dict[float, float] = {}
        self.point_limit = point_limit
        self.point_order = []

    def add_point(self, x: float, y: float) -> None:
        """Add a point to the dataset.

        Args:
            x: X value.
            y: Y value."""
        Internal.info(f"{self.point_limit} {len(self.point_order)}")
        if self.point_limit and (len(self.point_order) >= self.point_limit):
            to_del = self.point_order.pop(0)
            del self.points[to_del]

        self.point_order.append(x)
        self.points[x] = y

    def add_points(self, *args: tuple[float, float]) -> None:
        """Add multiple points to the dataset."""
        for i in args:
            self.add_point(*i)

class HeatedProgress(Progress):
    """Progress that changes color based on how close the bar is to completion."""

    def make_tasks_table(self, tasks: Iterable[Task]) -> Table:
        result = super().make_tasks_table(tasks)

        for col in result.columns:
            for cell in col._cells:
                if isinstance(cell, ProgressBar):
                    cell.complete_style = _heat_color(cell.completed)
                elif isinstance(cell, Text):
                    text = str(cell)

                    if "%" not in text:
                        continue

                    cell.stylize(_heat_color(float(text[:-1])))
        return result

class Internal(_Logger):
    """Logger to be seen by view.py developers for debugging purposes."""

    log = internal

class LogPanel(Panel):
    """Panel with limit on number of lines relative to the terminal size."""

    def __init__(self, **kwargs):
        self._lines = [""]
        self._line_index = 0
        super().__init__("", **kwargs)

    def _inc(self):
        self._lines.append("")
        self._line_index += 1

    def write(self, text: str) -> None:
        """Write text to the panel."""
        for i in text:
            if i == "\n":
                self._inc()
            else:
                self._lines[self._line_index] += i

    def __rich_console__(
        self,
        console: Console,
        options: ConsoleOptions,
    ) -> RenderResult:
        height = options.max_height
        width = options.max_width

        while height < len(self._lines):
            self._lines.pop(0)
            self._line_index -= 1

        final_lines = []

        for i in self._lines:
            if len(i) < (width - 3):  # - 3 because the ellipsis
                final_lines.append(i)
            else:
                final_lines.append(f"{i[:width - 7]}...")

        self.renderable = "\n".join(final_lines)

        return super().__rich_console__(console, options)

class LogTable(Table):
    """Table with limit on number of columns relative to the terminal height."""

    def __rich_console__(
        self, console: "Console", options: "ConsoleOptions"
    ) -> "RenderResult":
        height = options.max_height
        while len(self.rows) > (height - 4):
            # - 4 because the header and footer lines
            self.rows.pop(0)
            for i in self.columns:
                i._cells.pop(0)

        return super().__rich_console__(console, options)

class Plot:
    """Plot renderable for rich."""

    def __init__(self, name: str, x: str, y: str) -> None:
        """Args:
        name: Title of the graph.
        x: X label of the graph.
        y: Y label of the graph."""
        plt.xscale("linear")
        plt.yscale("linear")

        self.title = name
        self.x_label = x
        self.y_label = y
        self.datasets: dict[str, Dataset] = {}

    def dataset(self, name: str, *, point_limit: int | None = None) -> Dataset:
        """Generate or create a new dataset.

        Args:
            name: Name of the dataset.
            point_limit: Limit on the number of points to be allowed on the graph at a time. If not set, terminal size divided by 3 is used.
        """
        found = self.datasets.get(name)
        if found:
            return found

        size = os.get_terminal_size().lines // 3

        ds = Dataset(name, point_limit=point_limit or size)
        self.datasets[name] = ds
        return ds

    def _render(self, width: int, height: int) -> None:
        plt.clf()
        plt.plotsize(width, height)

        for ds in self.datasets.values():
            if ds.points:
                plt.plot(
                    [x for x in ds.points.keys()],
                    [y for y in ds.points.values()],
                    label=ds.name,
                )

        plt.title(self.title)
        plt.xlabel(self.x_label)
        plt.ylabel(self.y_label)
        plt.theme("pro")

    def __rich_console__(
        self, console: Console, options: ConsoleOptions
    ) -> RenderResult:
        self._render(options.max_width, options.max_height)
        yield Text.from_ansi(plt.build())

class Service(_Logger):
    """Logger to be seen by the user when the app is running."""

    log = svc