"""
数据获取服务基础架构
处理外部数据源的数据获取
"""

from typing import Dict, Any, Optional
from abc import ABC, abstractmethod
import httpx
import asyncio
from datetime import datetime

from ..schemas.data import (
    FinancialDataResponse,
    MarketDataResponse,
    SymbolValidationResponse,
    DataSourceStatus
)
from ..core.exceptions import (
    DataSourceError,
    APIError,
    SymbolNotFoundError,
    RateLimitError,
    AuthenticationError
)


class DataFetcher(ABC):
    """数据获取服务基类"""
    
    def __init__(self, config: Dict[str, Any]):
        self.config = config
        self.name = config.get("name", "unknown")
        self.timeout = config.get("timeout", 30)
        self.max_retries = config.get("max_retries", 3)
        self.retry_delay = config.get("retry_delay", 1)
    
    @abstractmethod
    async def fetch_financial_data(self, symbol: str, market: str) -> FinancialDataResponse:
        """获取财务数据"""
        pass
    
    @abstractmethod
    async def fetch_market_data(self, symbol: str, market: str) -> MarketDataResponse:
        """获取市场数据"""
        pass
    
    @abstractmethod
    async def validate_symbol(self, symbol: str, market: str) -> SymbolValidationResponse:
        """验证证券代码"""
        pass
    
    async def check_status(self) -> DataSourceStatus:
        """检查数据源状态"""
        start_time = datetime.now()
        try:
            # 尝试进行简单的健康检查
            await self._health_check()
            end_time = datetime.now()
            response_time = int((end_time - start_time).total_seconds() * 1000)
            
            return DataSourceStatus(
                name=self.name,
                is_available=True,
                last_check=end_time,
                response_time_ms=response_time
            )
        except Exception as e:
            end_time = datetime.now()
            return DataSourceStatus(
                name=self.name,
                is_available=False,
                last_check=end_time,
                error_message=str(e)
            )
    
    @abstractmethod
    async def _health_check(self):
        """健康检查实现"""
        pass
    
    async def _retry_request(self, func, *args, **kwargs):
        """重试机制"""
        last_exception = None
        
        for attempt in range(self.max_retries):
            try:
                return await func(*args, **kwargs)
            except (httpx.TimeoutException, httpx.ConnectError) as e:
                last_exception = e
                if attempt < self.max_retries - 1:
                    await asyncio.sleep(self.retry_delay * (2 ** attempt))  # 指数退避
                continue
            except Exception as e:
                # 对于其他类型的异常，不重试
                raise e
        
        # 所有重试都失败了
        raise DataSourceError(
            f"数据源 {self.name} 请求失败，已重试 {self.max_retries} 次",
            self.name,
            {"last_error": str(last_exception)}
        )


