class AlpacaDataAPI(DataAPI):
    """Alpaca Markets data API implementation with caching."""

    def __init__(self): 
        """Initialize Alpaca API client from environment variables."""
        load_dotenv(find_dotenv()) 
        self.api_key = os.getenv("ALPACA_API_KEY")
        self.secret_key = os.getenv("ALPACA_API_SECRET_KEY")
        self.connected = False
        self.initial_time = InitialConditions.get_initial_time()
        self.step_size = InitialConditions.get_time_step_size()
        self.data_client = StockHistoricalDataClient(self.api_key, self.secret_key) #alpaca connection
        self.price_cache = {}

    def get_price(self, stock: str, time_step: int) -> float:
        """Get stock price from Alpaca API with caching.

        Args:
            stock: Stock symbol.
            time_step: Time step index.

        Returns:
            Stock price as float. Falls back to previous cached price on error.
        """

        #checking cache
        key = (stock, time_step)
        if key in self.price_cache:
            return self.price_cache[key][0]

        #converting to alpaca format
        timestamp = self.initial_time + timedelta(seconds=self.step_size * time_step)
        timestamp = timestamp.astimezone(timezone.utc)
        start = timestamp
        end = (timestamp + timedelta(seconds = self.step_size))

        request = StockBarsRequest(
                symbol_or_symbols = stock,
                timeframe = TimeFrame.Day,
                start = start,
                end = end,
                limit = 1
        )

        try:

            bars = self.data_client.get_stock_bars(request) #StockHistoricalDataClient().get_stock_bars(stock, timeframe, start, limit)
            bar = bars[stock][0] #bars can be a multidimensional array since many symbols can be passed. we just use one though
            price = bar.close #price at close of interval
            self.price_cache[key] = (price, bar.timestamp)

            return price

        #connection error if client does not connect
        except Exception as e:
            print(f"could not retrieve price: {e}")
            self.price_cache[key] = self.price_cache[(stock, time_step - 1)] #default back to last cached price
            return self.price_cache[key][0]

    def is_connected(self) -> bool:
        """Check Alpaca API connection status."""
        response = requests.get(self.base_url, self.headers)
        if response.status_code == 200:
            self.connected = True
        return self.connected

class DataAPI(ABC):
    """Abstract base class for data API implementations."""

    @abstractmethod 
    def get_price(self, stock: str, time_step: int) -> float:
        """Get stock price at given time step.

        Args:
            stock: Stock symbol.
            time_step: Time step index.

        Returns:
            Stock price as float.
        """
        pass

    @abstractmethod
    def is_connected(self) -> bool:
        """Check if API connection is active.

        Returns:
            True if connected, False otherwise.
        """
        pass

class PolygonDataAPI(DataAPI):
    """Polygon.io data API implementation."""

    def __init__(self, api_key: str):
        """Initialize Polygon API client.

        Args:
            api_key: Polygon.io API key.
        """
        self.api_key = api_key
        self.connected = False
        self.initial_time = InitialConditions.get_initial_time()
        self.step_size = InitialConditions.get_time_step_size()

    def get_price(self, stock: str, time_step: int) -> float:
        """Get stock price from Polygon API.

        Args:
            stock: Stock symbol.
            time_step: Time step index.

        Returns:
            Stock price as float. Returns 0.0 on error.
        """
        #convert to polygon format
        try:
            timestamp = self.initial_time + (self.step_size * time_step)
            #TODO
            return 0.0
        except Exception as e:
            print(f"could not retrieve price: {e}")
            return 0.0

    def is_connected(self) -> bool:
        """Check Polygon API connection status."""
        #TODO
        return self.connected