import os
import time
import sqlite3
import threading
from datetime import datetime, timedelta

import requests
from flask import Flask, request, jsonify

app = Flask(__name__)

# ---- Config ----
SHARED_SECRET = os.environ.get("PROXY_SECRET", "")
DB_PATH = os.environ.get("DB_PATH", "/data/cache.db")
CURRENT_TTL_SECONDS = 15 * 60  # re-check "today" every 15 min in case NAV just posted

_db_lock = threading.Lock()

def get_db():
    conn = sqlite3.connect(DB_PATH)
    conn.execute("""
        CREATE TABLE IF NOT EXISTS historical_cache (
            ticker TEXT NOT NULL,
            requested_date TEXT NOT NULL,
            resolved_date TEXT NOT NULL,
            price REAL NOT NULL,
            PRIMARY KEY (ticker, requested_date)
        )
    """)
    return conn

_current_cache = {}   # ticker -> (price, resolved_date, date, time, fetched_at)
_current_cache_lock = threading.Lock()


def check_auth():
    key = request.args.get("key", "")
    return bool(SHARED_SECRET) and key == SHARED_SECRET


def fetch_yahoo_price(ticker, target_date):
    """Ask Yahoo for the last trading-day close on or before target_date."""
    period2 = int((target_date + timedelta(days=1)).timestamp())
    period1 = int((target_date - timedelta(days=10)).timestamp())

    url = f"https://query1.finance.yahoo.com/v8/finance/chart/{ticker}"
    headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"}
    r = requests.get(
        url,
        params={"period1": period1, "period2": period2, "interval": "1d"},
        headers=headers,
        timeout=10
    )

    if r.status_code != 200:
        return None, f"yahoo http {r.status_code}"

    data = r.json()

    try:
        result = data["chart"]["result"][0]
        timestamps = result["timestamp"]
        closes = result["indicators"]["quote"][0]["close"]
        meta = result.get("meta", {})
    except (KeyError, IndexError, TypeError):
        return None, "no historical data"

    # Yahoo's timestamp for the latest regular-market update
    market_timestamp = meta.get("regularMarketTime")

    if market_timestamp:
        market_datetime = datetime.utcfromtimestamp(market_timestamp)
        market_date = market_datetime.strftime("%Y-%m-%d")
        market_time = market_datetime.strftime("%H:%M:%S")
    else:
        market_date = None
        market_time = None

    best = None

    for ts, close in zip(timestamps, closes):
        if close is None:
            continue

        day = datetime.utcfromtimestamp(ts)

        if day.date() <= target_date.date():
            if best is None or day > best[0]:
                best = (day, close)

    if best is None:
        return None, "no trading day found in window"

    return {
        "resolved_date": best[0].strftime("%Y-%m-%d"),
        "price": round(best[1], 4),
        "date": market_date,
        "time": market_time
    }, None


@app.route("/current")
def current_price():
    if not check_auth():
        return jsonify({"error": "unauthorized"}), 401

    ticker = request.args.get("ticker", "").upper().strip()

    if not ticker:
        return jsonify({"error": "missing ticker"}), 400

    now = time.time()

    with _current_cache_lock:
        cached = _current_cache.get(ticker)

        if cached and (now - cached[4]) < CURRENT_TTL_SECONDS:
            return jsonify({
                "ticker": ticker,
                "price": cached[0],
                "resolved_date": cached[1],
                "cached": True,
                "date": cached[2],
                "time": cached[3]
            })

    result, err = fetch_yahoo_price(ticker, datetime.utcnow())

    if err:
        return jsonify({"ticker": ticker, "error": err}), 502

    with _current_cache_lock:
        _current_cache[ticker] = (
            result["price"],
            result["resolved_date"],
            result["date"],
            result["time"],
            now
        )

    return jsonify({
        "ticker": ticker,
        "price": result["price"],
        "resolved_date": result["resolved_date"],
        "cached": False,
        "date": result["date"],
        "time": result["time"]
    })


@app.route("/historical")
def historical_price():
    if not check_auth():
        return jsonify({"error": "unauthorized"}), 401

    ticker = request.args.get("ticker", "").upper().strip()
    date_str = request.args.get("date", "").strip()

    if not ticker or not date_str:
        return jsonify({"error": "missing ticker or date"}), 400

    try:
        target_date = datetime.strptime(date_str, "%Y-%m-%d")
    except ValueError:
        return jsonify({"error": "date must be YYYY-MM-DD"}), 400

    # If someone asks "historical" for today/future,
    # treat it like /current instead
    if target_date.date() >= datetime.utcnow().date():
        return current_price()

    with _db_lock:
        conn = get_db()

        row = conn.execute(
            "SELECT resolved_date, price FROM historical_cache WHERE ticker=? AND requested_date=?",
            (ticker, date_str),
        ).fetchone()

        conn.close()

    if row:
        return jsonify({
            "ticker": ticker,
            "requested_date": date_str,
            "resolved_date": row[0],
            "price": row[1],
            "cached": True
        })

    result, err = fetch_yahoo_price(ticker, target_date)

    if err:
        return jsonify({"ticker": ticker, "error": err}), 502

    with _db_lock:
        conn = get_db()

        conn.execute(
            "INSERT OR REPLACE INTO historical_cache "
            "(ticker, requested_date, resolved_date, price) "
            "VALUES (?, ?, ?, ?)",
            (
                ticker,
                date_str,
                result["resolved_date"],
                result["price"]
            ),
        )

        conn.commit()
        conn.close()

    return jsonify({
        "ticker": ticker,
        "requested_date": date_str,
        "resolved_date": result["resolved_date"],
        "price": result["price"],
        "cached": False
    })


@app.route("/health")
def health():
    return jsonify({"status": "ok"})


if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5005)