1"""
2Twelve Data Time Series Tools — Historical OHLCV data for stocks and forex.
3 
4Provides tools for fetching historical price data and end-of-day prices.
5"""
6 
7import logging
8 
9from core.tool import BaseTool, ToolContext, ToolResult
10from .client import get_client, handle_api_error, INTERVALS
11 
12logger = logging.getLogger(__name__)
13 
14 
15class TwelveDataTimeSeriesTools(BaseTool):
16    """Get historical OHLCV time series data."""
17 
18    @property
19    def name(self) -> str:
20        return "twelvedata_time_series"
21 
22    @property
23    def description(self) -> str:
24        return """Get historical OHLCV (Open, High, Low, Close, Volume) time series data for stocks and forex pairs.
25 
26Use this for historical price analysis, backtesting, and charting. Supports multiple intervals from 1-minute to monthly data.
27 
28Parameters:
29- symbol: Stock symbol (e.g., AAPL, MSFT, TSLA) or forex pair (e.g., EUR/USD, GBP/JPY)
30- interval: Time interval - 1min, 5min, 15min, 30min, 1h, 4h, 1day, 1week, 1month (default: 1day)
31- outputsize: Number of data points to return (1-5000, default: 30). Common values: 30 (compact), 100, 500, 5000 (maximum)
32- start_date: (optional) Start date in YYYY-MM-DD format
33- end_date: (optional) End date in YYYY-MM-DD format
34- prepost: (optional) Include pre/post-market data when available (US/Cboe Europe, Pro+ only)
35 
36Returns: Historical OHLCV data with metadata including symbol, exchange, currency, and interval"""
37 
38    @property
39    def parameters(self) -> dict:
40        return {
41            "type": "object",
42            "properties": {
43                "symbol": {
44                    "type": "string",
45                    "description": "Stock symbol (AAPL, MSFT) or forex pair (EUR/USD, GBP/JPY)",
46                },
47                "interval": {
48                    "type": "string",
49                    "description": "Time interval: 1min, 5min, 15min, 30min, 45min, 1h, 2h, 4h, 8h, 1day, 1week, 1month (default: 1day)",
50                    "enum": INTERVALS,
51                },
52                "outputsize": {
53                    "type": "integer",
54                    "description": "Number of data points to return (1-5000). Default 30.",
55                    "minimum": 1,
56                    "maximum": 5000,
57                },
58                "start_date": {
59                    "type": "string",
60                    "description": "Start date in YYYY-MM-DD format (optional)",
61                },
62                "end_date": {
63                    "type": "string",
64                    "description": "End date in YYYY-MM-DD format (optional)",
65                },
66                "prepost": {
67                    "type": "boolean",
68                    "description": "Include pre/post-market data when available (US/Cboe Europe, Pro+ only)",
69                },
70            },
71            "required": ["symbol"],
72        }
73 
74    async def execute(
75        self,
76        ctx: ToolContext,
77        symbol: str = "",
78        interval: str = "1day",
79        outputsize: int = 30,
80        start_date: str = "",
81        end_date: str = "",
82        prepost: bool = False,
83        **kwargs,
84    ) -> ToolResult:
85        if not symbol:
86            return ToolResult(success=False, error="'symbol' is required")
87        if interval not in INTERVALS:
88            return ToolResult(success=False, error=f"Invalid interval '{interval}'. Must be one of: {', '.join(INTERVALS)}")
89        try:
90            data = await get_client().get_time_series(
91                symbol=symbol,
92                interval=interval,
93                outputsize=outputsize,
94                start_date=start_date if start_date else None,
95                end_date=end_date if end_date else None,
96                prepost=prepost,
97            )
98            if data.get("status") == "error":
99                return ToolResult(success=False, error=f"API Error: {data.get('message', 'Unknown error')}")
100            return ToolResult(success=True, output=data)
101        except Exception as e:
102            return handle_api_error(e)
103 
104 
105class TwelveDataPriceTool(BaseTool):
106    """Get latest trading price for a stock or forex pair."""
107 
108    @property
109    def name(self) -> str:
110        return "twelvedata_price"
111 
112    @property
113    def description(self) -> str:
114        return """Get the latest available trading price for a stock or forex pair.
115 
116This is a lightweight endpoint for quick price checks without full quote data.
117 
118Parameters:
119- symbol: Stock symbol (AAPL, MSFT) or forex pair (EUR/USD, GBP/JPY)
120- prepost: (optional) Include pre/post-market data when available (US/Cboe Europe, Pro+ only)
121 
122Returns: Current price value"""
123 
124    @property
125    def parameters(self) -> dict:
126        return {
127            "type": "object",
128            "properties": {
129                "symbol": {
130                    "type": "string",
131                    "description": "Stock symbol or forex pair",
132                },
133                "prepost": {
134                    "type": "boolean",
135                    "description": "Include pre/post-market data when available (US/Cboe Europe, Pro+ only)",
136                },
137            },
138            "required": ["symbol"],
139        }
140 
141    async def execute(self, ctx: ToolContext, symbol: str = "", prepost: bool = False, **kwargs) -> ToolResult:
142        if not symbol:
143            return ToolResult(success=False, error="'symbol' is required")
144        try:
145            data = await get_client().get_price(symbol=symbol, prepost=prepost)
146            if data.get("status") == "error":
147                return ToolResult(success=False, error=f"API Error: {data.get('message', 'Unknown error')}")
148            return ToolResult(success=True, output=data)
149        except Exception as e:
150            return handle_api_error(e)
151 
152 
153class TwelveDataEODTool(BaseTool):
154    """Get end-of-day closing price for a stock or forex pair."""
155 
156    @property
157    def name(self) -> str:
158        return "twelvedata_eod"
159 
160    @property
161    def description(self) -> str:
162        return """Get end-of-day (EOD) closing price for a stock or forex pair.
163 
164Useful for daily analysis and reports. Returns the closing price for the most recent trading day or a specific date.
165 
166Parameters:
167- symbol: Stock symbol (AAPL, MSFT) or forex pair (EUR/USD, GBP/JPY)
168- date: (optional) Specific date in YYYY-MM-DD format (defaults to latest available)
169- prepost: (optional) Include pre/post-market data when available (US/Cboe Europe, Pro+ only)
170 
171Returns: EOD price data with close, high, low, open, volume"""
172 
173    @property
174    def parameters(self) -> dict:
175        return {
176            "type": "object",
177            "properties": {
178                "symbol": {
179                    "type": "string",
180                    "description": "Stock symbol or forex pair",
181                },
182                "date": {
183                    "type": "string",
184                    "description": "Specific date in YYYY-MM-DD format (optional)",
185                },
186                "prepost": {
187                    "type": "boolean",
188                    "description": "Include pre/post-market data when available (US/Cboe Europe, Pro+ only)",
189                },
190            },
191            "required": ["symbol"],
192        }
193 
194    async def execute(self, ctx: ToolContext, symbol: str = "", date: str = "", prepost: bool = False, **kwargs) -> ToolResult:
195        if not symbol:
196            return ToolResult(success=False, error="'symbol' is required")
197        try:
198            data = await get_client().get_eod(
199                symbol=symbol,
200                date=date if date else None,
201                prepost=prepost,
202            )
203            if data.get("status") == "error":
204                return ToolResult(success=False, error=f"API Error: {data.get('message', 'Unknown error')}")
205            return ToolResult(success=True, output=data)
206        except Exception as e:
207            return handle_api_error(e)
208