from __future__ import annotations

import copy
import json
import threading
import time
import urllib.error
import urllib.request
from datetime import datetime, timedelta
from typing import Any


class IfindError(RuntimeError):
    pass


class IfindHttpClient:
    BASE_URL = "https://quantapi.51ifind.com/api/v1"
    AUTH_ENDPOINT = "get_access_token"
    AUTH_ERROR_CODES = {-1302, -1303, -1304, -4302, -4303}

    def __init__(
        self,
        refresh_token: str = "",
        access_token: str = "",
        timeout: int = 15,
    ) -> None:
        self.timeout = max(3, int(timeout))
        self._refresh_token = str(refresh_token or "").strip()
        self._access_token = str(access_token or "").strip()
        self._access_expires_at: datetime | None = None
        self._token_lock = threading.Lock()
        self._cache_lock = threading.Lock()
        self._cache: dict[str, dict[str, Any]] = {}

    @property
    def configured(self) -> bool:
        return bool(self._refresh_token or self._access_token)

    def set_credentials(self, refresh_token: str, access_token: str = "") -> None:
        refresh_token = str(refresh_token or "").strip()
        access_token = str(access_token or "").strip()
        with self._token_lock:
            refresh_changed = refresh_token != self._refresh_token
            self._refresh_token = refresh_token
            if access_token or refresh_changed:
                self._access_token = access_token
                self._access_expires_at = None
        if refresh_changed:
            with self._cache_lock:
                self._cache.clear()

    def status(self) -> dict[str, Any]:
        return {
            "configured": self.configured,
            "access_ready": bool(self._access_token),
            "access_expires_at": (
                self._access_expires_at.isoformat(timespec="seconds")
                if self._access_expires_at
                else ""
            ),
        }

    def test_connection(self) -> dict[str, Any]:
        payload = self.real_time(
            "000001.SH",
            ["open", "high", "low", "latest", "preClose"],
            cache_ttl=0,
        )
        return {
            "ok": bool(payload),
            "sample_time": str(payload[0].get("time") or "") if payload else "",
        }

    def real_time(
        self,
        codes: str | list[str],
        indicators: list[str],
        cache_ttl: int = 10,
    ) -> list[dict[str, Any]]:
        code_text = self._codes(codes)
        payload = self._request(
            "real_time_quotation",
            {"codes": code_text, "indicators": ",".join(indicators)},
            cache_key=f"rq:{code_text}:{','.join(indicators)}",
            cache_ttl=cache_ttl,
        )
        return self._table_rows(payload)

    def history(
        self,
        codes: str | list[str],
        indicators: list[str],
        start_date: str,
        end_date: str,
        cache_ttl: int = 300,
    ) -> list[dict[str, Any]]:
        code_text = self._codes(codes)
        payload = self._request(
            "cmd_history_quotation",
            {
                "codes": code_text,
                "indicators": ",".join(indicators),
                "startdate": self._display_date(start_date),
                "enddate": self._display_date(end_date),
                "functionpara": {"CPS": "forward1", "Fill": "Omit"},
            },
            cache_key=f"hq:{code_text}:{start_date}:{end_date}:{','.join(indicators)}",
            cache_ttl=cache_ttl,
        )
        return self._table_rows(payload)

    def intraday(
        self,
        code: str,
        start_time: str,
        end_time: str,
        cache_ttl: int = 20,
    ) -> list[dict[str, Any]]:
        indicators = ["open", "high", "low", "close", "volume", "amount", "avgPrice"]
        payload = self._request(
            "high_frequency",
            {
                "codes": self._codes(code),
                "indicators": ",".join(indicators),
                "starttime": start_time,
                "endtime": end_time,
                "functionpara": {
                    "CPS": "forward1",
                    "Fill": "Previous",
                    "Timeformat": "LocalTime",
                    "Interval": "1",
                    "Limitstart": "09:30:00",
                    "Limitend": "15:00:00",
                },
            },
            cache_key=f"hf:{code}:{start_time}:{end_time}",
            cache_ttl=cache_ttl,
        )
        return self._table_rows(payload)

    def snapshots(
        self,
        codes: str | list[str],
        indicators: list[str],
        start_time: str,
        end_time: str,
        cache_ttl: int = 8,
    ) -> list[dict[str, Any]]:
        code_text = self._codes(codes)
        payload = self._request(
            "snap_shot",
            {
                "codes": code_text,
                "indicators": ",".join(indicators),
                "starttime": start_time,
                "endtime": end_time,
            },
            cache_key=f"ss:{code_text}:{start_time}:{end_time}:{','.join(indicators)}",
            cache_ttl=cache_ttl,
        )
        return self._table_rows(payload)

    def wencai(self, query: str, search_type: str = "stock", cache_ttl: int = 300) -> list[dict[str, Any]]:
        normalized = " ".join(str(query or "").split())
        if not normalized:
            raise IfindError("问财查询不能为空。")
        payload = self._request(
            "smart_stock_picking",
            {"searchstring": normalized, "searchtype": search_type},
            cache_key=f"wc:{search_type}:{normalized}",
            cache_ttl=cache_ttl,
        )
        return self._table_rows(payload)

    def report_query(
        self,
        codes: str | list[str],
        begin_date: str,
        end_date: str,
        cache_ttl: int = 300,
    ) -> list[dict[str, Any]]:
        code_text = self._codes(codes)
        payload = self._request(
            "report_query",
            {
                "codes": code_text,
                "beginrDate": self._display_date(begin_date),
                "endrDate": self._display_date(end_date),
                "outputpara": (
                    "reportDate:Y,thscode:Y,secName:Y,ctime:Y,"
                    "reportTitle:Y,pdfURL:Y,seq:Y"
                ),
            },
            cache_key=f"report:{code_text}:{begin_date}:{end_date}",
            cache_ttl=cache_ttl,
        )
        return self._table_rows(payload)

    def _request(
        self,
        endpoint: str,
        body: dict[str, Any],
        cache_key: str = "",
        cache_ttl: int = 0,
    ) -> dict[str, Any]:
        if not self.configured:
            raise IfindError("iFinD 尚未配置。")
        if cache_key and cache_ttl > 0:
            cached = self._cached(cache_key, cache_ttl)
            if cached is not None:
                return cached

        payload = self._post(endpoint, body, self._ensure_access_token())
        if self._is_auth_error(payload) and self._refresh_token:
            self._invalidate_access_token()
            payload = self._post(endpoint, body, self._ensure_access_token(force=True))
        self._validate_payload(payload)
        if cache_key and cache_ttl > 0:
            with self._cache_lock:
                self._cache[cache_key] = {
                    "created_at": time.time(),
                    "payload": copy.deepcopy(payload),
                }
        return payload

    def _ensure_access_token(self, force: bool = False) -> str:
        with self._token_lock:
            now = datetime.now().astimezone().replace(tzinfo=None)
            token_valid = bool(self._access_token) and (
                self._access_expires_at is None
                or self._access_expires_at > now + timedelta(minutes=2)
            )
            if token_valid and not force:
                return self._access_token
            if not self._refresh_token:
                if self._access_token:
                    return self._access_token
                raise IfindError("iFinD Refresh Token 尚未配置。")
            payload = self._post(self.AUTH_ENDPOINT, {}, "", self._refresh_token)
            self._validate_payload(payload)
            data = payload.get("data") or {}
            token = str(data.get("access_token") or "").strip()
            if not token:
                raise IfindError("iFinD 未返回 Access Token。")
            expires_at = self._parse_datetime(data.get("expired_time"))
            self._access_token = token
            self._access_expires_at = expires_at
            return token

    def _post(
        self,
        endpoint: str,
        body: dict[str, Any],
        access_token: str,
        refresh_token: str = "",
    ) -> dict[str, Any]:
        headers = {
            "Accept": "application/json",
            "Content-Type": "application/json",
            "User-Agent": "XiaobaiReviewWeb/1.0",
            "ifindlang": "cn",
        }
        if access_token:
            headers["access_token"] = access_token
        if refresh_token:
            headers["refresh_token"] = refresh_token
        request = urllib.request.Request(
            f"{self.BASE_URL}/{endpoint}",
            data=json.dumps(body, ensure_ascii=False, separators=(",", ":")).encode("utf-8"),
            headers=headers,
            method="POST",
        )
        try:
            with urllib.request.urlopen(request, timeout=self.timeout) as response:
                payload = json.loads(response.read().decode("utf-8"))
        except urllib.error.HTTPError as exc:
            detail = ""
            try:
                detail_payload = json.loads(exc.read().decode("utf-8", errors="replace"))
                detail = str(detail_payload.get("errmsg") or detail_payload.get("message") or "")
            except (json.JSONDecodeError, OSError):
                pass
            raise IfindError(f"iFinD HTTP {exc.code}{f'：{detail[:160]}' if detail else ''}") from exc
        except (urllib.error.URLError, TimeoutError, OSError, json.JSONDecodeError) as exc:
            raise IfindError("iFinD 数据请求失败。") from exc
        if not isinstance(payload, dict):
            raise IfindError("iFinD 返回格式不正确。")
        return payload

    def _cached(self, key: str, ttl: int) -> dict[str, Any] | None:
        with self._cache_lock:
            cached = self._cache.get(key)
            if not cached:
                return None
            if time.time() - float(cached.get("created_at") or 0) > ttl:
                self._cache.pop(key, None)
                return None
            return copy.deepcopy(cached["payload"])

    def _invalidate_access_token(self) -> None:
        with self._token_lock:
            self._access_token = ""
            self._access_expires_at = None

    @classmethod
    def _validate_payload(cls, payload: dict[str, Any]) -> None:
        try:
            error_code = int(payload.get("errorcode") or 0)
        except (TypeError, ValueError):
            error_code = -1
        if error_code != 0:
            message = str(payload.get("errmsg") or "未知错误")
            raise IfindError(f"iFinD 返回错误：{message[:200]}")

    @classmethod
    def _is_auth_error(cls, payload: dict[str, Any]) -> bool:
        try:
            error_code = int(payload.get("errorcode") or 0)
        except (TypeError, ValueError):
            error_code = 0
        message = str(payload.get("errmsg") or "").casefold()
        return error_code in cls.AUTH_ERROR_CODES or "token" in message or "鉴权" in message

    @staticmethod
    def _table_rows(payload: dict[str, Any]) -> list[dict[str, Any]]:
        tables = payload.get("tables") or []
        if isinstance(tables, dict):
            tables = [tables]
        rows: list[dict[str, Any]] = []
        for block in tables if isinstance(tables, list) else []:
            if not isinstance(block, dict):
                continue
            table = block.get("table") or {}
            if not isinstance(table, dict):
                continue
            times = block.get("time") or []
            codes = block.get("thscode") or block.get("thscodes") or []
            if isinstance(codes, str):
                codes = [codes]
            lengths = [len(value) for value in table.values() if isinstance(value, list)]
            row_count = max(lengths or [len(times) if isinstance(times, list) else 0, 1 if table else 0])
            for index in range(row_count):
                row: dict[str, Any] = {}
                if isinstance(times, list) and index < len(times):
                    row["time"] = times[index]
                if codes:
                    row["thscode"] = codes[index] if index < len(codes) else codes[0]
                for field, values in table.items():
                    if isinstance(values, list):
                        row[field] = values[index] if index < len(values) else None
                    elif index == 0:
                        row[field] = values
                rows.append(row)
        return rows

    @staticmethod
    def _codes(codes: str | list[str]) -> str:
        if isinstance(codes, list):
            values = [str(code or "").strip().upper() for code in codes]
        else:
            values = [part.strip().upper() for part in str(codes or "").split(",")]
        values = [value for value in values if value]
        if not values:
            raise IfindError("iFinD 证券代码不能为空。")
        if len(values) > 100:
            raise IfindError("iFinD 单次证券代码过多。")
        return ",".join(values)

    @staticmethod
    def _display_date(value: str) -> str:
        compact = str(value or "").replace("-", "")
        if len(compact) != 8 or not compact.isdigit():
            raise IfindError("iFinD 日期格式不正确。")
        return f"{compact[:4]}-{compact[4:6]}-{compact[6:]}"

    @staticmethod
    def _parse_datetime(value: Any) -> datetime | None:
        text = str(value or "").strip()
        if not text:
            return None
        try:
            return datetime.fromisoformat(text)
        except ValueError:
            return None