# chart.py — price charts, sparklines and the allocation bar
#
# SPDX-License-Identifier: GPL-3.0-or-later

import math
from datetime import datetime

import cairo
from gi.repository import Adw, Gtk, Pango, PangoCairo

from . import formatting

# libadwaita success / destructive colours (light, dark)
_UP = ((0.106, 0.522, 0.325), (0.471, 0.914, 0.671))
_DOWN = ((0.753, 0.110, 0.157), (1.0, 0.576, 0.549))


def trend_rgb(up):
    dark = Adw.StyleManager.get_default().get_dark()
    return (_UP if up else _DOWN)[1 if dark else 0]


def _fg(widget):
    c = widget.get_color()
    return c.red, c.green, c.blue


class PriceChart(Gtk.DrawingArea):
    """A line chart of (unix_time, price) points.

    compact=True draws a bare sparkline for list rows. The full chart
    adds min/max labels, start/end times and a hover read-out.
    """

    def __init__(self, compact=False):
        super().__init__()
        self.compact = compact
        self.points = []
        self.reference = None          # dashed line (previous close or avg cost)
        self.reference_label = ""
        self.time_format = "%H:%M"
        self.message = ""
        self._hover = None
        if compact:
            self.set_size_request(64, 28)
            self.set_valign(Gtk.Align.CENTER)
        else:
            self.set_size_request(-1, 220)
            motion = Gtk.EventControllerMotion()
            motion.connect("motion", self._on_motion)
            motion.connect("leave", self._on_leave)
            self.add_controller(motion)
        self.set_draw_func(self._draw)

    def set_data(self, points, reference=None, reference_label="", time_format="%H:%M"):
        self.points = list(points)
        self.reference = reference
        self.reference_label = reference_label
        self.time_format = time_format
        self.message = ""
        self._hover = None
        self.queue_draw()

    def set_message(self, message):
        self.points = []
        self.message = message
        self.queue_draw()

    # ---- geometry --------------------------------------------------------

    def _frame(self, width, height):
        if self.compact:
            return 1, 2, width - 2, height - 4
        return 0, 14, width - 64, height - 40     # left, top, w, h (room for labels)

    def _x(self, i, left, w):
        n = len(self.points)
        return left + (w * i / (n - 1) if n > 1 else w / 2)

    def _on_motion(self, _ctrl, x, _y):
        if len(self.points) < 2:
            return
        left, _top, w, _h = self._frame(self.get_width(), self.get_height())
        i = round((x - left) / w * (len(self.points) - 1))
        i = max(0, min(len(self.points) - 1, i))
        if i != self._hover:
            self._hover = i
            self.queue_draw()

    def _on_leave(self, _ctrl):
        self._hover = None
        self.queue_draw()

    def _text(self, cr, text, x, y, rgb, alpha=0.7, align="left"):
        layout = self.create_pango_layout(text)
        font = self.get_pango_context().get_font_description().copy()
        font.set_size(int((font.get_size() or 11 * Pango.SCALE) * 0.82))
        layout.set_font_description(font)
        tw, th = layout.get_pixel_size()
        if align == "right":
            x -= tw
        elif align == "center":
            x -= tw / 2
        x = max(0, min(self.get_width() - tw, x))
        cr.set_source_rgba(*rgb, alpha)
        cr.move_to(x, y - th / 2)
        PangoCairo.show_layout(cr, layout)
        return tw, th

    # ---- drawing ---------------------------------------------------------

    def _draw(self, _area, cr, width, height):
        fg = _fg(self)
        if len(self.points) < 2:
            if not self.compact and self.message:
                self._text(cr, self.message, width / 2, height / 2, fg, 0.55, "center")
            return

        values = [v for _t, v in self.points]
        lo, hi = min(values), max(values)
        if self.reference is not None:
            lo, hi = min(lo, self.reference), max(hi, self.reference)
        if math.isclose(lo, hi):
            pad = abs(hi) * 0.01 or 1.0
            lo, hi = lo - pad, hi + pad

        left, top, w, h = self._frame(width, height)

        def y(v):
            return top + (hi - v) / (hi - lo) * h

        start = self.reference if self.reference is not None and self.compact else values[0]
        rgb = trend_rgb(values[-1] >= start)

        # area fill
        cr.move_to(self._x(0, left, w), y(values[0]))
        for i, v in enumerate(values[1:], 1):
            cr.line_to(self._x(i, left, w), y(v))
        line = cr.copy_path()
        cr.line_to(self._x(len(values) - 1, left, w), top + h)
        cr.line_to(self._x(0, left, w), top + h)
        cr.close_path()
        gradient = cairo.LinearGradient(0, top, 0, top + h)
        gradient.add_color_stop_rgba(0, *rgb, 0.28 if not self.compact else 0.22)
        gradient.add_color_stop_rgba(1, *rgb, 0.0)
        cr.set_source(gradient)
        cr.fill()

        # reference line
        if self.reference is not None:
            ry = round(y(self.reference)) + 0.5
            cr.set_source_rgba(*fg, 0.35)
            cr.set_line_width(1)
            cr.set_dash([3, 3])
            cr.move_to(left, ry)
            cr.line_to(left + w, ry)
            cr.stroke()
            cr.set_dash([])
            if not self.compact:
                label = self.reference_label or formatting.price(self.reference)
                self._text(cr, label, left + w + 6, ry, fg, 0.6)

        # price line
        cr.new_path()
        cr.append_path(line)
        cr.set_source_rgb(*rgb)
        cr.set_line_width(1.5 if self.compact else 2)
        cr.set_line_join(cairo.LINE_JOIN_ROUND)
        cr.stroke()

        if self.compact:
            return

        # high / low labels and time axis
        self._text(cr, formatting.price(hi), left + w + 6, top, fg, 0.55)
        self._text(cr, formatting.price(lo), left + w + 6, top + h, fg, 0.55)
        t0 = datetime.fromtimestamp(self.points[0][0]).strftime(self.time_format)
        t1 = datetime.fromtimestamp(self.points[-1][0]).strftime(self.time_format)
        self._text(cr, t0, left, height - 10, fg, 0.55)
        self._text(cr, t1, left + w, height - 10, fg, 0.55, "right")

        if self._hover is not None:
            t, v = self.points[self._hover]
            hx, hy = self._x(self._hover, left, w), y(v)
            cr.set_source_rgba(*fg, 0.3)
            cr.set_line_width(1)
            cr.move_to(round(hx) + 0.5, top)
            cr.line_to(round(hx) + 0.5, top + h)
            cr.stroke()
            cr.set_source_rgb(*rgb)
            cr.arc(hx, hy, 4, 0, 2 * math.pi)
            cr.fill()
            when = datetime.fromtimestamp(t).strftime(self.time_format)
            self._text(cr, f"{formatting.price(v)}  ·  {when}", hx, top - 6, fg, 0.9, "center")