class TushareDataFetcher(DataFetcher):
    """Tushare数据获取器"""
    
    def __init__(self, config: Dict[str, Any]):
        super().__init__(config)
        self.token = config.get("api_key") or config.get("token")
        self.base_url = config.get("base_url", "http://api.tushare.pro")
        
        if not self.token:
            raise AuthenticationError("tushare", {"message": "Tushare API token未配置"})
    
    async def fetch_financial_data(self, symbol: str, market: str) -> FinancialDataResponse:
        """获取财务数据"""
        try:
            # 转换证券代码格式
            ts_code = self._convert_symbol_format(symbol, market)
            
            # TODO: 实现实际的Tushare API调用
            # 这里暂时返回模拟数据
            financial_data = await self._retry_request(self._fetch_tushare_financial, ts_code)
            
            return FinancialDataResponse(
                symbol=symbol,
                market=market,
                data_source="tushare",
                last_updated=datetime.now(),
                balance_sheet=financial_data.get("balance_sheet"),
                income_statement=financial_data.get("income_statement"),
                cash_flow=financial_data.get("cash_flow"),
                key_metrics=financial_data.get("key_metrics")
            )
        except Exception as e:
            if isinstance(e, (DataSourceError, APIError)):
                raise
            raise DataSourceError(f"获取财务数据失败: {str(e)}", "tushare")
    
    async def fetch_market_data(self, symbol: str, market: str) -> MarketDataResponse:
        """获取市场数据"""
        try:
            ts_code = self._convert_symbol_format(symbol, market)
            
            # TODO: 实现实际的Tushare API调用
            market_data = await self._retry_request(self._fetch_tushare_market, ts_code)
            
            return MarketDataResponse(
                symbol=symbol,
                market=market,
                data_source="tushare",
                last_updated=datetime.now(),
                price_data=market_data.get("price_data"),
                volume_data=market_data.get("volume_data"),
                technical_indicators=market_data.get("technical_indicators")
            )
        except Exception as e:
            if isinstance(e, (DataSourceError, APIError)):
                raise
            raise DataSourceError(f"获取市场数据失败: {str(e)}", "tushare")
    
    async def validate_symbol(self, symbol: str, market: str) -> SymbolValidationResponse:
        """验证证券代码"""
        try:
            ts_code = self._convert_symbol_format(symbol, market)
            
            # TODO: 实现实际的证券代码验证
            # 暂时模拟验证逻辑
            is_valid = await self._retry_request(self._validate_tushare_symbol, ts_code)
            
            return SymbolValidationResponse(
                symbol=symbol,
                market=market,
                is_valid=is_valid,
                company_name="示例公司" if is_valid else None,
                message="证券代码有效" if is_valid else "证券代码无效"
            )
        except Exception as e:
            return SymbolValidationResponse(
                symbol=symbol,
                market=market,
                is_valid=False,
                message=f"验证失败: {str(e)}"
            )
    
    async def _health_check(self):
        """健康检查"""
        try:
            async with httpx.AsyncClient(timeout=5) as client:
                # 尝试调用一个简单的API来测试连通性
                await self._call_tushare_api(client, "stock_basic", {"limit": 1})
        except Exception as e:
            raise DataSourceError(f"Tushare健康检查失败: {str(e)}", "tushare")
    
    def _convert_symbol_format(self, symbol: str, market: str) -> str:
        """转换证券代码格式为Tushare格式"""
        if market.lower() == "china":
            # 中国股票代码格式转换
            if symbol.startswith("6"):
                return f"{symbol}.SH"  # 上海证券交易所
            elif symbol.startswith(("0", "3")):
                return f"{symbol}.SZ"  # 深圳证券交易所
        return symbol
    
    async def _fetch_tushare_financial(self, ts_code: str) -> Dict[str, Any]:
        """获取Tushare财务数据"""
        async with httpx.AsyncClient(timeout=self.timeout) as client:
            # 获取资产负债表
            balance_sheet_data = await self._call_tushare_api(
                client, "balancesheet", {"ts_code": ts_code, "period": "20231231"}
            )
            
            # 获取利润表
            income_data = await self._call_tushare_api(
                client, "income", {"ts_code": ts_code, "period": "20231231"}
            )
            
            # 获取现金流量表
            cashflow_data = await self._call_tushare_api(
                client, "cashflow", {"ts_code": ts_code, "period": "20231231"}
            )
            
            # 获取基本财务指标
            fina_indicator_data = await self._call_tushare_api(
                client, "fina_indicator", {"ts_code": ts_code, "period": "20231231"}
            )
            
            return {
                "balance_sheet": self._process_balance_sheet(balance_sheet_data),
                "income_statement": self._process_income_statement(income_data),
                "cash_flow": self._process_cash_flow(cashflow_data),
                "key_metrics": self._process_key_metrics(fina_indicator_data)
            }
    
    async def _fetch_tushare_market(self, ts_code: str) -> Dict[str, Any]:
        """获取Tushare市场数据"""
        async with httpx.AsyncClient(timeout=self.timeout) as client:
            # 获取日线数据
            daily_data = await self._call_tushare_api(
                client, "daily", {"ts_code": ts_code, "start_date": "20240101", "end_date": "20241231"}
            )
            
            # 获取基本信息
            stock_basic_data = await self._call_tushare_api(
                client, "stock_basic", {"ts_code": ts_code}
            )
            
            return {
                "price_data": self._process_price_data(daily_data),
                "volume_data": self._process_volume_data(daily_data),
                "technical_indicators": self._calculate_technical_indicators(daily_data),
                "stock_info": self._process_stock_basic(stock_basic_data)
            }
    
    async def _validate_tushare_symbol(self, ts_code: str) -> bool:
        """验证Tushare证券代码"""
        try:
            async with httpx.AsyncClient(timeout=self.timeout) as client:
                result = await self._call_tushare_api(
                    client, "stock_basic", {"ts_code": ts_code}
                )
                return bool(result and len(result.get("items", [])) > 0)
        except Exception:
            return False
    
    async def _call_tushare_api(self, client: httpx.AsyncClient, api_name: str, params: Dict[str, Any]) -> Dict[str, Any]:
        """调用Tushare API"""
        request_data = {
            "api_name": api_name,
            "token": self.token,
            "params": params,
            "fields": ""
        }
        
        try:
            response = await client.post(self.base_url, json=request_data)
            response.raise_for_status()
            
            result = response.json()
            
            if result.get("code") != 0:
                error_msg = result.get("msg", "Unknown error")
                if "权限" in error_msg or "token" in error_msg.lower():
                    raise AuthenticationError("tushare", {"message": error_msg})
                elif "频率" in error_msg or "limit" in error_msg.lower():
                    raise RateLimitError("tushare")
                else:
                    raise APIError(f"Tushare API错误: {error_msg}", result.get("code"), "tushare")
            
            return result.get("data", {})
            
        except httpx.HTTPStatusError as e:
            if e.response.status_code == 401:
                raise AuthenticationError("tushare", {"status_code": e.response.status_code})
            elif e.response.status_code == 429:
                raise RateLimitError("tushare")
            else:
                raise APIError(f"HTTP错误: {e.response.status_code}", e.response.status_code, "tushare")
        except httpx.RequestError as e:
            raise DataSourceError(f"网络请求失败: {str(e)}", "tushare")
    
    def _process_balance_sheet(self, data: Dict[str, Any]) -> Dict[str, Any]:
        """处理资产负债表数据"""
        if not data or not data.get("items"):
            return {}
        
        items = data["items"]
        if not items:
            return {}
        
        # 取最新一期数据
        latest = items[0] if isinstance(items[0], list) else items
        fields = data.get("fields", [])
        
        if isinstance(latest, list) and fields:
            # 将列表数据转换为字典
            balance_data = dict(zip(fields, latest))
        else:
            balance_data = latest
        
        return {
            "total_assets": balance_data.get("total_assets", 0),
            "total_liab": balance_data.get("total_liab", 0),
            "total_hldr_eqy_exc_min_int": balance_data.get("total_hldr_eqy_exc_min_int", 0),
            "monetary_cap": balance_data.get("monetary_cap", 0),
            "accounts_receiv": balance_data.get("accounts_receiv", 0),
            "inventories": balance_data.get("inventories", 0)
        }
    
    def _process_income_statement(self, data: Dict[str, Any]) -> Dict[str, Any]:
        """处理利润表数据"""
        if not data or not data.get("items"):
            return {}
        
        items = data["items"]
        if not items:
            return {}
        
        latest = items[0] if isinstance(items[0], list) else items
        fields = data.get("fields", [])
        
        if isinstance(latest, list) and fields:
            income_data = dict(zip(fields, latest))
        else:
            income_data = latest
        
        return {
            "revenue": income_data.get("revenue", 0),
            "operate_profit": income_data.get("operate_profit", 0),
            "total_profit": income_data.get("total_profit", 0),
            "n_income": income_data.get("n_income", 0),
            "n_income_attr_p": income_data.get("n_income_attr_p", 0),
            "basic_eps": income_data.get("basic_eps", 0)
        }
    
    def _process_cash_flow(self, data: Dict[str, Any]) -> Dict[str, Any]:
        """处理现金流量表数据"""
        if not data or not data.get("items"):
            return {}
        
        items = data["items"]
        if not items:
            return {}
        
        latest = items[0] if isinstance(items[0], list) else items
        fields = data.get("fields", [])
        
        if isinstance(latest, list) and fields:
            cashflow_data = dict(zip(fields, latest))
        else:
            cashflow_data = latest
        
        return {
            "n_cashflow_act": cashflow_data.get("n_cashflow_act", 0),
            "n_cashflow_inv_act": cashflow_data.get("n_cashflow_inv_act", 0),
            "n_cashflow_fin_act": cashflow_data.get("n_cashflow_fin_act", 0),
            "c_cash_equ_end_period": cashflow_data.get("c_cash_equ_end_period", 0)
        }
    
    def _process_key_metrics(self, data: Dict[str, Any]) -> Dict[str, Any]:
        """处理关键财务指标数据"""
        if not data or not data.get("items"):
            return {}
        
        items = data["items"]
        if not items:
            return {}
        
        latest = items[0] if isinstance(items[0], list) else items
        fields = data.get("fields", [])
        
        if isinstance(latest, list) and fields:
            metrics_data = dict(zip(fields, latest))
        else:
            metrics_data = latest
        
        return {
            "pe": metrics_data.get("pe", 0),
            "pb": metrics_data.get("pb", 0),
            "ps": metrics_data.get("ps", 0),
            "roe": metrics_data.get("roe", 0),
            "roa": metrics_data.get("roa", 0),
            "gross_margin": metrics_data.get("gross_margin", 0),
            "debt_to_assets": metrics_data.get("debt_to_assets", 0)
        }
    
    def _process_price_data(self, data: Dict[str, Any]) -> Dict[str, Any]:
        """处理价格数据"""
        if not data or not data.get("items"):
            return {}
        
        items = data["items"]
        if not items:
            return {}
        
        # 取最新一天的数据
        latest = items[0] if isinstance(items[0], list) else items
        fields = data.get("fields", [])
        
        if isinstance(latest, list) and fields:
            price_data = dict(zip(fields, latest))
        else:
            price_data = latest
        
        return {
            "close": price_data.get("close", 0),
            "open": price_data.get("open", 0),
            "high": price_data.get("high", 0),
            "low": price_data.get("low", 0),
            "pre_close": price_data.get("pre_close", 0),
            "change": price_data.get("change", 0),
            "pct_chg": price_data.get("pct_chg", 0)
        }
    
    def _process_volume_data(self, data: Dict[str, Any]) -> Dict[str, Any]:
        """处理成交量数据"""
        if not data or not data.get("items"):
            return {}
        
        items = data["items"]
        if not items:
            return {}
        
        latest = items[0] if isinstance(items[0], list) else items
        fields = data.get("fields", [])
        
        if isinstance(latest, list) and fields:
            volume_data = dict(zip(fields, latest))
        else:
            volume_data = latest
        
        return {
            "vol": volume_data.get("vol", 0),
            "amount": volume_data.get("amount", 0)
        }
    
    def _calculate_technical_indicators(self, data: Dict[str, Any]) -> Dict[str, Any]:
        """计算技术指标"""
        if not data or not data.get("items"):
            return {}
        
        items = data["items"]
        if not items or len(items) < 20:
            return {}
        
        # 简单的移动平均计算
        closes = []
        for item in items[:20]:  # 取最近20天
            if isinstance(item, list):
                fields = data.get("fields", [])
                close_idx = fields.index("close") if "close" in fields else -1
                if close_idx >= 0:
                    closes.append(item[close_idx])
            else:
                closes.append(item.get("close", 0))
        
        if len(closes) >= 5:
            ma_5 = sum(closes[:5]) / 5
        else:
            ma_5 = 0
        
        if len(closes) >= 20:
            ma_20 = sum(closes) / 20
        else:
            ma_20 = 0
        
        return {
            "ma_5": ma_5,
            "ma_20": ma_20,
            "ma_60": 0  # 需要更多数据计算
        }
    
    def _process_stock_basic(self, data: Dict[str, Any]) -> Dict[str, Any]:
        """处理股票基本信息"""
        if not data or not data.get("items"):
            return {}
        
        items = data["items"]
        if not items:
            return {}
        
        latest = items[0] if isinstance(items[0], list) else items
        fields = data.get("fields", [])
        
        if isinstance(latest, list) and fields:
            basic_data = dict(zip(fields, latest))
        else:
            basic_data = latest
        
        return {
            "name": basic_data.get("name", ""),
            "industry": basic_data.get("industry", ""),
            "market": basic_data.get("market", ""),
            "list_date": basic_data.get("list_date", "")
        }


