# SPDX-License-Identifier: GPL-3.0-or-later
"""Providers, fallback, rate limits, daily budgets and the quote cache."""

import tempfile
import threading
import unittest
from pathlib import Path

from gnome_portfolio.cache import QuoteCache
from gnome_portfolio.providers import (Instrument, NotSupported, Provider, Quote, QuoteError,
                                       RateLimited, create_providers)
from gnome_portfolio.providers import alphavantage, finnhub, stooq
from gnome_portfolio.quotes import QuoteService

KO = Instrument("KO", "KO", "NYSE")
EQNR = Instrument("EQNR.OL", "EQNR", "OSL")


class AlphaVantageParsing(unittest.TestCase):
    def test_global_quote(self):
        q = alphavantage.parse_global_quote({"Global Quote": {
            "01. symbol": "KO", "05. price": "70.1200", "07. latest trading day": "2026-10-30",
            "08. previous close": "69.5000"}}, KO)
        self.assertEqual((q.price, q.previous_close, q.currency), (70.12, 69.5, "USD"))
        self.assertIsNotNone(q.market_time)

    def test_limits_and_errors(self):
        with self.assertRaises(RateLimited):
            alphavantage.parse_global_quote({"Information": "We have detected your API key "
                "and our standard API rate limit is 25 requests per day."}, KO)
        with self.assertRaises(NotSupported):
            alphavantage.parse_fx({"Information": "This is a premium endpoint."})
        with self.assertRaises(QuoteError):
            alphavantage.parse_global_quote({"Global Quote": {}}, KO)

    def test_series_and_fx(self):
        import time as _t
        today = _t.strftime("%Y-%m-%d")
        payload = {"Time Series (Daily)": {today: {"4. close": "10"},
                                           "2001-01-01": {"4. close": "1"}}}
        q = alphavantage.parse_series(payload, KO, "Time Series (Daily)", 31)
        self.assertEqual([v for _t2, v in q.points], [10.0])
        self.assertEqual(alphavantage.parse_fx(
            {"Realtime Currency Exchange Rate": {"5. Exchange Rate": "10.95"}}), 10.95)


class FinnhubParsing(unittest.TestCase):
    def test_quote(self):
        q = finnhub.parse_quote(200, {"c": 70.5, "pc": 70.0, "t": 1762100000}, KO)
        self.assertEqual((q.price, q.previous_close, q.delay_minutes), (70.5, 70.0, 0))
        self.assertEqual(finnhub.finnhub_symbol("BRK-B"), "BRK.B")

    def test_unknown_and_paid(self):
        with self.assertRaises(QuoteError):
            finnhub.parse_quote(200, {"c": 0, "d": None, "pc": 0, "t": 0}, KO)
        with self.assertRaises(NotSupported):
            finnhub.parse_quote(403, {"error": "You don't have access to this resource."}, KO)


class StooqParsing(unittest.TestCase):
    def test_csv(self):
        pts = stooq.parse_daily_csv("Date,Open,High,Low,Close,Volume\n"
                                    "2026-10-29,1,1,1,69.5,10\n2026-10-30,1,1,1,70,10\n")
        self.assertEqual([v for _t, v in pts], [69.5, 70.0])

    def test_bot_page(self):
        with self.assertRaises(RateLimited):
            stooq.parse_daily_csv("Get your apikey: visit stooq.com/q/d/?s=spy.us&get_apikey")
        with self.assertRaises(QuoteError):
            stooq.parse_daily_csv("No data")


class FakeProvider(Provider):
    """Scriptable provider for service tests."""

    def __init__(self, pid, markets, prices=None, fx=None, fail=None, needs_key=False,
                 key="", daily_limit=None, min_quote_age=0, history=False):
        super().__init__(key)
        self.id, self.name = pid, pid.title()
        self.markets = frozenset(markets)
        self.needs_key = needs_key
        self.prices, self.fx = prices or {}, fx or {}
        self.fail = fail            # None, "limit" or "down"
        self.daily_limit, self.min_quote_age = daily_limit, min_quote_age
        self.supports_fx = bool(fx)
        self.supports_history = history
        self.calls = 0

    def _maybe_fail(self):
        self.calls += 1
        if self.fail == "limit":
            raise RateLimited("limited")
        if self.fail == "down":
            raise QuoteError("down")

    def quote(self, inst):
        self._maybe_fail()
        if inst.symbol not in self.prices:
            raise QuoteError("unknown")
        price, cur = self.prices[inst.symbol]
        return Quote(inst.symbol, inst.ticker + " Inc", cur, price, price - 1)

    def fx_rate(self, a, b):
        self._maybe_fail()
        return self.fx[a + b]


def run_refresh(service, holdings, base="NOK", force=False):
    box, event = [], threading.Event()
    service.refresh(holdings, base, lambda r: (box.append(r), event.set()), force=force)
    assert event.wait(5)
    return box[0]


HOLDINGS = [("KO", "NYSE", "USD"), ("EQNR.OL", "OSL", "NOK")]


def make_service(providers, primary, cache=None, clock=None):
    s = QuoteService(providers={p.id: p for p in providers}, cache=cache,
                     clock=clock or __import__("time").time)
    s.configure(primary=primary)
    return s