class AllocationBar(Gtk.DrawingArea):
    """Horizontal stacked bar of portfolio value per exchange."""

    def __init__(self):
        super().__init__()
        self.parts = []            # [(rgb, fraction)]
        self.set_size_request(-1, 10)
        self.set_draw_func(self._draw)

    def set_parts(self, parts):
        self.parts = parts
        self.queue_draw()

    def _draw(self, _area, cr, width, height):
        radius = height / 2
        cr.new_sub_path()
        cr.arc(radius, radius, radius, math.pi / 2, 3 * math.pi / 2)
        cr.arc(width - radius, radius, radius, -math.pi / 2, math.pi / 2)
        cr.close_path()
        cr.clip()
        fg = _fg(self)
        cr.set_source_rgba(*fg, 0.1)
        cr.paint()
        x = 0.0
        for rgb, fraction in self.parts:
            w = width * fraction
            cr.set_source_rgb(*rgb)
            cr.rectangle(x, 0, w, height)
            cr.fill()
            x += w
        # punch thin gaps between the parts
        cr.set_operator(cairo.OPERATOR_CLEAR)
        x = 0.0
        for _rgb, fraction in self.parts[:-1]:
            x += width * fraction
            cr.rectangle(x - 1, 0, 2, height)
            cr.fill()
        cr.set_operator(cairo.OPERATOR_OVER)


class Dot(Gtk.DrawingArea):
    def __init__(self, rgb, size=10):
        super().__init__(valign=Gtk.Align.CENTER)
        self.rgb = rgb
        self.set_size_request(size, size)
        self.set_draw_func(self._draw)

    def _draw(self, _area, cr, width, height):
        cr.set_source_rgb(*self.rgb)
        cr.arc(width / 2, height / 2, min(width, height) / 2, 0, 2 * math.pi)
        cr.fill()