class YahooDataFetcher(DataFetcher):
    """Yahoo Finance数据获取器"""
    
    def __init__(self, config: Dict[str, Any]):
        super().__init__(config)
        self.base_url = config.get("base_url", "https://query1.finance.yahoo.com")
    
    async def fetch_financial_data(self, symbol: str, market: str) -> FinancialDataResponse:
        """获取财务数据"""
        try:
            yahoo_symbol = self._convert_symbol_format(symbol, market)
            
            # TODO: 实现实际的Yahoo Finance API调用
            financial_data = await self._retry_request(self._fetch_yahoo_financial, yahoo_symbol)
            
            return FinancialDataResponse(
                symbol=symbol,
                market=market,
                data_source="yahoo",
                last_updated=datetime.now(),
                balance_sheet=financial_data.get("balance_sheet"),
                income_statement=financial_data.get("income_statement"),
                cash_flow=financial_data.get("cash_flow"),
                key_metrics=financial_data.get("key_metrics")
            )
        except Exception as e:
            if isinstance(e, (DataSourceError, APIError)):
                raise
            raise DataSourceError(f"获取财务数据失败: {str(e)}", "yahoo")
    
    async def fetch_market_data(self, symbol: str, market: str) -> MarketDataResponse:
        """获取市场数据"""
        try:
            yahoo_symbol = self._convert_symbol_format(symbol, market)
            
            # TODO: 实现实际的Yahoo Finance API调用
            market_data = await self._retry_request(self._fetch_yahoo_market, yahoo_symbol)
            
            return MarketDataResponse(
                symbol=symbol,
                market=market,
                data_source="yahoo",
                last_updated=datetime.now(),
                price_data=market_data.get("price_data"),
                volume_data=market_data.get("volume_data"),
                technical_indicators=market_data.get("technical_indicators")
            )
        except Exception as e:
            if isinstance(e, (DataSourceError, APIError)):
                raise
            raise DataSourceError(f"获取市场数据失败: {str(e)}", "yahoo")
    
    async def validate_symbol(self, symbol: str, market: str) -> SymbolValidationResponse:
        """验证证券代码"""
        try:
            yahoo_symbol = self._convert_symbol_format(symbol, market)
            
            # TODO: 实现实际的证券代码验证
            is_valid = await self._retry_request(self._validate_yahoo_symbol, yahoo_symbol)
            
            return SymbolValidationResponse(
                symbol=symbol,
                market=market,
                is_valid=is_valid,
                company_name="Example Company" if is_valid else None,
                message="Symbol is valid" if is_valid else "Symbol not found"
            )
        except Exception as e:
            return SymbolValidationResponse(
                symbol=symbol,
                market=market,
                is_valid=False,
                message=f"Validation failed: {str(e)}"
            )
    
    async def _health_check(self):
        """健康检查"""
        async with httpx.AsyncClient(timeout=self.timeout) as client:
            response = await client.get(f"{self.base_url}/v1/finance/search?q=AAPL")
            if response.status_code != 200:
                raise APIError(f"Yahoo Finance API返回状态码: {response.status_code}", response.status_code, "yahoo")
    
    def _convert_symbol_format(self, symbol: str, market: str) -> str:
        """转换证券代码格式为Yahoo Finance格式"""
        if market.lower() == "hongkong":
            return f"{symbol}.HK"
        elif market.lower() == "japan":
            return f"{symbol}.T"
        elif market.lower() == "china":
            # 中国股票在Yahoo Finance中的格式
            if symbol.startswith("6"):
                return f"{symbol}.SS"  # 上海
            elif symbol.startswith(("0", "3")):
                return f"{symbol}.SZ"  # 深圳
        return symbol
    
    async def _fetch_yahoo_financial(self, yahoo_symbol: str) -> Dict[str, Any]:
        """获取Yahoo Finance财务数据"""
        # TODO: 实现实际的API调用
        return {
            "balance_sheet": {"totalAssets": 2000000},
            "income_statement": {"totalRevenue": 800000},
            "cash_flow": {"operatingCashflow": 300000},
            "key_metrics": {"trailingPE": 18.5}
        }
    
    async def _fetch_yahoo_market(self, yahoo_symbol: str) -> Dict[str, Any]:
        """获取Yahoo Finance市场数据"""
        # TODO: 实现实际的API调用
        return {
            "price_data": {"regularMarketPrice": 150.0, "dayHigh": 155.0, "dayLow": 145.0},
            "volume_data": {"regularMarketVolume": 2000000},
            "technical_indicators": {"fiftyDayAverage": 148.0, "twoHundredDayAverage": 152.0}
        }
    
    async def _validate_yahoo_symbol(self, yahoo_symbol: str) -> bool:
        """验证Yahoo Finance证券代码"""
        # TODO: 实现实际的验证逻辑
        return True


class DataFetcherFactory:
    """数据获取器工厂"""
    
    _fetchers = {
        "tushare": TushareDataFetcher,
        "yahoo": YahooDataFetcher,
    }
    
    @classmethod
    def create_fetcher(cls, data_source: str, config: Dict[str, Any]) -> DataFetcher:
        """创建数据获取器"""
        data_source_lower = data_source.lower()
        
        if data_source_lower not in cls._fetchers:
            raise DataSourceError(
                f"不支持的数据源: {data_source}",
                data_source,
                {"supported_sources": list(cls._fetchers.keys())}
            )
        
        fetcher_class = cls._fetchers[data_source_lower]
        return fetcher_class(config)
    
    @classmethod
    def get_supported_sources(cls) -> list:
        """获取支持的数据源列表"""
        return list(cls._fetchers.keys())
    
    @classmethod
    def register_fetcher(cls, name: str, fetcher_class: type):
        """注册新的数据获取器"""
        if not issubclass(fetcher_class, DataFetcher):
            raise ValueError("数据获取器必须继承自DataFetcher基类")
        cls._fetchers[name.lower()] = fetcher_class