Orders: one strategy

import os
from finlab.online.schwab_account import SchwabAccount

# Step 1: Check if environment variables are set
# (Taiwan brokers use their own variables, e.g. SinoPac: SHIOAJI_API_KEY,
#  SHIOAJI_SECRET_KEY, SHIOAJI_CERT_PERSON_ID, SHIOAJI_CERT_PATH, SHIOAJI_CERT_PASSWORD)
required_env_vars = ['SCHWAB_API_KEY', 'SCHWAB_SECRET', 'SCHWAB_TOKEN_PATH']

print("=== Environment Variable Check ===")
missing = [var for var in required_env_vars if not os.environ.get(var)]
for var in required_env_vars:
    print(
        f"{'❌' if var in missing else '✅'} {var}: {'NOT SET' if var in missing else 'set'}"
    )
if missing:
    raise SystemExit("Set the missing variables first")

# Step 2: Check if the token file exists
token_path = os.environ['SCHWAB_TOKEN_PATH']
if not os.path.exists(token_path):
    raise SystemExit(
        f"Token file not found: {token_path}. Create it with schwab-py's login flow."
    )

# Step 3: Attempt connection and catch errors
try:
    acc = SchwabAccount()
    print("✅ Account connected successfully")
    print(f"✅ Cash balance: ${acc.get_cash():,.2f}")
except Exception as e:
    print(f"❌ Connection failed: {e}")
    print("Check the app key, secret and token file, then try again later")

import os
from finlab.online.esun_account import EsunAccount

# Check E.SUN Securities environment variables
required_vars = [
    'ESUN_CONFIG_PATH',
    'ESUN_MARKET_API_KEY',
    'ESUN_ACCOUNT_PASSWORD',
    'ESUN_CERT_PASSWORD',
]

for var in required_vars:
    if not os.environ.get(var):
        print(f"❌ {var} is not set")
        print(
            f"   Reference: https://www.esunsec.com.tw/trading-platforms/api-trading/docs/trading/quick-start/"
        )
        exit(1)

# Check if config.ini exists
config_path = os.environ.get('ESUN_CONFIG_PATH')
if not os.path.exists(config_path):
    print(f"❌ Config file not found: {config_path}")
    exit(1)

try:
    acc = EsunAccount()
    print("✅ E.SUN Securities account connected successfully")
except Exception as e:
    print(f"❌ Connection failed: {e}")
    print("Please verify the contents of config.ini are correct")

from finlab.online.order_executor import OrderExecutor, Position
from finlab.online.schwab_account import SchwabAccount

def safe_order_check(
    position, account, max_stocks=50, max_weight=0.15, min_cash_buffer=0.1
):
    """
    Pre-order safety check function

    Args:
        position: Position object
        account: Broker account object
        max_stocks: Maximum number of holdings (default 50)
        max_weight: Maximum weight per stock (default 15%)
        min_cash_buffer: Minimum cash buffer ratio (default 10%)

    Raises:
        ValueError: Raised when any check fails
    """
    print("=== Pre-Order Safety Check ===\n")

    # Market value of each target holding at the latest price
    # (for Taiwan accounts, multiply by 1,000 shares per lot)
    price = account.get_price([p['symbol'] for p in position])
    values = {p['symbol']: float(p['quantity']) * price[p['symbol']] for p in position}
    total_value = sum(values.values())

    # Check 1: Number of holdings
    print(f"Number of holdings: {len(values)}")
    if len(values) > max_stocks:
        raise ValueError(
            f"❌ Too many holdings ({len(values)}), exceeds limit of {max_stocks}\n"
            f"   Suggestion: use .is_largest(N) to limit the number of selected stocks"
        )
    print(f"✅ Holdings count check passed (<= {max_stocks})\n")

    # Check 2: Single stock weight
    for symbol, value in values.items():
        weight = value / total_value if total_value > 0 else 0
        print(f"  {symbol}: ${value:,.0f} ({weight:.1%})")

        if weight > max_weight:
            raise ValueError(
                f"❌ Single stock weight too high: {symbol} accounts for {weight:.1%}, exceeds limit {max_weight:.0%}\n"
                f"   Suggestion: use the position_limit parameter to cap single stock weight"
            )

    print(f"\n✅ Single stock weight check passed (<= {max_weight:.0%})\n")

    # Check 3: Available funds
    available = account.get_total_balance()
    cash_buffer = available * min_cash_buffer
    print(f"Account value: ${available:,.0f}, target value: ${total_value:,.0f}")

    if total_value > (available - cash_buffer):
        raise ValueError(
            f"❌ Insufficient funds!\n"
            f"   Account value: ${available:,.0f}\n"
            f"   Target value: ${total_value:,.0f}\n"
            f"   Cash buffer: ${cash_buffer:,.0f} (reserve {min_cash_buffer:.0%})\n"
            f"   Suggestion: lower the fund passed to Position.from_report() or add more funds"
        )

    print(f"✅ Funds check passed (reserving {min_cash_buffer:.0%} buffer)\n")
    print("=" * 50)
    print("✅ All safety checks passed, ready to place orders")
    print("=" * 50)

