class Execution:
    """Wrapper class for batch trade execution with validation."""

    def __init__(self, api: ExecutionAPI):
        """Initialize execution wrapper with API adapter.

        Args:
            api: ExecutionAPI instance to use for trade execution.

        Raises:
            ConnectionError: If API is not connected.
        """
        self.api = api
        if not self.api.is_connected():
            raise ConnectionError("Execution API is not connected")

    def execute(self, output: List[Tuple[str, int, int, float]], time_step: int) -> List[bool]:
        """Execute all trades from output array with validation.

        Args:
            output: List of trade tuples (stock, shares, flag, price).
            time_step: Current time step.

        Returns:
            List of bools indicating success/failure for each trade.
        """
        results = []

        for trade in output:
            stock, shares, flag, desired_price = trade #the fourth argument is unnecessary just wanted to keep the output object consistent

            # Validate trade tuple
            if not isinstance(stock, str) or not isinstance(shares, int) or not isinstance(flag, int):
                print(f"Invalid trade format: {trade}")
                results.append(False)
                continue

            if shares <= 0:
                print(f"Invalid shares amount: {shares}")
                results.append(False)
                continue

            if flag not in [-1, 1]:
                print(f"Invalid flag: {flag} (must be -1 for sell or 1 for buy)")
                results.append(False)
                continue

            # Execute the trade
            success = self.api.execute_trade(stock, shares, flag, time_step)
            results.append(success)

        return results

    def set_api(self, api: ExecutionAPI):
        """Change execution API adapter at runtime.

        Args:
            api: New ExecutionAPI instance.

        Raises:
            ConnectionError: If new API is not connected.
        """
        self.api = api
        if not self.api.is_connected():
            raise ConnectionError("Execution API is not connected")

class ExecutionAPI(ABC):
    """Abstract base class for execution API implementations."""

    @abstractmethod
    def execute_trade(self, stock: str, num_shares: int, flag: int, time_step: int) -> bool:
        """Execute a single trade.

        Args:
            stock: Stock symbol.
            num_shares: Number of shares to trade.
            flag: 1 for buy, -1 for sell.
            time_step: Current time step.

        Returns:
            True if trade executed successfully, False otherwise.
        """
        pass

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

class MockExecutionAPI(ExecutionAPI):
    """Mock execution API for backtesting. No actual trades executed."""

    def __init__(self):
        """Initialize mock execution API."""
        self.connected = True

    def execute_trade(self, stock: str, num_shares: int, flag: int, time_step: int) -> bool:
        """Mock trade execution. Required for backtesting with historical prices.

        Args:
            stock: Stock symbol.
            num_shares: Number of shares to trade.
            flag: 1 for buy, -1 for sell.
            time_step: Current time step.

        Returns:
            Always returns True (no actual execution).
        """
        return True 

    def is_connected(self) -> bool:
        """Always returns True for mock API."""
        return self.connected

class PaperAlpacaExecutionAPI(ExecutionAPI):
    """Alpaca paper trading execution API implementation."""

    def __init__(self, api_key: str, secret_key: str, base_url: str = None):
        """Initialize Alpaca paper trading API client.

        Args:
            api_key: Alpaca API key.
            secret_key: Alpaca secret key.
            base_url: Optional base URL for API (defaults to paper trading).
        """
        self.api_key = api_key
        self.secret_key = secret_key
        self.base_url = base_url

    def execute_trade(self, stock: str, num_shares: int, flag: int, time_step: int) -> bool:
        """Execute trade via Alpaca paper trading API.

        Args:
            stock: Stock symbol.
            num_shares: Number of shares to trade.
            flag: 1 for buy, -1 for sell.
            time_step: Current time step.

        Returns:
            True if trade executed successfully, False otherwise.
        """
        try:
            # Example implementation:
            # order = self.client.submit_order(
            #     symbol=stock,
            #     qty=shares,
            #     side="buy" if flag == 1 else "sell",
            #     type="market",
            #     time_in_force="day"
            # )
            # return order.status == "filled"
            print(f"[ALPACA] Would execute: {stock}, {num_shares} shares, flag={flag}")
            return True
        except Exception as e:
            print(f"Error executing trade: {e}")
            return False

    def is_connected(self) -> bool:
        """Check Alpaca API connection status."""
        return True

class PolygonExecutionAPI(ExecutionAPI):
    """Polygon.io execution API implementation."""

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

        Args:
            api_key: Polygon.io API key.
        """
        self.api_key = api_key
        self.connected = False
        # Initialize Polygon client here
        # from polygon import RESTClient
        # self.client = RESTClient(api_key)

    def execute_trade(self, stock: str, num_shares: int, flag: int, time_step: int) -> bool:
        """Execute trade via Polygon API.

        Args:
            stock: Stock symbol.
            num_shares: Number of shares to trade.
            flag: 1 for buy, -1 for sell.
            time_step: Current time step.

        Returns:
            True if trade executed successfully, False otherwise.
        """
        try:
            # Example implementation:
            # order = self.client.place_order(
            #     symbol=stock,
            #     qty=shares,
            #     side="buy" if flag == 1 else "sell",
            #     type="market"
            # )
            # return order.status == "filled"
            print(f"[POLYGON] Would execute: {stock}, {num_shares} shares, flag={flag}")
            return True
        except Exception as e:
            print(f"Error executing trade: {e}")
            return False

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