# config.py
PAPER_TRADING = True # Set to False when you are ready to go live

# execution.py

# Farz karo yeh aapka real trade function hai jo Polymarket se baat karta hai
def place_real_polymarket_order(market_id, side, price, amount):
    print(f"[LIVE] Placing REAL order: {side} on {market_id} @ {price} for ${amount}")
    # Yahan pe aapka real API call ka logic hoga
    # from polymarket.api import ...
    # ...
    return {"status": "success", "order_id": "123xyz"}

# Yeh hamara naya paper trading ka logger hai (iss pe abhi detail mein baat hogi)
def paper_trade(strategy, market_id, question, side, price, amount):
    # Yeh function hum abhi banayengay
    print(f"[PAPER] Logging FAKE trade: {side} on {market_id} @ {price} for ${amount}")
    # ... CSV logic here ...
    return {"status": "paper_logged"}


# Yeh hai hamara MASTER execution function
def execute_trade(strategy, market_id, question, side, price, amount):
    """
    Master function jo decide karega real trade karni hai ya paper.
    Yeh function aapki strategy files (e.g., theta_sniper.py) se call hoga.
    """
    # config.py se setting import karo
    from config import PAPER_TRADING 

    if PAPER_TRADING:
        print("Paper trading mode is ON. Logging trade, no real money spent.")
        return paper_trade(strategy, market_id, question, side, price, amount)
    else:
        print("WARNING: Live trading mode is ON. Real money will be spent.")
        return place_real_polymarket_order(market_id, side, price, amount)

# strategies/theta_sniper.py (Example call)
import sys
# Add project root to path to allow imports
sys.path.append('../') 
from execution import execute_trade

def run_theta_sniper_strategy(market):
    # ... aapka logic to decide trade ...
    if some_condition_is_met:
        # Seedha master function call karo
        execute_trade(
            strategy='ThetaSniperV1',
            market_id=market['id'],
            question=market['question'],
            side='YES',
            price=0.85, # 85 cents
            amount=10 # $10
        )

# execution.py (or a new file like utils/logger.py)

import csv
from datetime import datetime

def paper_trade(strategy, market_id, question, side, price, amount):
    """Paper trade log karo — real paisa nahi lagega."""
    
    # Step 1: Trade ka data aik dictionary mein jama karo
    trade = {
        'timestamp': datetime.utcnow().isoformat(), # Kab trade li? ISO format standard hai.
        'strategy': strategy,                       # Kaunsi strategy ne li? ThetaSniper? GeoScout?
        'market_id': market_id,                     # Market ka unique ID
        'question': question[:80],                  # Poora question, 80 chars tak.
        'side': side,                               # 'YES' ya 'NO'
        'entry_price': price,                       # Kis price pe li? e.g., 0.85
        'amount': amount,                           # Kitne $ ki position? e.g., 10
        'status': 'open',                           # Shuru mein har trade 'open' hoti hai.
        'exit_price': None,                         # Jab close hogi tab isko fill karengay.
        'pnl': None                                 # Profit/Loss, close honay pe calculate hoga.
    }
    
    # Step 2: CSV file mein data write karo
    # 'a' ka matlab hai 'append' - file ke end mein add karo, overwrite nahi.
    # newline='' zaroori hai, warna CSV mein extra blank rows aati hain.
    with open('paper_trades.csv', 'a', newline='', encoding='utf-8') as f:
        # fieldnames batata hai ke columns kya hongay aur unka order kya hoga.
        writer = csv.DictWriter(f, fieldnames=trade.keys())
        
        # Yeh trick hai: agar file ka size 0 hai (yani file nayi hai),
        # to header (column names) likho. Sirf pehli baar.
        if f.tell() == 0:
            writer.writeheader()
            
        # Asal data ki row likho
        writer.writerow(trade)
    
    print(f"[PAPER] {side} '{question[:40]}...' @ {price*100:.0f}¢ | Amount: ${amount}")
    return trade

📊 Paper Trading → Live Trading Progression
┌──────────────────────────────┐
│ PHASE 1: STRATEGY DESIGN     │
│ (Theoretical)                │
│ - Rules documented           │
│ - Entry/exit criteria clear  │
└────────────┬─────────────────┘
             │
             ▼
┌──────────────────────────────┐
│ PHASE 2: BACKTESTING         │
│ (Historical simulation)       │
│ - 100+ past trades tested    │
│ - Strategy profitable?       │
│ - Drawdown acceptable?       │
└────────────┬─────────────────┘
        ┌────┴────┐
        │ (FAIL)  │ (PASS)
        ▼         ▼
    [REFINE]  ┌──────────────┐
             │ PHASE 3:     │
             │ PAPER TRADE  │
             │ (Live data,  │
             │  no money)   │
             │ - 20+ trades │
             │ - Real data  │
             │ - Algorithm  │
             │   executed OK│
             └────┬─────────┘
                  │
                  ▼
             ┌──────────────┐
             │ PHASE 4:     │
             │ LIVE TRADING │
             │ (Real money) │
             │ - Small size │
             │ - Monitor H24│
             │ - Prepare to │
             │   disable    │
             └──────────────┘