# Usage example
try:
    acc = SchwabAccount()
    position = Position.from_report(report, fund=100_000)

    # Run the safety check
    safe_order_check(position, acc, max_stocks=30, max_weight=0.10)

    # After passing the check, execute orders
    order_executor = OrderExecutor(position, account=acc)

    # Preview first (no actual orders)
    print("\n=== Preview Orders ===")
    order_executor.create_orders(view_only=True)

    # After confirmation, execute orders
    # order_executor.create_orders()  # Uncomment to actually place orders

except ValueError as e:
    print(f"\n{e}")
    print("\nPlease fix the issue before placing orders")

from datetime import datetime
from zoneinfo import ZoneInfo

from finlab.online.order_executor import OrderExecutor

order_executor = OrderExecutor(position, account=acc)

# Step 1: Check the trading session (U.S. regular hours, New York time)
now = datetime.now(ZoneInfo('America/New_York'))
if now.weekday() < 5 and (9, 30) <= (now.hour, now.minute) < (16, 0):
    print("✅ Currently in the regular trading session (09:30-16:00 ET)")
else:
    print("⚠️  Currently outside the regular trading session (09:30-16:00 ET)")

# Step 2: Preview first, then place orders
print("\n=== Preview Orders ===")
order_executor.create_orders(view_only=True)

confirmation = input("\nAfter confirming, type 'YES' to place orders: ")
if confirmation == 'YES':
    try:
        order_executor.create_orders()

        # Step 3: Check the orders that are still open
        print("\n=== Open Orders ===")
        for order_id, order in acc.get_orders().items():
            print(
                f"{order_id} {order.stock_id} {order.action.name} "
                f"{order.filled_quantity}/{order.quantity} {order.status.name}"
            )
    except Exception as e:
        print(f"\n❌ Order placement failed: {e}")
        print(
            "Check the broker's error message, your buying power and the trading session"
        )
else:
    print("Order placement cancelled")

from datetime import datetime
from zoneinfo import ZoneInfo

from finlab.online.order_executor import OrderExecutor, Position

now = datetime.now(ZoneInfo('Asia/Taipei'))
minutes = now.hour * 60 + now.minute

is_intraday_odd_lot = 9 * 60 <= minutes <= 13 * 60 + 30
is_afterhours_odd_lot = 13 * 60 + 40 <= minutes <= 14 * 60 + 30

if not (is_intraday_odd_lot or is_afterhours_odd_lot):
    print("⚠️  Currently outside odd lot trading sessions")
    print(
        "Wait for an odd lot session, or switch to round-lot trading (remove odd_lot=True)"
    )
else:
    position = Position.from_report(report, fund=500_000, odd_lot=True)
    order_executor = OrderExecutor(position, account=acc)
    order_executor.create_orders(view_only=True)  # Preview first
    # order_executor.create_orders()  # Uncomment after confirmation