import time

def fetch_market_price(market_id):
    # Imagine this function calls an API
    # For now, we'll simulate it
    print(f"API CALL: Fetching price for {market_id}...")
    # ... API call logic here ...
    return 150.50 # Dummy price

def analyze_with_ai(price):
    # Imagine this calls Gemini/Haiku - costs money!
    print(f"AI CALL: Analyzing price {price}...")
    # ... AI analysis logic here ...
    return "HOLD"

# The "Paise Zaya Karo" Loop
while True:
    price = fetch_market_price("PSX-FFC")
    decision = analyze_with_ai(price)
    print(f"Decision for FFC: {decision}")
    time.sleep(60) # Har minute call ho rahi hai!

# CODE EXPLANATION STARTS HERE
# ==============================

from datetime import datetime, timezone, timedelta

# Yeh hai humara in-memory cache. Simple Python dictionary.
# Real world projects mein, jaise hamare Polymarket Oracle mein,
# yeh thora complex ho sakta hai, but concept yehi hai.
_cache = {}

def should_reanalyze(market_id, current_price, min_hours=4, min_change=2.0):
    """
    Kya is market ko dobara analyze karna chahiye?
    
    Args:
        market_id (str): Market ka unique identifier, e.g., "KSE-100"
        current_price (float): Abhi ka taza price from data source.
        min_hours (int): Kitne ghante baad force re-analysis karna hai.
        min_change (float): Kitne percent price change pe re-analysis karna hai.
    """
    # Step 1: Check karo ke market cache mein hai bhi ya nahi.
    if market_id not in _cache:
        print(f"DEBUG: '{market_id}' not in cache. First time analysis.")
        return True  # Pehli baar dekh rahe hain, toh zaroor analyze karo.

    # Step 2: Agar cache mein hai, toh purana data nikalo.
    last = _cache[market_id]
    last_price = last['price']
    last_timestamp = last['timestamp']
    
    # Step 3: Time difference nikalo (ghanton mein).
    # Hum timezone.utc istemal kar rahe hain to avoid any timezone confusion. Hamesha UTC use karo.
    hours_since = (datetime.now(timezone.utc) - last_timestamp).total_seconds() / 3600
    
    # Step 4: Price difference nikalo (percentage mein).
    # abs() ensures ke change positive ho, chahe price upar jaye ya neeche.
    if last_price == 0: # Zero se division se bachne ke liye
        price_change_percent = float('inf') if current_price > 0 else 0.0
    else:
        price_change_percent = (abs(current_price - last_price) / last_price) * 100
    
    print(f"DEBUG: '{market_id}' | Hours since last analysis: {hours_since:.2f} | Price change: {price_change_percent:.2f}%")

    # Step 5: The Golden Rule. Asal faisla yahan hota hai.
    # Agar 4 ghante se zyada ho gaye HAIN, YA price 2% se zyada change hua HAI.
    if hours_since >= min_hours or price_change_percent >= min_change:
        print(f"DEBUG: Re-analyzing '{market_id}'. Reason: Time threshold ({hours_since:.2f}h >= {min_hours}h) OR Price threshold ({price_change_percent:.2f}% >= {min_change}%)")
        return True
    
    # Step 6: Agar upar wali condition nahi chali, iska matlab market stagnant hai.
    print(f"DEBUG: Skipping analysis for '{market_id}'. Market is stagnant.")
    return False  # Skip karo, paise bachao.

def update_cache(market_id, price):
    """
    Jab bhi hum successfully analyze karte hain, hum cache ko update karte hain.
    """
    print(f"DEBUG: Updating cache for '{market_id}' with price {price}.")
    _cache[market_id] = {
        'price': price,
        'timestamp': datetime.now(timezone.utc)
    }

# ============================
# CODE EXPLANATION ENDS HERE

📊 Smart Caching vs Naive API Calls
┌──────────────────────────────────┐
│ WITHOUT CACHE (Inefficient)      │
│                                  │
│ Loop iteration 1: Fetch markets  │
│ → API CALL (#1)                  │
│ Loop iteration 2: Fetch markets  │
│ → API CALL (#2) [Duplicate!]     │
│ Loop iteration 3: Fetch markets  │
│ → API CALL (#3) [Duplicate!]     │
│                                  │
│ Total: 3 API calls for same data │
└──────────────────────────────────┘

┌──────────────────────────────────┐
│ WITH CACHE (Efficient)           │
│                                  │
│ Loop iteration 1: Fetch markets  │
│ → API CALL (#1)                  │
│ → Store in cache (TTL: 60s)      │
│ Loop iteration 2: Fetch markets  │
│ → Cache HIT (return cached data) │
│ Loop iteration 3: Fetch markets  │
│ → Cache HIT (return cached data) │
│                                  │
│ Total: 1 API call + 2 cache hits │
│ Savings: 66% fewer API calls     │
└──────────────────────────────────┘