class ServiceTests(unittest.TestCase):
    def setUp(self):
        self.yahoo = FakeProvider("yahoo", {"NYSE", "OSL", "STO"},
                                  {"KO": (70.0, "USD"), "EQNR.OL": (260.0, "NOK")},
                                  fx={"USDNOK": 11.0})
        self.av = FakeProvider("alphavantage", {"NYSE"}, {"KO": (71.0, "USD")},
                               fx={"USDNOK": 11.1}, needs_key=True, key="k")
        self.fh = FakeProvider("finnhub", {"NYSE"}, {"KO": (72.0, "USD")}, needs_key=True)

    def test_primary_success(self):
        s = make_service([self.yahoo, self.av, self.fh], "yahoo")
        r = run_refresh(s, HOLDINGS)
        self.assertEqual(r.updated, {"KO", "EQNR.OL"})
        self.assertTrue(r.ok)
        self.assertEqual(s.rate("USD", "NOK"), 11.0)
        self.assertEqual(self.av.calls, 0)
        self.assertEqual(s.quotes["KO"].source, "yahoo")

    def test_fallback_when_rate_limited(self):
        self.yahoo.fail = "limit"
        s = make_service([self.yahoo, self.av, self.fh], "yahoo")
        r = run_refresh(s, HOLDINGS)
        # KO comes from Alpha Vantage; Oslo has no other source and no cache
        self.assertEqual(r.updated, {"KO"})
        self.assertEqual(s.quotes["KO"].source, "alphavantage")
        self.assertIn("EQNR.OL", r.missing)
        self.assertTrue(r.rate_limited)
        self.assertIsNotNone(r.retry_at)
        self.assertEqual(s.rate("USD", "NOK"), 11.1)
        # finnhub has no key, so it is never asked
        self.assertEqual(self.fh.calls, 0)

    def test_cooldown_skips_limited_source(self):
        t = [1000.0]
        self.yahoo.fail = "limit"
        s = make_service([self.yahoo, self.av], "yahoo", clock=lambda: t[0])
        run_refresh(s, [("EQNR.OL", "OSL", "NOK")])
        calls = self.yahoo.calls
        run_refresh(s, [("EQNR.OL", "OSL", "NOK")])
        self.assertEqual(self.yahoo.calls, calls)          # still cooling down
        t[0] += 61
        run_refresh(s, [("EQNR.OL", "OSL", "NOK")])
        self.assertGreater(self.yahoo.calls, calls)        # tried again
        self.assertEqual(s.failures["yahoo"], 2)           # backoff grows
        self.assertGreater(s.cooldown["yahoo"] - t[0], 100)

    def test_cached_values_survive_outage(self):
        with tempfile.TemporaryDirectory() as d:
            cache = QuoteCache(Path(d) / "q.json")
            s = make_service([self.yahoo], "yahoo", cache=cache)
            run_refresh(s, HOLDINGS)
            # new session: everything from disk is stale until refreshed
            self.yahoo.fail = "down"
            s2 = make_service([self.yahoo], "yahoo", cache=cache)
            self.assertEqual(s2.stale, {"KO", "EQNR.OL"})
            self.assertEqual(s2.quotes["EQNR.OL"].price, 260.0)
            r = run_refresh(s2, HOLDINGS)
            self.assertEqual(r.stale, {"KO", "EQNR.OL"})
            self.assertEqual(r.missing, set())
            self.assertEqual(s2.rate("USD", "NOK"), 11.0)     # cached rate kept
            self.yahoo.fail = None
            r = run_refresh(s2, HOLDINGS)
            self.assertTrue(r.ok)
            self.assertEqual(s2.stale, set())

    def test_daily_budget_and_reuse(self):
        self.av.daily_limit, self.av.min_quote_age = 2, 1800
        s = make_service([self.av], "alphavantage")
        r = run_refresh(s, [("KO", "NYSE", "USD")], base="USD")
        self.assertEqual(r.updated, {"KO"})
        r = run_refresh(s, [("KO", "NYSE", "USD")], base="USD")
        self.assertEqual(r.reused, {"KO"})                  # within min_quote_age
        self.assertEqual(s.budget_used("alphavantage"), 1)
        run_refresh(s, [("KO", "NYSE", "USD")], base="USD", force=True)
        r = run_refresh(s, [("KO", "NYSE", "USD")], base="USD", force=True)
        self.assertTrue(r.rate_limited)                     # 2/day used up
        self.assertEqual(r.stale, {"KO"})
        self.assertEqual(self.av.calls, 2)

    def test_fallbacks_off_and_unconfigured(self):
        self.yahoo.fail = "down"
        s = make_service([self.yahoo, self.av], "yahoo")
        s.configure(use_fallbacks=False)
        r = run_refresh(s, [("KO", "NYSE", "USD")], base="USD")
        self.assertEqual(r.missing, {"KO"})
        self.assertEqual(self.av.calls, 0)
        self.assertEqual([p.id for p in s.chain("NYSE")], ["yahoo"])
        s.configure(use_fallbacks=True)
        self.assertEqual([p.id for p in s.chain("NYSE")], ["yahoo", "alphavantage"])
        self.assertEqual([p.id for p in s.chain("OSL")], ["yahoo"])

    def test_inverse_rate(self):
        s = make_service([self.yahoo], "yahoo")
        s.rates["NOKUSD"] = (0.1, 0, "yahoo")
        self.assertAlmostEqual(s.rate("USD", "NOK"), 10.0)

    def test_lookup(self):
        s = make_service([self.yahoo], "yahoo")
        box, ev = [], threading.Event()
        s.lookup("KO", "NYSE", lambda q, e: (box.append((q, e)), ev.set()))
        ev.wait(5)
        self.assertEqual(box[0][0].source, "yahoo")
        self.assertIsNone(box[0][1])


class RealProviderClasses(unittest.TestCase):
    def test_declared_coverage(self):
        ps = create_providers({"alphavantage": "x"})
        self.assertTrue(ps["yahoo"].configured)
        self.assertTrue(ps["alphavantage"].configured)
        self.assertFalse(ps["finnhub"].configured)
        self.assertTrue(all(p.covers("NYSE") for p in ps.values()))
        self.assertEqual([p for p in ps if ps[p].covers("OSL")], ["yahoo"])


if __name__ == "__main__":
    unittest.main()
