import yfinance as yf
from typing import Dict, Any
from datetime import datetime

class IndianDataProvider:
    """Handles integration with Indian financial data APIs"""
    
    def __init__(self):
        pass
        
    def get_nse_stock_data(self, symbol: str) -> Dict[str, Any]:
        """Get NSE stock data using Yahoo Finance with direct metric extraction"""
        try:
            # Create ticker with NSE suffix
            ticker = yf.Ticker(f"{symbol}.NS")
            info = ticker.info
            financials = ticker.financials
            balance_sheet = ticker.balance_sheet
            cash_flow = ticker.cashflow
            
            # Extract key metrics directly from info
            current_price = info.get("currentPrice")
            total_revenue = info.get("totalRevenue")
            net_income = info.get("netIncomeToCommon")
            total_debt = info.get("totalDebt")

            # Convert to dict and extract only the first timestamp entry
            def extract_first_entry(df):
                df_dict = df.to_dict()
                if df_dict:
                    first_key = sorted(df_dict.keys())[len(df_dict)-1]
                    return {first_key: df_dict[first_key]}
                return {}
            
            return {
            'success': True,
            'info': info,
            'financials': extract_first_entry(financials) if not financials.empty else {},
            'balance_sheet': extract_first_entry(balance_sheet) if not balance_sheet.empty else {},
            'cash_flow': extract_first_entry(cash_flow) if not cash_flow.empty else {},
            'current_price': current_price,
            'total_revenue': total_revenue,
            'net_income': net_income,
            'total_debt': total_debt,
            'price_source': 'Yahoo Finance'
        }
        except Exception as e:
            return {"success": False, "error": str(e)}
    
    def format_stock_data_for_analysis(self, stock_data: Dict[str, Any]) -> str:
        """Format NSE stock data for compliance analysis"""
        if not stock_data.get('success'):
            return f"Error fetching stock data: {stock_data.get('error', 'Unknown error')}"
        
        try:
            info = stock_data['info']
            financials = stock_data['financials']
            balance_sheet = stock_data['balance_sheet']
            
            # Use directly extracted metrics
            current_price = stock_data.get('current_price')
            total_revenue = stock_data.get('total_revenue')
            net_income = stock_data.get('net_income')
            total_debt = stock_data.get('total_debt')
            
            # Format currency values
            def format_currency(value):
                if value is None:
                    return "N/A"
                return f"₹{value:,.2f}"
            
            def get_total_liabilities(balance_sheet: dict) -> float:
                for timestamp, financials in balance_sheet.items():
                    if 'Total Liabilities Net Minority Interest' in financials:
                        return financials['Total Liabilities Net Minority Interest']
                return None
            
            def get_total_assets(balance_sheet: dict) -> float:
                for timestamp, financials in balance_sheet.items():
                    if 'Total Assets' in financials:
                        return financials['Total Assets']
                return None
            
            total_assets = get_total_assets(balance_sheet)
            total_liabilities = get_total_liabilities(balance_sheet)
            shareholders_equity = total_assets - total_liabilities if total_assets and total_liabilities else None

            def get_ebitda(financials: dict) -> float:
                for timestamp, data in financials.items():
                    if 'EBITDA' in data:
                        return data['EBITDA']
                return None
            
            symbol_ebitda = get_ebitda(financials)

            def get_gross_profit(financials: dict) -> float:
                for timestamp, data in financials.items():
                    if 'Gross Profit' in data:
                        return data['Gross Profit']
                return None
            
            gross_profit = get_gross_profit(financials)

            def get_operating_income(financials: dict) -> float:
                for timestamp, data in financials.items():
                    if 'Operating Income' in data:
                        return data['Operating Income']
                return None

            operating_income = get_operating_income(financials)

            def get_operating_revenue(financials: dict) -> float:
                for timestamp, data in financials.items():
                    if 'Operating Revenue' in data:
                        return data['Operating Revenue']
                return None

            operating_revenue = get_operating_revenue(financials)

            def get_total_equity(balance_sheet: dict) -> float:
                for timestamp, data in balance_sheet.items():
                    if 'Total Equity Gross Minority Interest' in data:
                        return data['Total Equity Gross Minority Interest']
                return None
            
            total_equity = get_total_equity(balance_sheet)
            debt_to_equity = (total_debt / total_equity) if total_debt and total_equity else None
            
            formatted_data = f"""
COMPANY INFORMATION:
Company Name: {info.get('longName', 'N/A')}
Symbol: {info.get('symbol', 'N/A')}
Sector: {info.get('sector', 'N/A')}
Industry: {info.get('industry', 'N/A')}
Market Cap: {format_currency(info.get('marketCap'))}
Employees: {info.get('fullTimeEmployees', 'N/A')}

CURRENT PRICE: {format_currency(current_price)} (Source: Yahoo Finance)

FINANCIAL HIGHLIGHTS:
52 Week High: {format_currency(info.get('fiftyTwoWeekHigh'))}
52 Week Low: {format_currency(info.get('fiftyTwoWeekLow'))}
P/E Ratio: {info.get('trailingPE', 'N/A')}
Book Value: {format_currency(info.get('bookValue'))}
Dividend Yield: {info.get('dividendYield', 'N/A')}%

FINANCIAL STATEMENTS:
Revenue (Latest): {format_currency(total_revenue)}
Net Income (Latest): {format_currency(net_income)}
Total Assets (Latest): {format_currency(total_assets)}
Total Debt (Latest): {format_currency(total_debt)}
Total Equity (Latest): {format_currency(total_equity)}
Debt to Equity Ratio: {(f"{debt_to_equity:.2f}" if debt_to_equity else "N/A")}
Total Liabilities: {format_currency(total_liabilities)}
Shareholders Equity: {format_currency(shareholders_equity)}
EBITDA: {(format_currency(symbol_ebitda) if symbol_ebitda else "N/A")}
Gross Profit: {format_currency(gross_profit)}
Operating Income: {format_currency(operating_income)}
Operating Revenue: {format_currency(operating_revenue)}

BUSINESS SUMMARY:
{info.get('longBusinessSummary', 'N/A')}

GOVERNANCE:
Board Members: {len(info.get('companyOfficers', []))} officers listed
Audit Risk: {info.get('auditRisk', 'N/A')}
Board Risk: {info.get('boardRisk', 'N/A')}
Compensation Risk: {info.get('compensationRisk', 'N/A')}
Shareholder Rights Risk: {info.get('shareHolderRightsRisk', 'N/A')}
Overall Risk: {info.get('overallRisk', 'N/A')}
            """
            
            return formatted_data.strip()
            
        except Exception as e:
            return f"Error formatting stock data: {str(e)}"